Make LibraryMirror.members an 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 487 matching lines @@
     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_mirror) {
   ASSERT(Dart_IsClass(intf));
   if (Dart_ClassIsTypedef(intf)) {
     // This class is actually a typedef.  Represent it specially in
     // reflection.
@@ skipping 89 matching lines @@
   args.SetAt(1, name);
   args.SetAt(2, owner_mirror);
   args.SetAt(3, Instance::Handle());  // Null for type.
   args.SetAt(4, field.is_static() ? Bool::True() : Bool::False());
   args.SetAt(5, field.is_final()  ? Bool::True() : Bool::False());
 
   return CreateMirror(Symbols::_LocalVariableMirrorImpl(), args);
 }
 
 
-static Dart_Handle AddMemberClasses(Dart_Handle map,
-                                    Dart_Handle owner,
-                                    Dart_Handle owner_mirror) {
-  ASSERT(Dart_IsLibrary(owner));
-  Dart_Handle result;
-  Dart_Handle names = Dart_LibraryGetClassNames(owner);
-  if (Dart_IsError(names)) {
-    return names;
-  }
-  intptr_t len;
-  result = Dart_ListLength(names, &len);
-  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_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();
-}
-
-
-static Dart_Handle AddMemberFunctions(Dart_Handle map,
-                                      Dart_Handle owner,
-                                      Dart_Handle owner_mirror) {
-  Dart_Handle result;
-  Dart_Handle names = Dart_GetFunctionNames(owner);
-  if (Dart_IsError(names)) {
-    return names;
-  }
-  intptr_t len;
-  result = Dart_ListLength(names, &len);
-  if (Dart_IsError(result)) {
-    return result;
-  }
-  for (intptr_t i = 0; i < len; i++) {
-    Dart_Handle func_name = Dart_ListGetAt(names, i);
-    Dart_Handle func = Dart_LookupFunction(owner, func_name);
-    if (Dart_IsError(func)) {
-      return func;
-    }
-    ASSERT(!Dart_IsNull(func));
-
-    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 = 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();
-}
-
-
 static Dart_Handle AddConstructors(Dart_Handle map,
                                    Dart_Handle owner,
                                    Dart_Handle owner_mirror) {
   Dart_Handle result;
   Dart_Handle names = Dart_GetFunctionNames(owner);
   if (Dart_IsError(names)) {
     return names;
   }
   intptr_t len;
   result = Dart_ListLength(names, &len);
@@ skipping 24 matching lines @@
     }
     result = MapAdd(map, func_name, func_mirror);
     if (Dart_IsError(result)) {
       return result;
     }
   }
   return Dart_True();
 }
 
 
-static Dart_Handle AddMemberVariables(Dart_Handle map,
-                                      Dart_Handle owner,
-                                      Dart_Handle owner_mirror) {
-  Isolate* isolate = Isolate::Current();
-  Dart_Handle result;
-  Dart_Handle names = Dart_GetVariableNames(owner);
-  if (Dart_IsError(names)) {
-    return names;
-  }
-  intptr_t len;
-  result = Dart_ListLength(names, &len);
-  if (Dart_IsError(result)) {
-    return result;
-  }
-  for (intptr_t i = 0; i < len; i++) {
-    Dart_Handle var_name = Dart_ListGetAt(names, i);
-    Dart_Handle var = Dart_LookupVariable(owner, var_name);
-    if (Dart_IsError(var)) {
-      return var;
-    }
-    ASSERT(!Dart_IsNull(var));
-    ASSERT(Dart_IsVariable(var));
-    const Field& field = Api::UnwrapFieldHandle(isolate, var);
-    const Instance& owner_mirror_inst =
-      Api::UnwrapInstanceHandle(isolate, owner_mirror);
-    const Instance& var_mirror_inst =
-      Instance::Handle(CreateVariableMirror(field, owner_mirror_inst));
-    Dart_Handle var_mirror = Api::NewHandle(isolate, var_mirror_inst.raw());
-
-    result = MapAdd(map, var_name, var_mirror);
-    if (Dart_IsError(result)) {
-      return result;
-    }
-  }
-  return Dart_True();
-}
-
-
-static Dart_Handle CreateMemberMap(Dart_Handle owner,
-                                   Dart_Handle owner_mirror) {
-  // TODO(turnidge): This should be an immutable map.
-  if (Dart_IsError(owner_mirror)) {
-    return owner_mirror;
-  }
-  Dart_Handle result;
-  Dart_Handle map = MapNew();
-  if (Dart_IsLibrary(owner)) {
-    result = AddMemberClasses(map, owner, owner_mirror);
-    if (Dart_IsError(result)) {
-      return result;
-    }
-  }
-  result = AddMemberFunctions(map, owner, owner_mirror);
-  if (Dart_IsError(result)) {
-    return result;
-  }
-  result = AddMemberVariables(map, owner, owner_mirror);
-  if (Dart_IsError(result)) {
-    return result;
-  }
-  return map;
-}
-
-
 static Dart_Handle CreateConstructorMap(Dart_Handle owner,
                                         Dart_Handle owner_mirror) {
   // TODO(turnidge): This should be an immutable map.
   if (Dart_IsError(owner_mirror)) {
     return owner_mirror;
   }
   Dart_Handle result;
   Dart_Handle map = MapNew();
   result = AddConstructors(map, owner, owner_mirror);
   if (Dart_IsError(result)) {
     return result;
   }
   return map;
 }
 
 
 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);
