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,
+                                      const Instance& owner_mirror);
+static RawInstance* CreateLibraryMirror(const Library& lib);
+static RawInstance* CreateMethodMirror(const Function& func,
+                                       const Instance& owner_mirror);

[siva, 2013/07/18 20:38:45]

Why are these forward declarations needed?

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

Are not needed anymore. (At some point code was ordered differently.)

+
 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 459 matching lines @@
       Dart_New(mirror_type, Dart_Null(), ARRAY_SIZE(args), args);
   return mirror;
 }
 
 
 static Dart_Handle CreateMemberMap(Dart_Handle owner, Dart_Handle owner_mirror);
 static Dart_Handle CreateConstructorMap(Dart_Handle owner,
                                         Dart_Handle owner_mirror);
 
 
-static Dart_Handle CreateClassMirror(Dart_Handle intf,
-                                     Dart_Handle intf_name,
-                                     Dart_Handle lib,
-                                     Dart_Handle lib_mirror) {
+static Dart_Handle CreateClassMirrorUsingApi(Dart_Handle intf,
+                                             Dart_Handle intf_name,
+                                             Dart_Handle lib,
+                                             Dart_Handle lib_mirror) {
   ASSERT(Dart_IsClass(intf));
   if (Dart_ClassIsTypedef(intf)) {
     // This class is actually a typedef.  Represent it specially in
     // reflection.
     return CreateTypedefMirror(intf, intf_name, lib, lib_mirror);
   }
 
   Dart_Handle cls_name = NewString("_LocalClassMirrorImpl");
   Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
   if (Dart_IsError(type)) {
@@ skipping 37 matching lines @@
     CreateLazyMirror(default_class),
     member_map,
     constructor_map,
     type_var_map,
   };
   Dart_Handle mirror = Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
   return mirror;
 }
 
 
-static Dart_Handle CreateMethodMirror(Dart_Handle func,
-                                      Dart_Handle owner_mirror) {
+static Dart_Handle CreateMethodMirrorUsingApi(Dart_Handle func,
+                                              Dart_Handle owner_mirror) {
   // TODO(11742): Unwrapping is needed until the whole method is converted.
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Function& func_obj = Api::UnwrapFunctionHandle(isolate, func);
 
   Dart_Handle mirror_cls_name = NewString("_LocalMethodMirrorImpl");
   Dart_Handle mirror_type = Dart_GetType(MirrorLib(), mirror_cls_name, 0, NULL);
   if (Dart_IsError(mirror_type)) {
     return mirror_type;
   }
@@ skipping 78 matching lines @@
   if (Dart_IsError(result)) {
     return result;
   }
   for (intptr_t i = 0; i < len; i++) {
     Dart_Handle intf_name = Dart_ListGetAt(names, i);
     Dart_Handle intf = Dart_GetClass(owner, intf_name);
     if (Dart_IsError(intf)) {
       return intf;
     }
     Dart_Handle intf_mirror =
-        CreateClassMirror(intf, intf_name, owner, owner_mirror);
+        CreateClassMirrorUsingApi(intf, intf_name, owner, owner_mirror);
     if (Dart_IsError(intf_mirror)) {
       return intf_mirror;
     }
     result = MapAdd(map, intf_name, intf_mirror);
     if (Dart_IsError(result)) {
       return result;
     }
   }
   return Dart_True();
 }
@@ skipping 23 matching lines @@
     bool is_constructor = false;
     result = Dart_FunctionIsConstructor(func, &is_constructor);
     if (Dart_IsError(result)) {
       return result;
     }
     if (is_constructor) {
       // Skip constructors.
       continue;
     }
 
-    Dart_Handle func_mirror = CreateMethodMirror(func, owner_mirror);
+    Dart_Handle func_mirror = CreateMethodMirrorUsingApi(func, owner_mirror);
     if (Dart_IsError(func_mirror)) {
       return func_mirror;
     }
     result = MapAdd(map, func_name, func_mirror);
     if (Dart_IsError(result)) {
       return result;
     }
   }
   return Dart_True();
 }
@@ skipping 23 matching lines @@
     bool is_constructor = false;
     result = Dart_FunctionIsConstructor(func, &is_constructor);
     if (Dart_IsError(result)) {
       return result;
     }
     if (!is_constructor) {
       // Skip non-constructors.
       continue;
     }
 
-    Dart_Handle func_mirror = CreateMethodMirror(func, owner_mirror);
+    Dart_Handle func_mirror = CreateMethodMirrorUsingApi(func, owner_mirror);
     if (Dart_IsError(func_mirror)) {
       return func_mirror;
     }
     result = MapAdd(map, func_name, func_mirror);
     if (Dart_IsError(result)) {
       return result;
     }
   }
   return Dart_True();
 }
@@ skipping 67 matching lines @@
   Dart_Handle result;
   Dart_Handle map = MapNew();
   result = AddConstructors(map, owner, owner_mirror);
   if (Dart_IsError(result)) {
     return result;
   }
   return map;
 }
 
 
