Make ClassMirror.members internal-native and lazy.

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 519 matching lines @@
   if (Dart_IsNull(super_class)) {
     super_class = Dart_GetClass(CoreLib(), NewString("Object"));
   }
   // TODO(turnidge): Simplify code, now that default classes have been removed.
   Dart_Handle default_class = Dart_Null();
 
   Dart_Handle intf_mirror = CreateLazyMirror(intf);
   if (Dart_IsError(intf_mirror)) {
     return intf_mirror;
   }
-  Dart_Handle member_map = CreateMemberMap(intf, intf_mirror);
-  if (Dart_IsError(member_map)) {
-    return member_map;
-  }
   Dart_Handle constructor_map = CreateConstructorMap(intf, intf_mirror);
   if (Dart_IsError(constructor_map)) {
     return constructor_map;
   }
   Dart_Handle type_var_map = CreateTypeVariableMap(intf, intf_mirror);
   if (Dart_IsError(type_var_map)) {
     return type_var_map;
   }
 
   Dart_Handle args[] = {
     CreateMirrorReference(intf),
     Dart_Null(),  // "name"
     Dart_NewBoolean(Dart_IsClass(intf)),
     lib_mirror,
     CreateLazyMirror(super_class),
     CreateImplementsList(intf),
     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 CreateMethodMirrorUsingApi(Dart_Handle func,
                                               Dart_Handle owner_mirror) {
@@ skipping 734 matching lines @@
 }
 
 
 DEFINE_NATIVE_ENTRY(ClassMirror_library, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Class& klass = Class::Handle(ref.GetClassReferent());
   return CreateLibraryMirror(Library::Handle(klass.library()));
 }
 
 
+DEFINE_NATIVE_ENTRY(ClassMirror_members, 2) {

[rmacnak, 2013/07/23 01:15:37]

I intend to adapt this to be shared with LibraryMirror.

+  GET_NON_NULL_NATIVE_ARGUMENT(Instance,
+                               owner_mirror,
+                               arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
+  const Class& klass = Class::Handle(ref.GetClassReferent());
+
+  const Array& fields = Array::Handle(klass.fields());
+  // Some special types like 'dynamic' have a null fields list, but they should
+  // not wind up as the reflectees of ClassMirrors.

[siva, 2013/07/23 21:14:39]

One way to avoid this could be to store empty_array() as fields for the dynamic
type.

[rmacnak, 2013/07/23 22:57:34]

Hm. This irregularity also affects LookupField/LookupFunction. I tried adding
null_class().InitEmptyFields() in Object::Init, by which point the empty array
should be available, but this somehow ruins snapshot generation, even with a
clean build.

[siva, 2013/07/23 23:37:07]

Need to debug this.

On 2013/07/23 22:57:34, Ryan Macnak wrote:

+  ASSERT(!fields.IsNull());
+  const intptr_t num_fields = fields.Length();
+
+  const Array& functions = Array::Handle(klass.functions());
+  // Some special types like 'dynamic' have a null functions list, but they
+  // should not wind up as the reflectees of ClassMirrors.
+  ASSERT(!functions.IsNull());

[siva, 2013/07/23 21:14:39]

Ditto about storing empty_array() for functions.

+  const intptr_t num_functions = functions.Length();
+
+  Instance& member_mirror = Instance::Handle();
+  const GrowableObjectArray& member_mirrors = GrowableObjectArray::Handle(
+      GrowableObjectArray::New(num_fields + num_functions));

[siva, 2013/07/23 21:14:39]

Since you now the exact number of fields and functions can this be a plain Array
instead of a GrowableObjectArray ?

[rmacnak, 2013/07/23 22:57:34]

We know an upper bound. Some of the functions are synthetic and won't be added.
Hence a growable array with a capacity hint.

[siva, 2013/07/23 23:37:07]

True but the GrowableArray is going to allocate a backing array of the specified
capacity hint. A growable array in general has a higher memory footprint than a
regular array. Access (set/get) has an extra indirection. It is really useful
only if it actually grows.

On 2013/07/23 22:57:34, Ryan Macnak wrote:

+
+  Field& field = Field::Handle();
+  for (intptr_t i = 0; i < num_fields; i++) {
+    field ^= fields.At(i);
+    member_mirror = CreateVariableMirror(field, owner_mirror);
+    member_mirrors.Add(member_mirror);
+  }
+
+  Function& func = Function::Handle();
+  for (intptr_t i = 0; i < num_functions; i++) {
+    func ^= functions.At(i);
+    if (func.kind() == RawFunction::kRegularFunction ||
+        func.kind() == RawFunction::kGetterFunction ||
+        func.kind() == RawFunction::kSetterFunction) {
+      member_mirror = CreateMethodMirror(func, owner_mirror);
+      member_mirrors.Add(member_mirror);
+    }
+  }
+
+  return member_mirrors.raw();
+}
+
+
 // 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 549 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