Implement metadata as an internal native. Be honest about which mirrors don't yet support metadata …

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 78 matching lines @@
     return type;
   }
   Dart_Handle result = Dart_ObjectIsType(object, type, is_mirror);
   if (Dart_IsError(result)) {
     return result;
   }
   return Dart_True();  // Indicates success.  Result is in is_mirror.
 }
 
 
-static void FreeVMReference(Dart_WeakPersistentHandle weak_ref, void* data) {
-  Dart_PersistentHandle perm_handle =
-      reinterpret_cast<Dart_PersistentHandle>(data);
-  Dart_DeletePersistentHandle(perm_handle);
-  Dart_DeleteWeakPersistentHandle(weak_ref);
-}
-
-
-static Dart_Handle CreateVMReference(Dart_Handle handle) {
-  // Create the VMReference object.
-  Dart_Handle cls_name = NewString("VMReference");
-  Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
-  if (Dart_IsError(type)) {
-    return type;
-  }
-  Dart_Handle vm_ref =  Dart_New(type, Dart_Null(), 0, NULL);
-  if (Dart_IsError(vm_ref)) {
-    return vm_ref;
-  }
-
-  // Allocate a persistent handle.
-  Dart_PersistentHandle perm_handle = Dart_NewPersistentHandle(handle);
-  ASSERT(perm_handle != NULL);
-
-  // Store the persistent handle in the VMReference.
-  intptr_t perm_handle_value = reinterpret_cast<intptr_t>(perm_handle);
-  Dart_Handle result =
-      Dart_SetNativeInstanceField(vm_ref, 0, perm_handle_value);
-  if (Dart_IsError(result)) {
-    Dart_DeletePersistentHandle(perm_handle);
-    return result;
-  }
-
-  // Create a weak reference.  We use the callback to be informed when
-  // the VMReference is collected, so we can release the persistent
-  // 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;
-}
-
-
 // TODO(11742): Remove once there are no more users of the Dart_Handle-based
 // VMReferences.
 static Dart_Handle CreateMirrorReference(Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& referent = Object::Handle(isolate, Api::UnwrapHandle(handle));
   const MirrorReference& reference =
        MirrorReference::Handle(MirrorReference::New());
   reference.set_referent(referent);
   return Api::NewHandle(isolate, reference.raw());
@@ skipping 379 matching lines @@
   if (Dart_IsError(constructor_map)) {
     return constructor_map;
   }
   Dart_Handle type_var_map = CreateTypeVariableMap(intf, intf_mirror);
   if (Dart_IsError(type_var_map)) {
     return type_var_map;
   }
 
   Dart_Handle args[] = {
     CreateMirrorReference(intf),
-    CreateVMReference(intf),
     Dart_Null(),  // "name"
     Dart_NewBoolean(Dart_IsClass(intf)),
     lib_mirror,
     CreateLazyMirror(super_class),
     CreateImplementsList(intf),
     CreateLazyMirror(default_class),
     member_map,
     constructor_map,
     type_var_map,
   };
@@ skipping 37 matching lines @@
     Api::False()
   };
   Dart_Handle mirror =
       Dart_New(mirror_type, Dart_Null(), ARRAY_SIZE(args), args);
   return mirror;
 }
 
 
 static Dart_Handle CreateVariableMirror(Dart_Handle var,
                                         Dart_Handle var_name,
-                                        Dart_Handle lib_mirror) {
+                                        Dart_Handle owner_mirror) {
   ASSERT(Dart_IsVariable(var));
   Dart_Handle cls_name = NewString("_LocalVariableMirrorImpl");
   Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
   if (Dart_IsError(type)) {
     return type;
   }
 
   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 var_type = Dart_VariableType(var);
   if (Dart_IsError(var_type)) {
     return var_type;
   }
 
   Dart_Handle args[] = {
+    CreateMirrorReference(var),
     var_name,
-    lib_mirror,
+    owner_mirror,
     CreateLazyMirror(var_type),
     Dart_NewBoolean(is_static),
     Dart_NewBoolean(is_final),
   };
   Dart_Handle mirror = Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
   return mirror;
 }
 
 
 static Dart_Handle AddMemberClasses(Dart_Handle map,
@@ skipping 202 matching lines @@
   Dart_Handle lazy_lib_mirror = CreateLazyMirror(lib);
   if (Dart_IsError(lazy_lib_mirror)) {
     return lazy_lib_mirror;
   }
   Dart_Handle member_map = CreateMemberMap(lib, lazy_lib_mirror);
   if (Dart_IsError(member_map)) {
     return member_map;
   }
   Dart_Handle args[] = {
     CreateMirrorReference(lib),
-    CreateVMReference(lib),
     Dart_LibraryName(lib),
     Dart_LibraryUrl(lib),
     member_map,
   };
   Dart_Handle lib_mirror = Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
   if (Dart_IsError(lib_mirror)) {
     return lib_mirror;
   }
 
   return lib_mirror;
@@ skipping 78 matching lines @@
   Dart_Handle cls_name = NewString("_LocalInstanceMirrorImpl");
   Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
   if (Dart_IsError(type)) {
     return type;
   }
 
   // TODO(turnidge): This is wrong.  The Null class is distinct from object.
   Dart_Handle object_class = Dart_GetClass(CoreLib(), NewString("Object"));
 
   Dart_Handle args[] = {
-    CreateVMReference(Dart_Null()),
     CreateLazyMirror(object_class),
     Dart_Null(),
   };
   Dart_Handle mirror = Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
   return mirror;
 }
 
 
 static Dart_Handle CreateInstanceMirror(Dart_Handle instance) {
   if (Dart_IsNull(instance)) {
@@ skipping 26 matching lines @@
     }
 
     // TODO(turnidge): Pass the function owner here.  This will require
     // us to support functions in CreateLazyMirror.
     Dart_Handle func_mirror =
         CreateMethodMirror(func, Dart_Null());
     if (Dart_IsError(func_mirror)) {
       return func_mirror;
     }
     Dart_Handle args[] = {
-      CreateVMReference(instance),
       CreateLazyMirror(instance_cls),
       instance,
       func_mirror,
     };
     return Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
 
   } else {
     Dart_Handle cls_name = NewString("_LocalInstanceMirrorImpl");
     Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
     if (Dart_IsError(type)) {
       return type;
     }
     Dart_Handle args[] = {
-      CreateVMReference(instance),
       CreateLazyMirror(instance_cls),
       instance,
     };
     return Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
   }
 }
 
 
 void NATIVE_ENTRY_FUNCTION(Mirrors_makeLocalMirrorSystem)(
     Dart_NativeArguments args) {
@@ skipping 50 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();
-}
-
 
