Create ParameterMirror.type lazily.

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 218 matching lines @@
   }
   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;
   }
 
   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 arg_type = Dart_FunctionParameterType(func, i);
-    if (Dart_IsError(arg_type)) {
-      return arg_type;
-    }
     Dart_Handle args[] = {
-      CreateLazyMirror(arg_type),
-      Dart_NewBoolean(i >= fixed_param_count),  // optional param?
+      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;
     }
@@ skipping 1579 matching lines @@
 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