-static Dart_Handle CreateLibraryMirror(Dart_Handle lib) {
+static Dart_Handle CreateLibraryMirrorUsingApi(Dart_Handle lib) {
   Dart_Handle cls_name = NewString("_LocalLibraryMirrorImpl");
   Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
   if (Dart_IsError(type)) {
     return type;
   }
   Dart_Handle lazy_lib_mirror = CreateLazyMirror(lib);
   if (Dart_IsError(lazy_lib_mirror)) {
     return lazy_lib_mirror;
   }
   Dart_Handle member_map = CreateMemberMap(lib, lazy_lib_mirror);
@@ skipping 34 matching lines @@
     int64_t id64;
     Dart_IntegerToInt64(lib_id, &id64);
     Dart_Handle lib_url = Dart_GetLibraryURL(id64);
     if (Dart_IsError(lib_url)) {
       return lib_url;
     }
     Dart_Handle lib = Dart_LookupLibrary(lib_url);
     if (Dart_IsError(lib)) {
       return lib;
     }
-    Dart_Handle lib_mirror = CreateLibraryMirror(lib);
+    Dart_Handle lib_mirror = CreateLibraryMirrorUsingApi(lib);
     if (Dart_IsError(lib_mirror)) {
       return lib_mirror;
     }
     result = MapAdd(map, lib_url, lib_mirror);
   }
   return map;
 }
 
 
 static Dart_Handle CreateIsolateMirror() {
@@ skipping 81 matching lines @@
 
     // TODO(turnidge): Why not use the real function name here?
     Dart_Handle func_owner = Dart_FunctionOwner(func);
     if (Dart_IsError(func_owner)) {
       return func_owner;
     }
 
     // TODO(turnidge): Pass the function owner here.  This will require
     // us to support functions in CreateLazyMirror.
     Dart_Handle func_mirror =
-        CreateMethodMirror(func, Dart_Null());
+        CreateMethodMirrorUsingApi(func, Dart_Null());
     if (Dart_IsError(func_mirror)) {
       return func_mirror;
     }
     Dart_Handle args[] = {
       CreateVMReference(instance),
       CreateLazyMirror(instance_cls),
       instance,
       func_mirror,
     };
     return Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
 
   } else {
     Dart_Handle cls_name = NewString("_LocalInstanceMirrorImpl");
     Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
     if (Dart_IsError(type)) {
       return type;
     }
     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.

[siva, 2013/07/18 20:38:45]

This comment here is misleading it seems to imply that this is not the final
version...

Move it down to the call of CreateLibraryMirrorUsingApi stating that this will
be replaced by actual VM code.

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

Done.

+static RawInstance* CreateClassMirror(const Class& cls,
+                                      const Instance& owner_mirror) {
+  Dart_EnterScope();
+  Isolate* isolate = Isolate::Current();
+  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 = CreateLibraryMirrorUsingApi(lib_handle);
+  if (Dart_IsError(lib_mirror)) {
+    Dart_PropagateError(lib_mirror);
+  }
+  Dart_Handle result =  CreateClassMirrorUsingApi(cls_handle,
+                                                  name_handle,
+                                                  lib_handle,
+                                                  lib_mirror);
+  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) {
+  Dart_EnterScope();
+  Isolate* isolate = Isolate::Current();
+  Dart_Handle lib_handle = Api::NewHandle(isolate, lib.raw());
+  Dart_Handle result = CreateLibraryMirrorUsingApi(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();
+  Dart_Handle func_handle = Api::NewHandle(isolate, func.raw());
+  Dart_Handle owner_handle = Api::NewHandle(isolate, owner_mirror.raw());
+  Dart_Handle result = CreateMethodMirrorUsingApi(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 27 matching lines @@
     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);
+  Dart_Handle lib_mirror = CreateLibraryMirrorUsingApi(lib_handle);
   if (Dart_IsError(lib_mirror)) {
     Dart_PropagateError(lib_mirror);
   }
-  Dart_Handle result = CreateClassMirror(cls_handle,
-                                         name_handle,
-                                         lib_handle,
-                                         lib_mirror);
+  Dart_Handle result = CreateClassMirrorUsingApi(cls_handle,
+                                                 name_handle,
+                                                 lib_handle,
+                                                 lib_mirror);
   if (Dart_IsError(result)) {
     Dart_PropagateError(result);
   }
   Dart_SetReturnValue(args, result);
   Dart_ExitScope();
 }
 
 void NATIVE_ENTRY_FUNCTION(Mirrors_metadata)(Dart_NativeArguments args) {
   Dart_EnterScope();
   Dart_Handle mirror = Dart_GetNativeArgument(args, 0);
@@ skipping 698 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();
+  if (func.IsNonImplicitClosureFunction()) {
+    return CreateMethodMirror(Function::Handle(
+        func.parent_function()), Instance::Handle());
+  }
+  const Class& owner = Class::Handle(func.Owner());
+  if (owner.IsTopLevel()) {
+    return CreateLibraryMirror(Library::Handle(owner.library()));
+  }
+  return CreateClassMirror(owner, Instance::Handle());
+}
+
 }  // namespace dart