Changes to mirrors in support of metadata access at runtime. Assumes VM changes in flight.…

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 "vm/dart_api_impl.h"
 #include "vm/bootstrap_natives.h"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
@@ skipping 61 matching lines @@
   if (Dart_IsError(cls)) {
     return cls;
   }
   Dart_Handle result = Dart_ObjectIsType(object, cls, is_mirror);
   if (Dart_IsError(result)) {
     return result;
   }
   return Dart_True();  // Indicates success.  Result is in is_mirror.
 }
 
+static Dart_Handle IsMethodMirror(Dart_Handle object, bool* is_mirror) {
+  Dart_Handle cls_name = NewString("MethodMirror");
+  Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
+  if (Dart_IsError(cls)) {
+    return cls;
+  }
+  Dart_Handle result = Dart_ObjectIsType(object, cls, is_mirror);
+  if (Dart_IsError(result)) {
+    return result;
+  }
+  return Dart_True();  // Indicates success.  Result is in is_mirror.
+}
+
+static Dart_Handle IsVariableMirror(Dart_Handle object, bool* is_mirror) {
+  Dart_Handle cls_name = NewString("VariableMirror");
+  Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
+  if (Dart_IsError(cls)) {
+    return cls;
+  }
+  Dart_Handle result = Dart_ObjectIsType(object, cls, is_mirror);
+  if (Dart_IsError(result)) {
+    return result;
+  }
+  return Dart_True();  // Indicates success.  Result is in is_mirror.
+}
+
 
 static bool IsSimpleValue(Dart_Handle object) {
   return (Dart_IsNull(object) ||
           Dart_IsNumber(object) ||
           Dart_IsString(object) ||
           Dart_IsBoolean(object));
 }
 
 
 static void FreeVMReference(Dart_WeakPersistentHandle weak_ref, void* data) {
@@ skipping 34 matching lines @@
   // handle.
   void* perm_handle_data = reinterpret_cast<void*>(perm_handle);
   Dart_WeakPersistentHandle weak_ref =
       Dart_NewWeakPersistentHandle(vm_ref, perm_handle_data, FreeVMReference);
   ASSERT(weak_ref != NULL);
 
   // Success.
   return vm_ref;
 }
 
+static Dart_Handle StringFromSymbol(Dart_Handle symbol) {
+  Dart_Handle result = Dart_Invoke(MirrorLib(), NewString("_n"), 1, &symbol);
+  return result;
+}
+
 
 static Dart_Handle UnwrapVMReference(Dart_Handle vm_ref) {
   // Retrieve the persistent handle from the VMReference
   intptr_t perm_handle_value = 0;
   Dart_Handle result =
       Dart_GetNativeInstanceField(vm_ref, 0, &perm_handle_value);
   if (Dart_IsError(result)) {
     return result;
   }
   Dart_PersistentHandle perm_handle =
       reinterpret_cast<Dart_PersistentHandle>(perm_handle_value);
   ASSERT(perm_handle != NULL);
   Dart_Handle handle = Dart_HandleFromPersistent(perm_handle);
   ASSERT(handle != NULL);
   ASSERT(!Dart_IsError(handle));
   return handle;
 }
 
+static Dart_Handle UnwrapMirror(Dart_Handle mirror);
 
