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"
@@ skipping 478 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);
   }
 }
 
 
+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);
+  }
+  // TODO(11742): At some point the handle calls will be replaced by inlined
+  // functionality.
+  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();
+}
+
+
+static RawInstance* CreateLibraryMirror(const Library& lib) {
+  Dart_EnterScope();
+  Isolate* isolate = Isolate::Current();
+  Dart_Handle lib_handle = Api::NewHandle(isolate, lib.raw());
+  // TODO(11742): At some point the handle calls will be replaced by inlined
+  // functionality.
+  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();
+}
+
+
+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());
+  // TODO(11742): At some point the handle calls will be replaced by inlined
+  // functionality.
+  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