Implement method and variable reflection in dart:mirrors.

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 33 matching lines @@
 static Dart_Handle MapNew() {
   Dart_Handle cls = Dart_GetClass(CoreLib(), Dart_NewString("Map"));
   if (Dart_IsError(cls)) {
     return cls;
   }
   return Dart_New(cls, Dart_Null(), 0, NULL);
 }
 
 
 static Dart_Handle MapAdd(Dart_Handle map, Dart_Handle key, Dart_Handle value) {
-  const int kNumArgs = 2;
-  Dart_Handle args[kNumArgs];
-  args[0] = key;
-  args[1] = value;
-  return Dart_Invoke(map, Dart_NewString("[]="), kNumArgs, args);
+  Dart_Handle args[] = { key, value };
+  return Dart_Invoke(map, Dart_NewString("[]="), ARRAY_SIZE(args), args);
 }
 
 
 static Dart_Handle MapGet(Dart_Handle map, Dart_Handle key) {
-  const int kNumArgs = 1;
-  Dart_Handle args[kNumArgs];
-  args[0] = key;
-  return Dart_Invoke(map, Dart_NewString("[]"), kNumArgs, args);
+  Dart_Handle args[] = { key };
+  return Dart_Invoke(map, Dart_NewString("[]"), ARRAY_SIZE(args), args);
 }
 
 
 static Dart_Handle MirrorLib() {
   Dart_Handle mirror_lib_name = Dart_NewString("dart:mirrors");
   return Dart_LookupLibrary(mirror_lib_name);
 }
 
 
 static Dart_Handle IsMirror(Dart_Handle object, bool* is_mirror) {
@@ skipping 114 matching lines @@
     } else {
       // Simple value.
       ASSERT(IsSimpleValue(arg));
       arg_array->Add(arg);
     }
   }
   return Dart_True();
 }
 
 
