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()));
 
+  // These offsets much be kept in sync with those in mirrors_impl.dart.

[siva, 2015/04/22 00:00:47]

Can you declare some constants in mirrors_impl.dart and assert that these values
match some constants here during start up.
Something similar to ClassFinalizer::VerifyImplicitFieldOffsets()

[rmacnak, 2015/04/22 17:09:02]

Added debug-only hook in CreateMirrorSystem, which will run during about half of
the mirror tests. PTAL

+  intptr_t kind_flags = 0;
+  kind_flags |= (func.is_abstract()                                << 0);
+  kind_flags |= (func.IsGetterFunction()                           << 1);
+  kind_flags |= (func.IsSetterFunction()                           << 2);
   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()));
+  kind_flags |= (isConstructor                                     << 3);
+  kind_flags |= ((isConstructor && func.is_const())                << 4);
+  kind_flags |= ((isConstructor && func.IsGenerativeConstructor()) << 5);
+  kind_flags |= ((isConstructor && func.is_redirecting())          << 6);
+  kind_flags |= ((isConstructor && func.IsFactory())               << 7);
+  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 611 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