-static Dart_Handle UnwrapMirror(Dart_Handle mirror) {
+static Dart_Handle UnwrapObjectMirror(Dart_Handle mirror) {
   Dart_Handle field_name = NewString("_reference");
   Dart_Handle vm_ref = Dart_GetField(mirror, field_name);
   if (Dart_IsError(vm_ref)) {
     return vm_ref;
   }
   return UnwrapVMReference(vm_ref);
 }
 
 
+static Dart_Handle UnwrapMethodMirror(Dart_Handle methodMirror) {
+  Dart_Handle namefield_name = NewString("simpleName");
+  Dart_Handle name_ref = Dart_GetField(methodMirror, namefield_name);
+  if (Dart_IsError(name_ref)) {
+    return name_ref;
+  }
+  Dart_Handle ownerfield_name = NewString("_owner");
+  Dart_Handle owner_mirror = Dart_GetField(methodMirror, ownerfield_name);
+  if (Dart_IsError(owner_mirror)) {
+    return owner_mirror;
+  }
+  Dart_Handle owner = UnwrapMirror(owner_mirror);
+  if (Dart_IsError(owner)) {
+    return owner;
+  }
+  Dart_Handle func = Dart_LookupFunction(owner, StringFromSymbol(name_ref));
+  if (Dart_IsError(func)) {
+    return func;
+  }
+  ASSERT(!Dart_IsNull(func));
+  return func;
+}
+
+static Dart_Handle UnwrapVariableMirror(Dart_Handle variableMirror) {
+  Dart_Handle namefield_name = NewString("simpleName");
+  Dart_Handle name_ref = Dart_GetField(variableMirror, namefield_name);
+  if (Dart_IsError(name_ref)) {
+    return name_ref;
+  }
+  Dart_Handle ownerfield_name = NewString("_owner");
+  Dart_Handle owner_mirror = Dart_GetField(variableMirror, ownerfield_name);
+  ASSERT(!Dart_IsNull(owner_mirror));
+  if (Dart_IsError(owner_mirror)) {
+    return owner_mirror;
+  }
+  Dart_Handle owner = UnwrapMirror(owner_mirror);
+  if (Dart_IsError(owner)) {
+    return owner;
+  }
+  Dart_Handle variable =
+  Dart_LookupVariable(owner, StringFromSymbol(name_ref));
+  if (Dart_IsError(variable)) {
+    return variable;
+  }
+  ASSERT(!Dart_IsNull(variable));
+  return variable;
+}
+
+static Dart_Handle UnwrapMirror(Dart_Handle mirror) {
+  // Caveat Emptor:
+  // only works for ObjectMirrors, VariableMirrors and MethodMirrors
+  // and their subtypes
+  bool is_method_mirror = false;
+  Dart_Handle result = IsMethodMirror(mirror, &is_method_mirror);
+  if (Dart_IsError(result)) {
+    return result;
+  }
+  if (is_method_mirror) {
+    return UnwrapMethodMirror(mirror);
+  }
+  bool is_variable_mirror = false;
+  result = IsVariableMirror(mirror, &is_variable_mirror);
+  if (Dart_IsError(result)) {
+    return result;
+  }
+  if (is_variable_mirror) {
+    return UnwrapVariableMirror(mirror);
+  }
+  return UnwrapObjectMirror(mirror);
+  // will return nonsense if mirror is not an ObjectMirror
+}
+
 static Dart_Handle UnwrapArg(Dart_Handle arg) {
     if (Dart_IsError(arg)) {
       return arg;
     }
     bool is_mirror = false;
     Dart_Handle result = IsMirror(arg, &is_mirror);
     if (Dart_IsError(result)) {
       return result;
     }
     if (is_mirror) {
@@ skipping 284 matching lines @@
     return CreateTypedefMirror(intf, intf_name, lib, lib_mirror);
   }
 
   Dart_Handle cls_name = NewString("_LocalClassMirrorImpl");
   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?
+  // TODO(gbracha): this is probably the root of bug 7868
   Dart_Handle super_class = Dart_GetSuperclass(intf);
   if (Dart_IsNull(super_class)) {
     super_class = Dart_GetClass(CoreLib(), NewString("Object"));
   }
   // TODO(turnidge): Simplify code, now that default classes have been removed.
   Dart_Handle default_class = Dart_Null();
 
   Dart_Handle intf_mirror = CreateLazyMirror(intf);
   if (Dart_IsError(intf_mirror)) {
     return intf_mirror;
@@ skipping 622 matching lines @@
                                          name_handle,
                                          lib_handle,
                                          lib_mirror);
   if (Dart_IsError(result)) {
     Dart_PropagateError(result);
   }
   Dart_SetReturnValue(args, result);
   Dart_ExitScope();
 }
 
+void NATIVE_ENTRY_FUNCTION(Mirrors_metadata)(Dart_NativeArguments args) {
+  Dart_EnterScope();
+  Dart_Handle mirror = Dart_GetNativeArgument(args, 0);
+
+  Dart_Handle reflectee = UnwrapMirror(mirror);
+  Dart_Handle result = Dart_GetMetadata(reflectee);
+  if (Dart_IsError(result)) {
+    Dart_PropagateError(result);
+  }
+  ASSERT(Dart_IsList(result));
+  Dart_SetReturnValue(args, result);
+  Dart_ExitScope();
+}
+
 void NATIVE_ENTRY_FUNCTION(LocalObjectMirrorImpl_invoke)(
     Dart_NativeArguments args) {
   Dart_EnterScope();
   Dart_Handle mirror = Dart_GetNativeArgument(args, 0);
   Dart_Handle member_name = Dart_GetNativeArgument(args, 1);
   // The arguments are either simple values or instance mirrors.
   Dart_Handle positional_arguments = Dart_GetNativeArgument(args, 2);
   Dart_Handle async = Dart_GetNativeArgument(args, 3);
 
   Dart_Handle reflectee = UnwrapMirror(mirror);
@@ skipping 150 matching lines @@
   }
 
   Dart_Handle wrapped_result = CreateInstanceMirror(result);
   if (Dart_IsError(wrapped_result)) {
     Dart_PropagateError(wrapped_result);
   }
   Dart_SetReturnValue(args, wrapped_result);
   Dart_ExitScope();
 }
 
-
 void HandleMirrorsMessage(Isolate* isolate,
                           Dart_Port reply_port,
                           const Instance& message) {
   UNIMPLEMENTED();
 }
 
 }  // namespace dart