-  if (Dart_IsError(member_map)) {
-    return member_map;
-  }
   Dart_Handle args[] = {
     CreateMirrorReference(lib),
     Dart_LibraryName(lib),
     Dart_LibraryUrl(lib),
-    member_map,
   };
   Dart_Handle lib_mirror = Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
   if (Dart_IsError(lib_mirror)) {
     return lib_mirror;
   }
 
   return lib_mirror;
 }
 
 
@@ skipping 391 matching lines @@
   // initialized until the first time the getter is invoked.
   const Instance& value = Instance::Handle(field.value());
   ASSERT(value.raw() != Object::transition_sentinel().raw());
   return value.raw() == Object::sentinel().raw();
 }
 
 
 DEFINE_NATIVE_ENTRY(ClassMirror_name, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Class& klass = Class::Handle(ref.GetClassReferent());
-  return klass.Name();
+  return klass.UserVisibleName();
 }
 
 
 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()));
 }
 
 
@@ skipping 35 matching lines @@
         func.kind() == RawFunction::kSetterFunction) {
       member_mirror = CreateMethodMirror(func, owner_mirror);
       member_mirrors.Add(member_mirror);
     }
   }
 
   return member_mirrors.raw();
 }
 
 
+DEFINE_NATIVE_ENTRY(LibraryMirror_members, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Instance,
+                               owner_mirror,
+                               arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
+  const Library& library = Library::Handle(ref.GetLibraryReferent());
+
+  Instance& member_mirror = Instance::Handle();
+  const GrowableObjectArray& member_mirrors =
+      GrowableObjectArray::Handle(GrowableObjectArray::New());
+
+  Field& field = Field::Handle();
+  Class& klass = Class::Handle();
+  Function& func = Function::Handle();

[siva, 2013/07/24 22:41:35]

You don't need these 3 handles, see comment below.

+
+  Object& entry = Object::Handle();
+  DictionaryIterator entries(library);
+
+  String& user_visible_name = String::Handle();
+  Class& lookup_class = Class::Handle();
+
+  while (entries.HasNext()) {
+    entry = entries.GetNext();
+    if (entry.IsClass()) {
+      klass ^= entry.raw();

[siva, 2013/07/24 22:41:35]

you could replace this with the Cast operator:

   const Klass& klass = Klass::Cast(entry);

(this doesn't create a new handle just casts the existing handle to
the new type which you have already checked and verified by doing a
entry.IsClass() above).

Ditto comment for 'field' and 'func' below.

[rmacnak, 2013/07/24 22:51:43]

Done.

+      if (!klass.IsCanonicalSignatureClass()) {
+        // The various implementations of public classes don't always have the
+        // expected superinterfaces or other properties, so we filter them out
+        // (e.g., ObjectArray would displace the abstract class List but doesn't
+        // answer [Iterable] as its superinterfaces). Checking that the normal
+        // and user-visible names match does not work because it excludes
+        // private members.
+        user_visible_name = klass.UserVisibleName();
+        lookup_class = library.LookupClassAllowPrivate(user_visible_name, NULL);
+        bool is_lookup_class;
+        {
+          NoGCScope();
+          is_lookup_class = klass.raw() == lookup_class.raw();
+        }

[siva, 2013/07/24 22:41:35]

Replace this with the internal class id check as discussed offline.

[rmacnak, 2013/07/24 22:51:43]

Done.

+        if (is_lookup_class) {
+          member_mirror = CreateClassMirror(klass, owner_mirror);
+          member_mirrors.Add(member_mirror);
+        }
+      }
+    } else if (entry.IsField()) {
+      field ^= entry.raw();
+      member_mirror = CreateVariableMirror(field, owner_mirror);
+      member_mirrors.Add(member_mirror);
+    } else if (entry.IsFunction()) {
+      func ^= entry.raw();
+      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 610 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