Add a MirrorReference reflectee for ClassMirrors. Rewrite the name accessor in terms of it, at leas…

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"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
 #include "vm/message.h"
 #include "vm/port.h"
 #include "vm/resolver.h"
 
 namespace dart {
 
 inline Dart_Handle NewString(const char* str) {
@@ skipping 134 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;
 }
 
+
+// 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());
+}
+
+
 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 =
@@ skipping 417 matching lines @@
   Dart_Handle constructor_map = CreateConstructorMap(intf, intf_mirror);
   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),
-    intf_name,
+    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,
   };
   Dart_Handle mirror = Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
@@ skipping 779 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();
 }
 
+
+DEFINE_NATIVE_ENTRY(ClassMirror_name, 1) {
+  const MirrorReference& klass_ref =
+      MirrorReference::CheckedHandle(arguments->NativeArgAt(0));
+  Class& klass = Class::Handle();
+  klass ^= klass_ref.referent();
+  return klass.Name();
+}
+
 }  // namespace dart