Make the ClassMirrors created through reflectClass() find their owners (libraries) lazily.

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 404 matching lines @@
     if (Dart_IsError(result)) {
       return result;
     }
   }
   return map;
 }
 
 
 static Dart_Handle CreateTypedefMirror(Dart_Handle cls,
                                        Dart_Handle cls_name,
-                                       Dart_Handle owner,
                                        Dart_Handle owner_mirror) {
   Dart_Handle mirror_cls_name = NewString("_LocalTypedefMirrorImpl");
   Dart_Handle mirror_type = Dart_GetType(MirrorLib(), mirror_cls_name, 0, NULL);
   if (Dart_IsError(mirror_type)) {
     return mirror_type;
   }
 
   Dart_Handle referent = Dart_ClassGetTypedefReferent(cls);
   if (Dart_IsError(referent)) {
     return referent;
   }
 
   Dart_Handle args[] = {
     CreateMirrorReference(cls),
     cls_name,
     owner_mirror,
     CreateLazyMirror(referent),
   };
   Dart_Handle mirror =
       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 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);
+    return CreateTypedefMirror(intf, intf_name, lib_mirror);
   }
 
   Dart_Handle cls_name = NewString("_LocalClassMirrorImpl");
   Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
   if (Dart_IsError(type)) {
     return type;
   }
 
   // TODO(turnidge): Why am I getting Null when I expect Object?
   // TODO(gbracha): this is probably the root of bug 7868
@@ skipping 132 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 =
-        CreateClassMirrorUsingApi(intf, intf_name, owner, owner_mirror);
+        CreateClassMirrorUsingApi(intf, intf_name, 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 338 matching lines @@
       CreateLazyMirror(instance_cls),
       instance,
     };
     return Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
   }
 }
 
 
 static RawInstance* CreateClassMirror(const Class& cls,
                                       const Instance& owner_mirror) {
+  Instance& retvalue = Instance::Handle();

[rmacnak, 2013/07/18 22:55:00]

Merging with Michael's changes, we discovered it is important this handle (and
its cousins in CreateLibraryMirror and CreateMethodMirror) be created outside
the Dart_Enter/ExitScope.

   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 lib_mirror = Api::NewHandle(isolate, owner_mirror.raw());
   // 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);
+  retvalue ^= Api::UnwrapHandle(result);
   Dart_ExitScope();
   return retvalue.raw();
 }
 
 
 static RawInstance* CreateLibraryMirror(const Library& lib) {
+  Instance& retvalue = Instance::Handle();
   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);
+  retvalue ^= Api::UnwrapHandle(result);
   Dart_ExitScope();
   return retvalue.raw();
 }
 
 
 static RawInstance* CreateMethodMirror(const Function& func,
                                        const Instance& owner_mirror) {
+  Instance& retvalue = Instance::Handle();
   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);
+  retvalue ^= Api::UnwrapHandle(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)) {
@@ skipping 28 matching lines @@
   const Type& type = Api::UnwrapTypeHandle(isolate, key);
   const Class& cls = Class::Handle(type.type_class());
   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 lib_mirror = Dart_Null();
   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();
 }
 
 
 DEFINE_NATIVE_ENTRY(DeclarationMirror_metadata, 1) {
@@ skipping 150 matching lines @@
 
 DEFINE_NATIVE_ENTRY(ClassMirror_name, 1) {
   const MirrorReference& klass_ref =
       MirrorReference::CheckedHandle(arguments->NativeArgAt(0));
   Class& klass = Class::Handle();
   klass ^= klass_ref.referent();
   return klass.Name();
 }
 
 
+DEFINE_NATIVE_ENTRY(ClassMirror_library, 1) {
+  const MirrorReference& klass_ref =
+      MirrorReference::CheckedHandle(arguments->NativeArgAt(0));
+  Class& klass = Class::Handle();
+  klass ^= klass_ref.referent();
+
+  const Library& library = Library::Handle(klass.library());
+  return CreateLibraryMirror(library);
+}
+
+
 // Invoke the function, or noSuchMethod if it is null. Propagate any unhandled
 // exceptions. Wrap and propagate any compilation errors.
 static RawObject* ReflectivelyInvokeDynamicFunction(const Instance& receiver,
                                                     const Function& function,
                                                     const String& target_name,
                                                     const Array& arguments) {
   // Note "arguments" is already the internal arguments with the receiver as
   // the first element.
   Object& result = Object::Handle();
   if (function.IsNull()) {
@@ skipping 554 matching lines @@
         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