-static Dart_Handle CreateLazyLibraryMirror(Dart_Handle lib) {
-  if (Dart_IsNull(lib)) {
-    return lib;
+static Dart_Handle CreateLazyMirror(Dart_Handle target) {
+  if (Dart_IsNull(target)) {
+    return target;
   }
-  Dart_Handle cls_name = Dart_NewString("_LazyLibraryMirror");
-  Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
-  const int kNumArgs = 1;
-  Dart_Handle args[kNumArgs];
-  args[0] = Dart_LibraryName(lib);
-  return Dart_New(cls, Dart_Null(), kNumArgs, args);
+  if (Dart_IsLibrary(target)) {
+    Dart_Handle cls_name = Dart_NewString("_LazyLibraryMirror");
+    Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
+    Dart_Handle args[] = { Dart_LibraryName(target) };
+    return Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
+  } else {
+    ASSERT(Dart_IsClass(target) || Dart_IsInterface(target));
+    Dart_Handle cls_name = Dart_NewString("_LazyInterfaceMirror");
+    Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
+
+    Dart_Handle lib = Dart_ClassGetLibrary(target);
+    Dart_Handle lib_name;
+    if (Dart_IsNull(lib)) {
+      lib_name = Dart_Null();
+    } else {
+      lib_name = Dart_LibraryName(lib);
+    }
+
+    Dart_Handle args[] = { lib_name, Dart_ClassName(target) };
+    return Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
+  }
 }
 
 
-static Dart_Handle CreateLazyInterfaceMirror(Dart_Handle intf) {
-  if (Dart_IsNull(intf)) {
-    return intf;
-  }
-  Dart_Handle cls_name = Dart_NewString("_LazyInterfaceMirror");
-  Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
-  const int kNumArgs = 2;
-  Dart_Handle args[kNumArgs];
-  args[0] = Dart_LibraryName(Dart_ClassGetLibrary(intf));
-  args[1] = Dart_ClassName(intf);
-  return Dart_New(cls, Dart_Null(), kNumArgs, args);
-}
-
-
 static Dart_Handle CreateImplementsList(Dart_Handle intf) {
   intptr_t len = 0;
   Dart_Handle result = Dart_ClassGetInterfaceCount(intf, &len);
   if (Dart_IsError(result)) {
     return result;
   }
 
   Dart_Handle mirror_list = Dart_NewList(len);
   if (Dart_IsError(mirror_list)) {
     return mirror_list;
   }
 
   for (int i = 0; i < len; i++) {
     Dart_Handle interface = Dart_ClassGetInterfaceAt(intf, i);
     if (Dart_IsError(interface)) {
       return interface;
     }
-    Dart_Handle mirror = CreateLazyInterfaceMirror(interface);
+    Dart_Handle mirror = CreateLazyMirror(interface);
     if (Dart_IsError(mirror)) {
       return mirror;
     }
     Dart_Handle result = Dart_ListSetAt(mirror_list, i, mirror);
     if (Dart_IsError(result)) {
       return result;
     }
   }
   return mirror_list;
 }
 
 
+static Dart_Handle CreateMemberMap(Dart_Handle owner);
+
+
 static Dart_Handle CreateInterfaceMirror(Dart_Handle intf,
                                          Dart_Handle intf_name,
-                                         Dart_Handle lib) {
+                                         Dart_Handle lib,
+                                         Dart_Handle lib_mirror) {
   ASSERT(Dart_IsClass(intf) || Dart_IsInterface(intf));
   Dart_Handle cls_name = Dart_NewString("_LocalInterfaceMirrorImpl");
   Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
   if (Dart_IsError(cls)) {
     return cls;
   }
 
   // TODO(turnidge): Why am I getting Null when I expect Object?
   Dart_Handle super_class = Dart_GetSuperclass(intf);
   if (Dart_IsNull(super_class)) {
     super_class = Dart_GetClass(CoreLib(), Dart_NewString("Object"));
   }
   Dart_Handle default_class = Dart_ClassGetDefault(intf);
-
-  const int kNumArgs = 7;
-  Dart_Handle args[kNumArgs];
-  args[0] = CreateVMReference(intf);
-  args[1] = intf_name;
-  args[2] = Dart_NewBoolean(Dart_IsClass(intf));
-  args[3] = CreateLazyLibraryMirror(lib);
-  args[4] = CreateLazyInterfaceMirror(super_class);
-  args[5] = CreateImplementsList(intf);
-  args[6] = CreateLazyInterfaceMirror(default_class);
-  Dart_Handle mirror = Dart_New(cls, Dart_Null(), kNumArgs, args);
+  Dart_Handle member_map = CreateMemberMap(intf);
+  if (Dart_IsError(member_map)) {
+    return member_map;
+  }
+
+  Dart_Handle args[] = {
+    CreateVMReference(intf),
+    intf_name,
+    Dart_NewBoolean(Dart_IsClass(intf)),
+    lib_mirror,
+    CreateLazyMirror(super_class),
+    CreateImplementsList(intf),
+    CreateLazyMirror(default_class),
+    member_map,
+  };
+  Dart_Handle mirror = Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
   return mirror;
 }
 
 
-static Dart_Handle CreateLibraryMemberMap(Dart_Handle lib) {
-  // TODO(turnidge): This should be an immutable map.
-  Dart_Handle map = MapNew();
-
-  Dart_Handle intf_names = Dart_LibraryGetClassNames(lib);
-  if (Dart_IsError(intf_names)) {
-    return intf_names;
+static Dart_Handle CreateMethodMirror(Dart_Handle func,
+                                      Dart_Handle func_name,
+                                      Dart_Handle lib_mirror) {
+  ASSERT(Dart_IsFunction(func));
+  Dart_Handle cls_name = Dart_NewString("_LocalMethodMirrorImpl");
+  Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
+  if (Dart_IsError(cls)) {
+    return cls;
+  }
+
+  bool is_static = false;
+  bool is_abstract = false;
+  bool is_getter = false;
+  bool is_setter = false;
+  bool is_constructor = false;
+
+  Dart_Handle result = Dart_FunctionIsStatic(func, &is_static);
+  if (Dart_IsError(result)) {
+    return result;
+  }
+  result = Dart_FunctionIsAbstract(func, &is_abstract);
+  if (Dart_IsError(result)) {
+    return result;
+  }
+  result = Dart_FunctionIsGetter(func, &is_getter);
+  if (Dart_IsError(result)) {
+    return result;
+  }
+  result = Dart_FunctionIsSetter(func, &is_setter);
+  if (Dart_IsError(result)) {
+    return result;
+  }
+  result = Dart_FunctionIsConstructor(func, &is_constructor);
+  if (Dart_IsError(result)) {
+    return result;
+  }
+
+  // TODO(turnidge): Implement constructor kinds (arguments 7 - 10).
+  Dart_Handle args[] = {
+    func_name,
+    lib_mirror,
+    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(),
+  };
+  Dart_Handle mirror = Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
+  return mirror;
+}
+
+
+static Dart_Handle CreateVariableMirror(Dart_Handle var,
+                                        Dart_Handle var_name,
+                                        Dart_Handle lib_mirror) {
+  ASSERT(Dart_IsVariable(var));
+  Dart_Handle cls_name = Dart_NewString("_LocalVariableMirrorImpl");
+  Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
+  if (Dart_IsError(cls)) {
+    return cls;
+  }
+
+  bool is_static = false;
+  bool is_final = false;
+
+  Dart_Handle result = Dart_VariableIsStatic(var, &is_static);
+  if (Dart_IsError(result)) {
+    return result;
+  }
+  result = Dart_VariableIsFinal(var, &is_final);
+  if (Dart_IsError(result)) {
+    return result;
+  }
+
+  Dart_Handle args[] = {
+    var_name,
+    lib_mirror,
+    Dart_NewBoolean(is_static),
+    Dart_NewBoolean(is_final),
+  };
+  Dart_Handle mirror = Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
+  return mirror;
+}
+
+
+static Dart_Handle AddMemberClasses(Dart_Handle map,
+                                    Dart_Handle owner,
+                                    Dart_Handle owner_mirror) {
+  ASSERT(Dart_IsLibrary(owner));
+  Dart_Handle result;
+  Dart_Handle names = Dart_LibraryGetClassNames(owner);
+  if (Dart_IsError(names)) {
+    return names;
   }
   intptr_t len;
-  Dart_Handle result = Dart_ListLength(intf_names, &len);
+  result = Dart_ListLength(names, &len);
   if (Dart_IsError(result)) {
     return result;
   }
   for (int i = 0; i < len; i++) {
-    Dart_Handle intf_name = Dart_ListGetAt(intf_names, i);
-    Dart_Handle intf = Dart_GetClass(lib, intf_name);
+    Dart_Handle intf_name = Dart_ListGetAt(names, i);
+    Dart_Handle intf = Dart_GetClass(owner, intf_name);
     if (Dart_IsError(intf)) {
       return intf;
     }
-    Dart_Handle intf_mirror = CreateInterfaceMirror(intf, intf_name, lib);
+    Dart_Handle intf_mirror =
+        CreateInterfaceMirror(intf, intf_name, owner, owner_mirror);
     if (Dart_IsError(intf_mirror)) {
       return intf_mirror;
     }
     result = MapAdd(map, intf_name, intf_mirror);
+    if (Dart_IsError(result)) {
+      return result;
+    }
+  }
+  return Dart_True();
+}
+
+
+static Dart_Handle AddMemberFunctions(Dart_Handle map,
+                                      Dart_Handle owner,
+                                      Dart_Handle owner_mirror) {
+  Dart_Handle result;
+  Dart_Handle names = Dart_GetFunctionNames(owner);
+  if (Dart_IsError(names)) {
+    return names;
+  }
+  intptr_t len;
+  result = Dart_ListLength(names, &len);
+  if (Dart_IsError(result)) {
+    return result;
+  }
+  for (int i = 0; i < len; i++) {
+    Dart_Handle func_name = Dart_ListGetAt(names, i);
+    Dart_Handle func = Dart_LookupFunction(owner, func_name);
+    if (Dart_IsError(func)) {
+      return func;
+    }
+    ASSERT(!Dart_IsNull(func));
+    Dart_Handle func_mirror = CreateMethodMirror(func, func_name, owner_mirror);
+    if (Dart_IsError(func_mirror)) {
+      return func_mirror;
+    }
+    result = MapAdd(map, func_name, func_mirror);
+    if (Dart_IsError(result)) {
+      return result;
+    }
+  }
+  return Dart_True();
+}
+
+
+static Dart_Handle AddMemberVariables(Dart_Handle map,
+                                      Dart_Handle owner,
+                                      Dart_Handle owner_mirror) {
+  Dart_Handle result;
+  Dart_Handle names = Dart_GetVariableNames(owner);
+  if (Dart_IsError(names)) {
+    return names;
+  }
+  intptr_t len;
+  result = Dart_ListLength(names, &len);
+  if (Dart_IsError(result)) {
+    return result;
+  }
+  for (int i = 0; i < len; i++) {
+    Dart_Handle var_name = Dart_ListGetAt(names, i);
+    Dart_Handle var = Dart_LookupVariable(owner, var_name);
+    if (Dart_IsError(var)) {
+      return var;
+    }
+    ASSERT(!Dart_IsNull(var));
+    Dart_Handle var_mirror = CreateVariableMirror(var, var_name, owner_mirror);
+    if (Dart_IsError(var_mirror)) {
+      return var_mirror;
+    }
+    result = MapAdd(map, var_name, var_mirror);
+    if (Dart_IsError(result)) {
+      return result;
+    }
+  }
+  return Dart_True();
+}
+
+
+static Dart_Handle CreateMemberMap(Dart_Handle owner) {
+  // TODO(turnidge): This should be an immutable map.
+  Dart_Handle owner_mirror = CreateLazyMirror(owner);
+  if (Dart_IsError(owner_mirror)) {
+    return owner_mirror;
+  }
+  Dart_Handle result;
+  Dart_Handle map = MapNew();
+  if (Dart_IsLibrary(owner)) {
+    result = AddMemberClasses(map, owner, owner_mirror);
+    if (Dart_IsError(result)) {
+      return result;
+    }
+  }
+  result = AddMemberFunctions(map, owner, owner_mirror);
+  if (Dart_IsError(result)) {
+    return result;
+  }
+  result = AddMemberVariables(map, owner, owner_mirror);
+  if (Dart_IsError(result)) {
+    return result;
   }
   return map;
 }
 
 
 static Dart_Handle CreateLibraryMirror(Dart_Handle lib) {
   Dart_Handle cls_name = Dart_NewString("_LocalLibraryMirrorImpl");
   Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
   if (Dart_IsError(cls)) {
     return cls;
   }
-  Dart_Handle member_map = CreateLibraryMemberMap(lib);
+  Dart_Handle member_map = CreateMemberMap(lib);
   if (Dart_IsError(member_map)) {
     return member_map;
   }
-  const int kNumArgs = 4;
-  Dart_Handle args[kNumArgs];
-  args[0] = CreateVMReference(lib);
-  args[1] = Dart_LibraryName(lib);
-  args[2] = Dart_LibraryUrl(lib);
-  args[3] = member_map;
-  Dart_Handle lib_mirror = Dart_New(cls, Dart_Null(), kNumArgs, args);
+  Dart_Handle args[] = {
+    CreateVMReference(lib),
+    Dart_LibraryName(lib),
+    Dart_LibraryUrl(lib),
+    member_map,
+  };
+  Dart_Handle lib_mirror = Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
   if (Dart_IsError(lib_mirror)) {
     return lib_mirror;
   }
 
   return lib_mirror;
 }
 
 
 static Dart_Handle CreateLibrariesMap() {
   // TODO(turnidge): This should be an immutable map.
@@ skipping 38 matching lines @@
     return libraries;
   }
 
   // Lookup the root_lib_mirror from the library list to canonicalize it.
   Dart_Handle root_lib_name = Dart_LibraryName(Dart_RootLibrary());
   Dart_Handle root_lib_mirror = MapGet(libraries, root_lib_name);
   if (Dart_IsError(root_lib_mirror)) {
     return root_lib_mirror;
   }
 
-  const int kNumArgs = 3;
-  Dart_Handle args[kNumArgs];
-  args[0] = Dart_DebugName();
-  args[1] = root_lib_mirror;
-  args[2] = libraries;
-  Dart_Handle mirror = Dart_New(cls, Dart_Null(), kNumArgs, args);
+  Dart_Handle args[] = {
+    Dart_DebugName(),
+    root_lib_mirror,
+    libraries,
+  };
+  Dart_Handle mirror = Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
   if (Dart_IsError(mirror)) {
     return mirror;
   }
 
   return mirror;
 }
 
 
 static Dart_Handle CreateNullMirror() {
   Dart_Handle cls_name = Dart_NewString("_LocalInstanceMirrorImpl");
   Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
   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"));
 
-  const int kNumArgs = 4;
-  Dart_Handle args[kNumArgs];
-  args[0] = CreateVMReference(Dart_Null());
-  args[1] = CreateLazyInterfaceMirror(object_class);
-  args[2] = Dart_True();
-  args[3] = Dart_Null();
-  Dart_Handle mirror = Dart_New(cls, Dart_Null(), kNumArgs, args);
+  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);
-  const int kNumArgs = 4;
-  Dart_Handle args[kNumArgs];
-  args[0] = CreateVMReference(instance);
-  args[1] = CreateLazyInterfaceMirror(instance_cls);
-  args[2] = Dart_NewBoolean(is_simple);
-  args[3] = (is_simple ? instance : Dart_Null());
-  Dart_Handle mirror = Dart_New(cls, Dart_Null(), kNumArgs, args);
+  Dart_Handle args[] = {
+    CreateVMReference(instance),
+    CreateLazyMirror(instance_cls),
+    Dart_NewBoolean(is_simple),
+    (is_simple ? instance : Dart_Null()),
+  };
+  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)) {
     Dart_Handle exc = Dart_ErrorGetException(error);
     if (Dart_IsError(exc)) {
       return exc;
     }
     Dart_Handle exc_string = Dart_ToString(exc);
     if (Dart_IsError(exc_string)) {
       // Only propagate fatal errors from exc.toString().  Ignore the rest.
       if (Dart_IsFatalError(exc_string)) {
         return exc_string;
       }
       exc_string = Dart_Null();
     }
 
     Dart_Handle stack = Dart_ErrorGetStacktrace(error);
     if (Dart_IsError(stack)) {
       return stack;
     }
     Dart_Handle cls_name = Dart_NewString("MirroredUncaughtExceptionError");
     Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
-    const int kNumArgs = 3;
-    Dart_Handle args[kNumArgs];
-    args[0] = CreateInstanceMirror(exc);
-    args[1] = exc_string;
-    args[2] = stack;
-    Dart_Handle mirrored_exc = Dart_New(cls, Dart_Null(), kNumArgs, args);
+    Dart_Handle args[] = {
+      CreateInstanceMirror(exc),
+      exc_string,
+      stack,
+    };
+    Dart_Handle mirrored_exc =
+        Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
     return Dart_NewUnhandledExceptionError(mirrored_exc);
   } else if (Dart_IsApiError(error) ||
              Dart_IsCompilationError(error)) {
     Dart_Handle cls_name = Dart_NewString("MirroredCompilationError");
     Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
-    const int kNumArgs = 1;
-    Dart_Handle args[kNumArgs];
-    args[0] = Dart_NewString(Dart_GetError(error));
-    Dart_Handle mirrored_exc = Dart_New(cls, Dart_Null(), kNumArgs, args);
+    Dart_Handle args[] = { Dart_NewString(Dart_GetError(error)) };
+    Dart_Handle mirrored_exc =
+        Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
     return Dart_NewUnhandledExceptionError(mirrored_exc);
   } else {
     ASSERT(Dart_IsFatalError(error));
     return error;
   }
 }
 
 
 void NATIVE_ENTRY_FUNCTION(Mirrors_makeLocalIsolateMirror)(
     Dart_NativeArguments args) {
@@ skipping 41 matching lines @@
   Dart_SetReturnValue(args, wrapped_result);
 }
 
 void HandleMirrorsMessage(Isolate* isolate,
                           Dart_Port reply_port,
                           const Instance& message) {
   UNIMPLEMENTED();
 }
 
 }  // namespace dart