Ensure class mirrors on non-generic classes always have their runtime type set.

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 "lib/invocation_mirror.h"
 #include "vm/bootstrap_natives.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
 #include "vm/object_store.h"
@@ skipping 282 matching lines @@
       // We represent function types as canonical signature classes.
       return CreateFunctionTypeMirror(cls, type);
     } else {
       // We represent typedefs as non-canonical signature classes.
       return CreateTypedefMirror(cls, owner_mirror);
     }
   }
 
   const Bool& is_generic = Bool::Get(cls.NumTypeParameters() != 0);
 
+  // Non-generics always have their runtime types. Generics may or may not.
+  ASSERT(!(cls.NumTypeParameters() == 0) || !type.IsNull());

[siva, 2013/08/28 23:12:06]

The comment here is very cryptic, you probably should elaborate here
that the assertion is to ensure this function is called with a
non null runtime 'type' parameter for a non generic 'cls' parameter.

+
   const Array& args = Array::Handle(Array::New(4));
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(cls)));
   args.SetAt(1, type);
   args.SetAt(2, String::Handle(cls.UserVisibleName()));
   args.SetAt(3, is_generic);
   return CreateMirror(Symbols::_LocalClassMirrorImpl(), args);
 }
 
 
 static RawInstance* CreateLibraryMirror(const Library& lib) {
@@ skipping 192 matching lines @@
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Class& klass = Class::Handle(ref.GetClassReferent());
   return klass.UserVisibleName();
 }
 
 
 DEFINE_NATIVE_ENTRY(ClassMirror_library, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Class& klass = Class::Handle(ref.GetClassReferent());
   const Library& library = Library::Handle(klass.library());
-  // TODO(rmacnak): Revisit when we decide what to do about
-  // reflectClass(dynamic).
-  if (library.IsNull()) {
-    return Instance::null();
-  }
+  ASSERT(!library.IsNull());
   return CreateLibraryMirror(library);
 }
 
 
 DEFINE_NATIVE_ENTRY(ClassMirror_supertype, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Class& klass = Class::Handle(ref.GetClassReferent());
   return klass.super_type();
 }
 
@@ skipping 95 matching lines @@
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
   const Library& library = Library::Handle(ref.GetLibraryReferent());
 
   Instance& member_mirror = Instance::Handle();
   const GrowableObjectArray& member_mirrors =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
 
   Object& entry = Object::Handle();
   DictionaryIterator entries(library);
 
+  AbstractType& type = AbstractType::Handle();
+
   while (entries.HasNext()) {
     entry = entries.GetNext();
     if (entry.IsClass()) {
       const Class& klass = Class::Cast(entry);
       // We filter out implementation classes like Smi, Mint, Bignum,
       // OneByteString; function signature classes; and dynamic.
       if (!klass.IsCanonicalSignatureClass() &&
           !klass.IsDynamicClass() &&
           !RawObject::IsImplementationClassId(klass.id())) {
-        member_mirror = CreateClassMirror(klass,
-                                          AbstractType::Handle(),
-                                          owner_mirror);
+        if (klass.NumTypeParameters() == 0) {
+          // Include runtime type for non-generics only.
+          type = RawTypeOfClass(klass);
+        } else {
+          type = AbstractType::null();
+        }
+        member_mirror = CreateClassMirror(klass, type, owner_mirror);
         member_mirrors.Add(member_mirror);
       }
     } else if (entry.IsField()) {
       const Field& field = Field::Cast(entry);
       member_mirror = CreateVariableMirror(field, owner_mirror);
       member_mirrors.Add(member_mirror);
     } else if (entry.IsFunction()) {
       const Function& func = Function::Cast(entry);
       if (func.kind() == RawFunction::kRegularFunction ||
           func.kind() == RawFunction::kGetterFunction ||
@@ skipping 49 matching lines @@
     arg_type ^= args.TypeAt(i + num_inherited_args);
     type_mirror = CreateTypeMirror(arg_type);
     result.SetAt(i, type_mirror);
   }
   return result.raw();
 }
 
 
 DEFINE_NATIVE_ENTRY(TypeVariableMirror_owner, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(TypeParameter, param, arguments->NativeArgAt(0));
-  return CreateClassMirror(Class::Handle(param.parameterized_class()),
+  const Class& owner = Class::Handle(param.parameterized_class());
+  // The owner of a type variable must be a generic class: pass a null runtime
+  // type to get a mirror on the declaration.
+  ASSERT(owner.NumTypeParameters() != 0);
+  return CreateClassMirror(owner,
                            AbstractType::Handle(),
                            Instance::null_instance());
 }
 
 
 DEFINE_NATIVE_ENTRY(TypeVariableMirror_upper_bound, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(TypeParameter, param, arguments->NativeArgAt(0));
   return param.bound();
 }
 
@@ skipping 544 matching lines @@
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Function& func = Function::Handle(ref.GetFunctionReferent());
   if (func.IsNonImplicitClosureFunction()) {
     return CreateMethodMirror(Function::Handle(
         func.parent_function()), Object::null_instance());
   }
   const Class& owner = Class::Handle(func.Owner());
   if (owner.IsTopLevel()) {
     return CreateLibraryMirror(Library::Handle(owner.library()));
   }
-  return CreateClassMirror(owner,
-                           AbstractType::Handle(),
-                           Object::null_instance());
+
+  AbstractType& type = AbstractType::Handle();
+  if (owner.NumTypeParameters() == 0) {
+    // Include runtime type for non-generics only.
+    type = RawTypeOfClass(owner);
+  }
+  return CreateClassMirror(owner, type, Object::null_instance());
 }
 
 
 DEFINE_NATIVE_ENTRY(MethodMirror_parameters, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, owner, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(1));
   const Function& func = Function::Handle(ref.GetFunctionReferent());
   return CreateParameterMirrorList(func, owner);
 }
 
@@ skipping 53 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());
   return field.type();
 }
 
 }  // namespace dart