Implement ClassMirror.superclass with internal code for ordinary (but not function type) classes. R…

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 493 matching lines @@
     // reflection.
     return CreateTypedefMirror(intf, intf_name, lib_mirror);
   }
 
   Dart_Handle cls_name = NewString("_LocalClassMirrorImpl");
   Dart_Handle type = Dart_GetType(MirrorLib(), cls_name, 0, NULL);
   if (Dart_IsError(type)) {
     return type;
   }
 
-  // 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"));
-  }
+  Dart_Handle super_class = Dart_Null();
   // 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;
   }
   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),
     Dart_Null(),  // "name"
     Dart_NewBoolean(Dart_IsClass(intf)),
     lib_mirror,
-    CreateLazyMirror(super_class),
+    super_class,
     CreateImplementsList(intf),
     CreateLazyMirror(default_class),
     constructor_map,
     type_var_map,
   };
   Dart_Handle mirror = Dart_New(type, Dart_Null(), ARRAY_SIZE(args), args);
   return mirror;
 }
 
 
@@ skipping 498 matching lines @@
 }
 
 
 DEFINE_NATIVE_ENTRY(ClassMirror_library, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Class& klass = Class::Handle(ref.GetClassReferent());
   return CreateLibraryMirror(Library::Handle(klass.library()));
 }
 
 
+DEFINE_NATIVE_ENTRY(ClassMirror_supertype, 1) {

[rmacnak, 2013/07/25 20:51:51]

We answer a Type instead of a ClassMirror for two reasons:

1) We can hit the cache on reflectClass()

2) We will eventually need to change the reflectee of a ClassMirror from a
RawClass to a RawAbstractType, because a RawClass doesn't have the type
arguments we will need to implement ClassMirror.typeArguments.

+  GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
+  const Class& klass = Class::Handle(ref.GetClassReferent());
+  return klass.super_type();
+}
+
 DEFINE_NATIVE_ENTRY(ClassMirror_members, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(Instance,
                                owner_mirror,
                                arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
   const Class& klass = Class::Handle(ref.GetClassReferent());
 
   const Array& fields = Array::Handle(klass.fields());
   // Some special types like 'dynamic' have a null fields list, but they should
   // not wind up as the reflectees of ClassMirrors.
@@ skipping 700 matching lines @@
 
 DEFINE_NATIVE_ENTRY(VariableMirror_type, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Field& field = Field::Handle(ref.GetFieldReferent());
 
   const AbstractType& type = AbstractType::Handle(field.type());
   return CreateTypeMirror(type);
 }
 
 }  // namespace dart