+DEFINE_NATIVE_ENTRY(DeclarationMirror_metadata, 1) {
+  const MirrorReference& decl_ref =
+      MirrorReference::CheckedHandle(arguments->NativeArgAt(0));
+  const Object& decl = Object::Handle(decl_ref.referent());
+
+  Class& klass = Class::Handle();
+  if (decl.IsClass()) {
+    klass ^= decl.raw();
+  } else if (decl.IsFunction()) {
+    klass = Function::Cast(decl).origin();
+  } else if (decl.IsField()) {
+    klass = Field::Cast(decl).origin();
+  } else {
+    return Object::empty_array().raw();
+  }
+
+  const Library& library = Library::Handle(klass.library());
+  return library.GetMetadata(decl);
+}
+
+
 void HandleMirrorsMessage(Isolate* isolate,
                           Dart_Port reply_port,
                           const Instance& message) {
   UNIMPLEMENTED();
 }
 
 
 // TODO(11742): This is transitional.
 static RawInstance* Reflect(const Instance& reflectee) {
   Isolate* isolate = Isolate::Current();
@@ skipping 677 matching lines @@
 
 DEFINE_NATIVE_ENTRY(MethodMirror_name, 1) {
   const MirrorReference& func_ref =
       MirrorReference::CheckedHandle(arguments->NativeArgAt(0));
   Function& func = Function::Handle();
   func ^= func_ref.referent();
   return func.UserVisibleName();
 }
 
 }  // namespace dart