Add a limited version of ParameterMirrors that can only tell whether they are

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 "vm/bootstrap_natives.h"
 
 #include "platform/json.h"
 #include "include/dart_api.h"
 #include "include/dart_debugger_api.h"
 #include "vm/dart_entry.h"
@@ skipping 310 matching lines @@
   }
   result = Dart_FunctionIsSetter(func, &is_setter);
   if (Dart_IsError(result)) {
     return result;
   }
   result = Dart_FunctionIsConstructor(func, &is_constructor);
   if (Dart_IsError(result)) {
     return result;
   }
 
+  int64_t fixed_param_count;
+  int64_t opt_param_count;
+  result = Dart_FunctionParameterCounts(func,
+                                        &fixed_param_count,
+                                        &opt_param_count);
+  if (Dart_IsError(result)) {
+    return result;
+  }
+
+  Dart_Handle parameter_mirrors =
+    Dart_NewList(fixed_param_count + opt_param_count);
+  if (Dart_IsError(parameter_mirrors)) {
+    return result;
+  }
+
+  Dart_Handle param_cls_name = Dart_NewString("_LocalParameterMirrorImpl");
+  Dart_Handle param_cls = Dart_GetClass(MirrorLib(), param_cls_name);
+  if (Dart_IsError(param_cls)) {
+    return param_cls;
+  }
+
+  // TODO(rmacnak): Fill the parameter mirrors with more than whether they are
+  // are optional.
+  for (int i = 0; i < fixed_param_count; i++) {
+    Dart_Handle args[] = { Dart_False() };
+    Dart_Handle fixed_param =
+      Dart_New(param_cls, Dart_Null(), ARRAY_SIZE(args), args);
+    if (Dart_IsError(fixed_param)) {
+     return fixed_param;
+    }
+    result = Dart_ListSetAt(parameter_mirrors, i, fixed_param);
+    if (Dart_IsError(result)) {
+     return result;
+    }
+  }
+
+  for (int i = 0; i < opt_param_count; i++) {
+    Dart_Handle args[] = { Dart_True() };
+    Dart_Handle opt_param =
+      Dart_New(param_cls, Dart_Null(), ARRAY_SIZE(args), args);
+    if (Dart_IsError(opt_param)) {
+     return opt_param;
+    }
+    result = Dart_ListSetAt(parameter_mirrors, i+fixed_param_count, opt_param);
+    if (Dart_IsError(result)) {
+     return result;
+    }
+  }
+
   // TODO(turnidge): Implement constructor kinds (arguments 7 - 10).
   Dart_Handle args[] = {
     func_name,
     lib_mirror,
+    parameter_mirrors,
     Dart_NewBoolean(is_static),
     Dart_NewBoolean(is_abstract),
     Dart_NewBoolean(is_getter),
     Dart_NewBoolean(is_setter),
     Dart_NewBoolean(is_constructor),
     Dart_False(),
     Dart_False(),
     Dart_False(),
     Dart_False(),
   };
@@ skipping 273 matching lines @@
   if (Dart_IsError(cls)) {
     return cls;
   }
 
   // TODO(turnidge): This is wrong.  The Null class is distinct from object.
   Dart_Handle object_class = Dart_GetClass(CoreLib(), Dart_NewString("Object"));
 
   Dart_Handle args[] = {
     CreateVMReference(Dart_Null()),
     CreateLazyMirror(object_class),
-    Dart_True(),
     Dart_Null(),
   };
   Dart_Handle mirror = Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
   return mirror;
 }
 
 
 static Dart_Handle CreateInstanceMirror(Dart_Handle instance) {
   if (Dart_IsNull(instance)) {
     return CreateNullMirror();
   }
   ASSERT(Dart_IsInstance(instance));
   Dart_Handle cls_name = Dart_NewString("_LocalInstanceMirrorImpl");
   Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
   if (Dart_IsError(cls)) {
     return cls;
   }
   Dart_Handle instance_cls = Dart_InstanceGetClass(instance);
   if (Dart_IsError(instance_cls)) {
     return instance_cls;
   }
 
-  bool is_simple = IsSimpleValue(instance);
   Dart_Handle args[] = {
     CreateVMReference(instance),
     CreateLazyMirror(instance_cls),
-    Dart_NewBoolean(is_simple),
     instance
   };
   Dart_Handle mirror = Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
   return mirror;
 }
 
 
 static Dart_Handle CreateMirroredError(Dart_Handle error) {
   ASSERT(Dart_IsError(error));
   if (Dart_IsUnhandledExceptionError(error)) {
@@ skipping 85 matching lines @@
   Dart_SetReturnValue(args, wrapped_result);
 }
 
 void HandleMirrorsMessage(Isolate* isolate,
                           Dart_Port reply_port,
                           const Instance& message) {
   UNIMPLEMENTED();
 }
 
 }  // namespace dart