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 180 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);
+    const int kNumArgs = 1;
+    Dart_Handle args[kNumArgs];
+    args[0] = Dart_LibraryName(target);
+    return Dart_New(cls, Dart_Null(), kNumArgs, 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);
+    }
+
+    const int kNumArgs = 2;
+    Dart_Handle args[kNumArgs];
+    args[0] = lib_name;
+    args[1] = Dart_ClassName(target);
+    return Dart_New(cls, Dart_Null(), kNumArgs, 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 member_map = CreateMemberMap(intf);
+  if (Dart_IsError(member_map)) {
+    return member_map;
+  }
+
+  const int kNumArgs = 8;

[cshapiro, 2012/06/28 23:57:47]

Can this be eliminated, maybe by something like this

Dart_Handle args[] = { ... , ... , ... };

[turnidge, 2012/07/09 23:45:17]

Done.

   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[3] = lib_mirror;
+  args[4] = CreateLazyMirror(super_class);
   args[5] = CreateImplementsList(intf);
-  args[6] = CreateLazyInterfaceMirror(default_class);
+  args[6] = CreateLazyMirror(default_class);
+  args[7] = member_map;
   Dart_Handle mirror = Dart_New(cls, Dart_Null(), kNumArgs, args);
   return mirror;
 }
 
 
-static Dart_Handle CreateLibraryMemberMap(Dart_Handle lib) {
+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).
+  const int kNumArgs = 11;

[cshapiro, 2012/06/28 23:57:47]

Same here, see above regarding the kNumArgs stuff.

[turnidge, 2012/07/09 23:45:17]

Done.

+  Dart_Handle args[kNumArgs];
+  args[0] = func_name;
+  args[1] = lib_mirror;
+  args[2] = Dart_NewBoolean(is_static);
+  args[3] = Dart_NewBoolean(is_abstract);
+  args[4] = Dart_NewBoolean(is_getter);
+  args[5] = Dart_NewBoolean(is_setter);
+  args[6] = Dart_NewBoolean(is_constructor);
+  args[7] = Dart_False();
+  args[8] = Dart_False();
+  args[9] = Dart_False();
+  args[10] = Dart_False();
+  Dart_Handle mirror = Dart_New(cls, Dart_Null(), kNumArgs, 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;
+  }
+
+  const int kNumArgs = 4;

[cshapiro, 2012/06/28 23:57:47]

Same here too.

[turnidge, 2012/07/09 23:45:17]

Done.

+  Dart_Handle args[kNumArgs];
+  args[0] = var_name;
+  args[1] = lib_mirror;
+  args[2] = Dart_NewBoolean(is_static);
+  args[3] = Dart_NewBoolean(is_final);
+  Dart_Handle mirror = Dart_New(cls, Dart_Null(), kNumArgs, args);
+  return mirror;
+}
+
+
+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 map = MapNew();
 
-  Dart_Handle intf_names = Dart_LibraryGetClassNames(lib);
-  if (Dart_IsError(intf_names)) {
-    return intf_names;
-  }
+  Dart_Handle names;
+  Dart_Handle result;
   intptr_t len;

[cshapiro, 2012/06/28 23:57:47]

How do we know that len is always initialized?  Can we limit its scope?  Can we
exit early if "owner" is not a library?

[turnidge, 2012/07/09 23:45:17]

Taken care of by splitting out the 3 helper functions as suggested below.

-  Dart_Handle result = Dart_ListLength(intf_names, &len);
+
+  if (Dart_IsLibrary(owner)) {
+    // Add classes/interfaces.
+    names = Dart_LibraryGetClassNames(owner);

[cshapiro, 2012/06/28 23:57:47]

Since names here is not the same as names below, it would be nice if another
variable or another variable scope was used.

[turnidge, 2012/07/09 23:45:17]

Done.

+    if (Dart_IsError(names)) {
+      return names;
+    }
+    result = Dart_ListLength(names, &len);
+    if (Dart_IsError(result)) {
+      return result;
+    }
+    for (int i = 0; i < len; i++) {
+      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, owner, owner_mirror);
+      if (Dart_IsError(intf_mirror)) {
+        return intf_mirror;
+      }
+      result = MapAdd(map, intf_name, intf_mirror);
+      if (Dart_IsError(result)) {
+        return result;
+      }
+    }
+  }
+
+  // Add functions.
+  names = Dart_GetFunctionNames(owner);
+  if (Dart_IsError(names)) {
+    return names;
+  }
+  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);
-    if (Dart_IsError(intf)) {
-      return intf;
-    }
-    Dart_Handle intf_mirror = CreateInterfaceMirror(intf, intf_name, lib);
-    if (Dart_IsError(intf_mirror)) {
-      return intf_mirror;
-    }
-    result = MapAdd(map, intf_name, intf_mirror);
-  }
+    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;
+    }
+  }
+
+  // Add variables.
+  names = Dart_GetVariableNames(owner);

[cshapiro, 2012/06/28 23:57:47]

It looks like there are 3 different functions inside this one function.  Maybe
you can split this up into 3 separate functions for functions libraries and
variables.

[turnidge, 2012/07/09 23:45:17]

Done.

+  if (Dart_IsError(names)) {
+    return names;
+  }
+  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 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);
@@ skipping 75 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"));
 
   const int kNumArgs = 4;
   Dart_Handle args[kNumArgs];
   args[0] = CreateVMReference(Dart_Null());
-  args[1] = CreateLazyInterfaceMirror(object_class);
+  args[1] = CreateLazyMirror(object_class);
   args[2] = Dart_True();
   args[3] = Dart_Null();
   Dart_Handle mirror = Dart_New(cls, Dart_Null(), kNumArgs, 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[1] = CreateLazyMirror(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);
   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