Inline create parameter mirror list functionality.

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 100 matching lines @@
 }
 
 
 // TODO(11742): Remove once there are no more users of the Dart_Handle-based
 // VMReferences.
 static Dart_Handle CreateMirrorReference(Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& referent = Object::Handle(isolate, Api::UnwrapHandle(handle));
   const MirrorReference& reference =
-       MirrorReference::Handle(MirrorReference::New());
-  reference.set_referent(referent);
+       MirrorReference::Handle(MirrorReference::New(referent));
   return Api::NewHandle(isolate, reference.raw());
 }
 
 
 static Dart_Handle StringFromSymbol(Dart_Handle symbol) {
   Dart_Handle result = Dart_Invoke(MirrorLib(), NewString("_n"), 1, &symbol);
   return result;
 }
 
 
@@ skipping 95 matching lines @@
     return UnwrapVariableMirror(mirror);
   }
   return UnwrapObjectMirror(mirror);
   // will return nonsense if mirror is not an ObjectMirror
 }
 
 
 static Dart_Handle CreateLazyMirror(Dart_Handle target);
 
 
-static Dart_Handle CreateParameterMirrorList(Dart_Handle func) {
-  ASSERT(Dart_IsFunction(func));
-  int64_t fixed_param_count;
-  int64_t opt_param_count;
-  Dart_Handle result = Dart_FunctionParameterCounts(func,
-                                                    &fixed_param_count,
-                                                    &opt_param_count);
-  if (Dart_IsError(result)) {
-    return result;
+static RawInstance* CreateParameterMirrorList(const Function& func) {
+  HANDLESCOPE(Isolate::Current());
+  const intptr_t param_cnt = func.num_fixed_parameters() -
+                             func.NumImplicitParameters() +
+                             func.NumOptionalParameters();
+  const Array& results = Array::Handle(Array::New(param_cnt));
+  const Array& args = Array::Handle(Array::New(3));
+  args.SetAt(0, MirrorReference::Handle(MirrorReference::New(func)));
+  Smi& pos = Smi::Handle();
+  Instance& param = Instance::Handle();
+  for (intptr_t i = 0; i < param_cnt; ++i) {

[siva, 2013/07/24 23:12:38]

normally i++ is used in our code base I think.

[Michael Lippautz (Google), 2013/07/24 23:34:03]

Done.

+    pos ^= Smi::New(i);
+    args.SetAt(1, pos);
+    args.SetAt(2, (i >= func.num_fixed_parameters()) ?
+        Bool::True() : Bool::False());
+    param ^= CreateMirror(Symbols::_LocalParameterMirrorImpl(), args);
+    results.SetAt(i, param);
   }
-
-  int64_t param_count = fixed_param_count + opt_param_count;
-  Dart_Handle parameter_list = Dart_NewList(param_count);
-  if (Dart_IsError(parameter_list)) {
-    return result;
-  }
-
-  Dart_Handle param_cls_name = NewString("_LocalParameterMirrorImpl");
-  Dart_Handle param_type = Dart_GetType(MirrorLib(), param_cls_name, 0, NULL);
-  if (Dart_IsError(param_type)) {
-    return param_type;
-  }
-
-  Dart_Handle reflectee = CreateMirrorReference(func);
-  for (int64_t i = 0; i < param_count; i++) {
-    Dart_Handle args[] = {
-      reflectee,
-      Dart_NewInteger(i),
-      (i >= fixed_param_count) ? Api::True() : Api::False(),
-    };
-    Dart_Handle param =
-        Dart_New(param_type, Dart_Null(), ARRAY_SIZE(args), args);
-    if (Dart_IsError(param)) {
-      return param;
-    }
-    result = Dart_ListSetAt(parameter_list, i, param);
-    if (Dart_IsError(result)) {
-      return result;
-    }
-  }
-  return parameter_list;
+  results.MakeImmutable();
+  return results.raw();
 }
 
 
+static Dart_Handle CreateParameterMirrorListUsingApi(Dart_Handle func) {
+  ASSERT(Dart_IsFunction(func));
+  Isolate* isolate = Isolate::Current();
+  return Api::NewHandle(
+      isolate, CreateParameterMirrorList(Api::UnwrapFunctionHandle(
+          isolate, func)));
+}
+
+
 static Dart_Handle CreateLazyMirror(Dart_Handle target) {
   if (Dart_IsNull(target) || Dart_IsError(target)) {
     return target;
   }
 
   if (Dart_IsLibrary(target)) {
     Dart_Handle cls_name = NewString("_LazyLibraryMirror");
     Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
     Dart_Handle args[] = { Dart_LibraryUrl(target) };
     return Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
   }
 
   if (Dart_IsClass(target)) {
     if (Dart_ClassIsFunctionType(target)) {
       Dart_Handle cls_name = NewString("_LazyFunctionTypeMirror");
       Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
 
       Dart_Handle sig = Dart_ClassGetFunctionTypeSignature(target);
       Dart_Handle return_type = Dart_FunctionReturnType(sig);
       if (Dart_IsError(return_type)) {
         return return_type;
       }
 
       Dart_Handle args[] = {
         CreateLazyMirror(return_type),
-        CreateParameterMirrorList(sig),
+        CreateParameterMirrorListUsingApi(sig),
       };
       return Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
     } else {
       Dart_Handle cls_name = NewString("_LazyTypeMirror");
       Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
       Dart_Handle lib = Dart_ClassGetLibrary(target);
       Dart_Handle lib_url;
       if (Dart_IsNull(lib)) {
         lib_url = Dart_Null();
       } else {
@@ skipping 258 matching lines @@
   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,
-    CreateParameterMirrorList(func),
+    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;
 }
 
 static RawInstance* CreateVariableMirror(const Field& field,
                                          const Instance& owner_mirror) {
   const MirrorReference& field_ref =
-      MirrorReference::Handle(MirrorReference::New());
-  field_ref.set_referent(field);
+      MirrorReference::Handle(MirrorReference::New(field));
 
   const String& name = String::Handle(field.UserVisibleName());
 
   const Array& args = Array::Handle(Array::New(6));
   args.SetAt(0, field_ref);
   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());
@@ skipping 1258 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