Mirrors memory usage tweaks.

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 "lib/mirrors.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/bootstrap_natives.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 224 matching lines @@
   const Array& args = Array::Handle(Array::New(2));
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(cls)));
   args.SetAt(1, type);
   return CreateMirror(Symbols::_LocalFunctionTypeMirror(), args);
 }
 
 
 static RawInstance* CreateMethodMirror(const Function& func,
                                        const Instance& owner_mirror,
                                        const AbstractType& instantiator) {
-  const Array& args = Array::Handle(Array::New(13));
+  const Array& args = Array::Handle(Array::New(6));
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(func)));
 
   String& name = String::Handle(func.name());
   name = String::IdentifierPrettyNameRetainPrivate(name);
   args.SetAt(1, name);
-
   args.SetAt(2, owner_mirror);
   args.SetAt(3, instantiator);
   args.SetAt(4, Bool::Get(func.is_static()));
-  args.SetAt(5, Bool::Get(func.is_abstract()));
-  args.SetAt(6, Bool::Get(func.IsGetterFunction()));
-  args.SetAt(7, Bool::Get(func.IsSetterFunction()));
 
-  bool isConstructor = (func.kind() == RawFunction::kConstructor);
-  args.SetAt(8, Bool::Get(isConstructor));
-  args.SetAt(9, Bool::Get(isConstructor && func.is_const()));
-  args.SetAt(10, Bool::Get(isConstructor && func.IsGenerativeConstructor()));
-  args.SetAt(11, Bool::Get(isConstructor && func.is_redirecting()));
-  args.SetAt(12, Bool::Get(isConstructor && func.IsFactory()));
+  intptr_t kind_flags = 0;
+  kind_flags |= (func.is_abstract() << Mirrors::kAbstract);
+  kind_flags |= (func.IsGetterFunction()  << Mirrors::kGetter);
+  kind_flags |= (func.IsSetterFunction()  << Mirrors::kSetter);
+  bool is_ctor = (func.kind() == RawFunction::kConstructor);
+  kind_flags |= (is_ctor  << Mirrors::kConstructor);
+  kind_flags |= ((is_ctor && func.is_const()) << Mirrors::kConstCtor);
+  kind_flags |= ((is_ctor && func.IsGenerativeConstructor())
+                 << Mirrors::kGenerativeCtor);
+  kind_flags |= ((is_ctor && func.is_redirecting())
+                 << Mirrors::kRedirectingCtor);
+  kind_flags |= ((is_ctor && func.IsFactory()) << Mirrors::kFactoryCtor);
+  args.SetAt(5, Smi::Handle(Smi::New(kind_flags)));
 
   return CreateMirror(Symbols::_LocalMethodMirror(), args);
 }
 
 
 static RawInstance* CreateVariableMirror(const Field& field,
                                          const Instance& owner_mirror) {
   const MirrorReference& field_ref =
       MirrorReference::Handle(MirrorReference::New(field));
 
@@ skipping 258 matching lines @@
   const Instance& root_library_mirror =
       Instance::Handle(CreateLibraryMirror(root_library));
 
   const Array& args = Array::Handle(Array::New(2));
   args.SetAt(0, debug_name);
   args.SetAt(1, root_library_mirror);
   return CreateMirror(Symbols::_LocalIsolateMirror(), args);
 }
 
 
+static void VerifyMethodKindShifts() {
+#ifdef DEBUG
+  Isolate* isolate = Isolate::Current();
+  const Library& lib = Library::Handle(isolate, Library::MirrorsLibrary());
+  const Class& cls = Class::Handle(isolate,
+      lib.LookupClassAllowPrivate(Symbols::_LocalMethodMirror()));
+  const Error& error = Error::Handle(isolate, cls.EnsureIsFinalized(isolate));
+  ASSERT(error.IsNull());
+
+  Field& field = Field::Handle();
+  Smi& value = Smi::Handle();
+
+  #define CHECK_KIND_SHIFT(name)                                               \
+    field = cls.LookupField(String::Handle(String::New(#name)));               \
+    ASSERT(!field.IsNull());                                                   \
+    value ^= field.value();                                                    \
+    ASSERT(value.Value() == Mirrors::name);
+  MIRRORS_KIND_SHIFT_LIST(CHECK_KIND_SHIFT)
+  #undef CHECK_KIND_SHIFT
+#endif
+}
+
+
 static RawInstance* CreateMirrorSystem() {
+  VerifyMethodKindShifts();
+
   Isolate* isolate = Isolate::Current();
   const GrowableObjectArray& libraries = GrowableObjectArray::Handle(
       isolate, isolate->object_store()->libraries());
 
   const intptr_t num_libraries = libraries.Length();
   const GrowableObjectArray& library_mirrors = GrowableObjectArray::Handle(
       isolate, GrowableObjectArray::New(num_libraries));
   Library& library = Library::Handle(isolate);
   Instance& library_mirror = Instance::Handle(isolate);
 
@@ skipping 332 matching lines @@
                                instantiator,
                                arguments->NativeArgAt(1));
   const Class& cls = Class::Handle(ref.GetClassReferent());
   const Function& func = Function::Handle(CallMethod(cls));
   ASSERT(!func.IsNull());
   AbstractType& type = AbstractType::Handle(func.result_type());
   return InstantiateType(type, instantiator);
 }
 
 
-DEFINE_NATIVE_ENTRY(ClassMirror_library, 1) {
+DEFINE_NATIVE_ENTRY(ClassMirror_libraryUri, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Class& klass = Class::Handle(ref.GetClassReferent());
   const Library& library = Library::Handle(klass.library());
   ASSERT(!library.IsNull());
-  return CreateLibraryMirror(library);
+  return library.url();
 }
 
 
 DEFINE_NATIVE_ENTRY(ClassMirror_supertype, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0));
   ASSERT(!type.IsMalformed());
   ASSERT(type.IsFinalized());
   if (!type.HasResolvedTypeClass()) {
     Exceptions::ThrowArgumentError(type);
     UNREACHABLE();
@@ skipping 1122 matching lines @@
 }
 
 DEFINE_NATIVE_ENTRY(TypeMirror_moreSpecificTest, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, a, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, b, arguments->NativeArgAt(1));
   return Bool::Get(a.IsMoreSpecificThan(b, NULL)).raw();
 }
 
 
 }  // namespace dart