Inline MethodMirror creation

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 532 matching lines @@
     CreateImplementsList(intf),
     CreateLazyMirror(default_class),
     constructor_map,
     type_var_map,
   };
   Dart_Handle mirror = Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
   return mirror;
 }
 
 
+static RawInstance* CreateMethodMirror(const Function& func,
+                                       const Instance& owner_mirror) {
+  HANDLESCOPE(Isolate::Current());

[siva, 2013/07/25 20:54:40]

Is the HANDLESCOPE here needed? Do we have a leak possibility?

[Michael Lippautz (Google), 2013/07/25 21:06:38]

It's not needed anymore. It was needed when the MirrorSystem populated functions
eagerly and we had too much floating garbage (causing a slowdown).

+  const Array& args = Array::Handle(Array::New(11));
+  args.SetAt(0, MirrorReference::Handle(MirrorReference::New(func)));
+  args.SetAt(1, owner_mirror);
+  args.SetAt(2, func.is_static() ? Bool::True() : Bool::False());
+  args.SetAt(3, func.is_abstract() ? Bool::True() : Bool::False());
+  args.SetAt(4, func.IsGetterFunction() ? Bool::True() : Bool::False());
+  args.SetAt(5, func.IsSetterFunction() ? Bool::True() : Bool::False());
+  args.SetAt(6, func.IsConstructor() ? Bool::True() : Bool::False());
+  // TODO(mlippautz): Implement different constructor kinds.
+  args.SetAt(7, Bool::False());
+  args.SetAt(8, Bool::False());
+  args.SetAt(9, Bool::False());
+  args.SetAt(10, Bool::False());
+  return CreateMirror(Symbols::_LocalMethodMirrorImpl(), args);
+}
+
+
 static Dart_Handle CreateMethodMirrorUsingApi(Dart_Handle func,
                                               Dart_Handle owner_mirror) {
-  // TODO(11742): Unwrapping is needed until the whole method is converted.
   Isolate* isolate = Isolate::Current();
-  const Function& func_obj = Api::UnwrapFunctionHandle(isolate, func);
-
-  Dart_Handle mirror_cls_name = NewString("_LocalMethodMirrorImpl");
-  Dart_Handle mirror_type = Dart_GetType(MirrorLib(), mirror_cls_name, 0, NULL);
-  if (Dart_IsError(mirror_type)) {
-    return mirror_type;
-  }
-
-  // TODO(turnidge): Implement constructor kinds (arguments 7 - 10).
-  Dart_Handle args[] = {
-    CreateMirrorReference(func),
-    owner_mirror,
-    CreateParameterMirrorListUsingApi(func),
-    func_obj.is_static() ? Api::True() : Api::False(),
-    func_obj.is_abstract() ? Api::True() : Api::False(),
-    func_obj.IsGetterFunction() ? Api::True() : Api::False(),
-    func_obj.IsSetterFunction() ? Api::True() : Api::False(),
-    func_obj.IsConstructor() ? Api::True() : Api::False(),
-    Api::False(),
-    Api::False(),
-    Api::False(),
-    Api::False()
-  };
-  Dart_Handle mirror =
-      Dart_New(mirror_type, Dart_Null(), ARRAY_SIZE(args), args);
-  return mirror;
+  return Api::NewHandle(isolate, CreateMethodMirror(
+      Api::UnwrapFunctionHandle(isolate, func),
+      Api::UnwrapInstanceHandle(isolate, owner_mirror)));
 }
 
 static RawInstance* CreateVariableMirror(const Field& field,
                                          const Instance& owner_mirror) {
   const MirrorReference& field_ref =
       MirrorReference::Handle(MirrorReference::New(field));
 
   const String& name = String::Handle(field.UserVisibleName());
 
   const Array& args = Array::Handle(Array::New(6));
@@ skipping 429 matching lines @@
   Dart_Handle result = CreateLibraryMirrorUsingApi(lib_handle);
   if (Dart_IsError(result)) {
     Dart_PropagateError(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);
-  }
-  retvalue ^= Api::UnwrapHandle(result);
-  Dart_ExitScope();
-  return retvalue.raw();
-}
-
-
 static RawInstance* CreateTypeMirror(const AbstractType& type) {
   ASSERT(!type.IsMalformed());
   if (type.HasResolvedTypeClass()) {
     const Class& cls = Class::Handle(type.type_class());
     // Handle void and dynamic types.
     if (cls.IsVoidClass()) {
       Array& args = Array::Handle(Array::New(1));
       args.SetAt(0, Symbols::Void());
       // TODO(mlippautz): Create once in the VM isolate and retrieve from there.
       return CreateMirror(Symbols::_SpecialTypeMirrorImpl(), args);
@@ skipping 822 matching lines @@
         func.parent_function()), Object::null_instance());
   }
   const Class& owner = Class::Handle(func.Owner());
   if (owner.IsTopLevel()) {
     return CreateLibraryMirror(Library::Handle(owner.library()));
   }
   return CreateClassMirror(owner, Object::null_instance());
 }
 
 
+DEFINE_NATIVE_ENTRY(MethodMirror_parameters, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
+  const Function& func = Function::Handle(ref.GetFunctionReferent());
+  return CreateParameterMirrorList(func);
+}
+
+
 DEFINE_NATIVE_ENTRY(MethodMirror_return_type, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Function& func = Function::Handle(ref.GetFunctionReferent());
   // We handle constructors in Dart code.
   ASSERT(!func.IsConstructor());
   const AbstractType& return_type = AbstractType::Handle(func.result_type());
   return CreateTypeMirror(return_type);
 }
 
 
 DEFINE_NATIVE_ENTRY(ParameterMirror_type, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(Smi, pos, arguments->NativeArgAt(1));
   const Function& func = Function::Handle(ref.GetFunctionReferent());
   const AbstractType& param_type = AbstractType::Handle(func.ParameterTypeAt(
       func.NumImplicitParameters() + pos.Value()));
   return CreateTypeMirror(param_type);
 }
 
 
 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