Fill in type arguments when creating an object from the mirrors or embedding API.

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 11 matching lines @@
   const Object& result = Object::Handle(
       DartLibraryCalls::InstanceCreate(mirrors_lib,
                                        mirror_class_name,
                                        constructor_name,
                                        constructor_arguments));
   ASSERT(!result.IsError());
   return Instance::Cast(result).raw();
 }
 
 
-// Note a "raw type" is not the same as a RawType.
-static RawAbstractType* RawTypeOfClass(const Class& cls) {
-  Type& type = Type::Handle(Type::New(cls,
-                                      Object::null_abstract_type_arguments(),
-                                      Scanner::kDummyTokenIndex));
-  return ClassFinalizer::FinalizeType(cls, type, ClassFinalizer::kCanonicalize);
-}
-
-
 static void ThrowMirroredCompilationError(const String& message) {
   Array& args = Array::Handle(Array::New(1));
   args.SetAt(0, message);
 
   Exceptions::ThrowByType(Exceptions::kMirroredCompilationError, args);
   UNREACHABLE();
 }
 
 
 static void ThrowInvokeError(const Error& error) {
@@ skipping 236 matching lines @@
     if (!call_function.IsNull()) {
       return call_function.raw();
     }
     lookup_cls = lookup_cls.SuperClass();
   } while (!lookup_cls.IsNull());
   return Function::null();
 }
 
 static RawInstance* CreateClassMirror(const Class& cls,
                                       const AbstractType& type,
+                                      const Bool& is_declaration,
                                       const Instance& owner_mirror) {
   ASSERT(!cls.IsDynamicClass() && !cls.IsVoidClass());
 
   if (cls.IsSignatureClass()) {
     if (cls.IsCanonicalSignatureClass()) {
       // 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);
     }
   }
 
+  ASSERT(!type.IsNull());
+
   const Bool& is_generic = Bool::Get(cls.NumTypeParameters() != 0);
   const Bool& is_mixin_typedef = Bool::Get(cls.is_mixin_typedef());
 
-  // If the class is not generic, the mirror must have a non-null runtime type.
-  // If the class is generic, the mirror will have a null runtime type if it
-  // represents the declaration or a non-null runtime type if it represents an
-  // instantiation.
-  ASSERT(!(cls.NumTypeParameters() == 0) || !type.IsNull());
-
-  const Array& args = Array::Handle(Array::New(5));
+  const Array& args = Array::Handle(Array::New(6));
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(cls)));
   args.SetAt(1, type);
   // We do not set the names of anonymous mixin applications because the mirrors
   // use a different naming convention than the VM (lib.S with lib.M and S&M
   // respectively).
   if (!cls.IsMixinApplication() || cls.is_mixin_typedef()) {
     args.SetAt(2, String::Handle(cls.UserVisibleName()));
   }
   args.SetAt(3, is_generic);
   args.SetAt(4, is_mixin_typedef);
+  args.SetAt(5, cls.NumTypeParameters() == 0 ? Bool::False() : is_declaration);
   return CreateMirror(Symbols::_LocalClassMirrorImpl(), args);
 }
 
 
 static RawInstance* CreateLibraryMirror(const Library& lib) {
   const Array& args = Array::Handle(Array::New(3));
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(lib)));
   String& str = String::Handle();
   str = lib.name();
   args.SetAt(1, str);
@@ skipping 12 matching lines @@
       Array& args = Array::Handle(Array::New(1));
       args.SetAt(0, Symbols::Void());
       // TODO(mlippautz): Create once in the VM isolate and retrieve from there.
       return CreateMirror(Symbols::_SpecialTypeMirrorImpl(), args);
     } else if (cls.IsDynamicClass()) {
       Array& args = Array::Handle(Array::New(1));
       args.SetAt(0, Symbols::Dynamic());
       // TODO(mlippautz): Create once in the VM isolate and retrieve from there.
       return CreateMirror(Symbols::_SpecialTypeMirrorImpl(), args);
     }
-    return CreateClassMirror(cls, type, Object::null_instance());
+    return CreateClassMirror(cls, type, Bool::False(), Object::null_instance());
   } else if (type.IsTypeParameter()) {
     return CreateTypeVariableMirror(TypeParameter::Cast(type),
                                     Object::null_instance());
   }
   UNREACHABLE();
   return Instance::null();
 }
 
 
 static RawInstance* CreateIsolateMirror() {
@@ skipping 44 matching lines @@
 DEFINE_NATIVE_ENTRY(Mirrors_makeLocalClassMirror, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(Type, type, arguments->NativeArgAt(0));
   const Class& cls = Class::Handle(type.type_class());
   ASSERT(!cls.IsNull());
   if (cls.IsDynamicClass() || cls.IsVoidClass()) {
     const Array& args = Array::Handle(Array::New(1));
     args.SetAt(0, type);
     Exceptions::ThrowByType(Exceptions::kArgument, args);
     UNREACHABLE();
   }
-  // Strip the type for generics only.
-  if (cls.NumTypeParameters() == 0) {
-    return CreateClassMirror(cls,
-                             type,
-                             Object::null_instance());
-  } else {
-    return CreateClassMirror(cls,
-                             AbstractType::Handle(),
-                             Object::null_instance());
-  }
+  const Type& stripped_type = Type::Handle(cls.RareType());
+  return CreateClassMirror(cls,
+                           stripped_type,
+                           Bool::True(),  // is_declaration
+                           Object::null_instance());
 }
 
 
 DEFINE_NATIVE_ENTRY(Mirrors_makeLocalTypeMirror, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, type, arguments->NativeArgAt(0));
   return CreateTypeMirror(type);
 }
 
 
 DEFINE_NATIVE_ENTRY(MirrorReference_equals, 2) {
@@ skipping 207 matching lines @@
 
   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())) {
-        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);
+        type = klass.RareType();
+        member_mirror = CreateClassMirror(klass,
+                                          type,
+                                          Bool::True(),  // is_declaration
+                                          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 50 matching lines @@
     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));
   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);
+  const Type& type = Type::Handle(owner.RareType());
   return CreateClassMirror(owner,
-                           AbstractType::Handle(),
+                           type,
+                           Bool::True(),  // is_declaration
                            Instance::null_instance());
 }
 
 
 DEFINE_NATIVE_ENTRY(TypeVariableMirror_upper_bound, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(TypeParameter, param, arguments->NativeArgAt(0));
   return param.bound();
 }
 
 
@@ skipping 204 matching lines @@
       Array::Handle(ArgumentsDescriptor::New(args.Length(), arg_names));
 
   const Function& function = Function::Handle(
       klass.LookupStaticFunctionAllowPrivate(function_name));
 
 
   ArgumentsDescriptor args_descriptor(args_descriptor_array);
   if (function.IsNull() ||
       !function.AreValidArguments(args_descriptor, NULL) ||
       !function.is_visible()) {
-    ThrowNoSuchMethod(AbstractType::Handle(RawTypeOfClass(klass)),
+    ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()),
                       function_name,
                       function,
                       InvocationMirror::kStatic,
                       InvocationMirror::kMethod);
     UNREACHABLE();
   }
 
   Object& result = Object::Handle(
       DartEntry::InvokeFunction(function, args, args_descriptor_array));
   if (result.IsError()) {
@@ skipping 14 matching lines @@
 
   // Note static fields do not have implicit getters.
   const Field& field = Field::Handle(klass.LookupStaticField(getter_name));
   if (field.IsNull() || FieldIsUninitialized(field)) {
     const String& internal_getter_name = String::Handle(
         Field::GetterName(getter_name));
     const Function& getter = Function::Handle(
         klass.LookupStaticFunctionAllowPrivate(internal_getter_name));
 
     if (getter.IsNull() || !getter.is_visible()) {
-      ThrowNoSuchMethod(AbstractType::Handle(RawTypeOfClass(klass)),
+      ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()),
                         getter_name,
                         getter,
                         InvocationMirror::kStatic,
                         InvocationMirror::kGetter);
       UNREACHABLE();
     }
 
     // Invoke the getter and return the result.
     Object& result = Object::Handle(
         DartEntry::InvokeFunction(getter, Object::empty_array()));
@@ skipping 18 matching lines @@
 
   // Check for real fields and user-defined setters.
   const Field& field = Field::Handle(klass.LookupStaticField(setter_name));
   if (field.IsNull()) {
     const String& internal_setter_name = String::Handle(
       Field::SetterName(setter_name));
     const Function& setter = Function::Handle(
       klass.LookupStaticFunctionAllowPrivate(internal_setter_name));
 
     if (setter.IsNull() || !setter.is_visible()) {
-      ThrowNoSuchMethod(AbstractType::Handle(RawTypeOfClass(klass)),
+      ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()),
                         setter_name,
                         setter,
                         InvocationMirror::kStatic,
                         InvocationMirror::kSetter);
       UNREACHABLE();
     }
 
     // Invoke the setter and return the result.
     const int kNumArgs = 1;
     const Array& args = Array::Handle(Array::New(kNumArgs));
@@ skipping 15 matching lines @@
                              setter_name.ToCString()));
     ThrowMirroredCompilationError(message);
     UNREACHABLE();
   }
 
   field.set_value(value);
   return value.raw();
 }
 
 
-DEFINE_NATIVE_ENTRY(ClassMirror_invokeConstructor, 4) {
+DEFINE_NATIVE_ENTRY(ClassMirror_invokeConstructor, 5) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Class& klass = Class::Handle(ref.GetClassReferent());
+  GET_NATIVE_ARGUMENT(Type, type, arguments->NativeArgAt(1));
   GET_NON_NULL_NATIVE_ARGUMENT(
-      String, constructor_name, arguments->NativeArgAt(1));
-  GET_NON_NULL_NATIVE_ARGUMENT(Array, explicit_args, arguments->NativeArgAt(2));
-  GET_NON_NULL_NATIVE_ARGUMENT(Array, arg_names, arguments->NativeArgAt(3));
+      String, constructor_name, arguments->NativeArgAt(2));
+  GET_NON_NULL_NATIVE_ARGUMENT(Array, explicit_args, arguments->NativeArgAt(3));
+  GET_NON_NULL_NATIVE_ARGUMENT(Array, arg_names, arguments->NativeArgAt(4));
 
   // By convention, the static function implementing a named constructor 'C'
   // for class 'A' is labeled 'A.C', and the static function implementing the
   // unnamed constructor for class 'A' is labeled 'A.'.
   // This convention prevents users from explicitly calling constructors.
   const String& klass_name = String::Handle(klass.Name());
   String& internal_constructor_name =
       String::Handle(String::Concat(klass_name, Symbols::Dot()));
   if (!constructor_name.IsNull()) {
     internal_constructor_name =
         String::Concat(internal_constructor_name, constructor_name);
   }
 
   Function& lookup_constructor = Function::Handle(
       klass.LookupFunctionAllowPrivate(internal_constructor_name));
 
   if (lookup_constructor.IsNull() ||
       !(lookup_constructor.IsConstructor() || lookup_constructor.IsFactory()) ||
       !lookup_constructor.is_visible()) {
     // Pretend we didn't find the constructor at all when the arity is wrong
     // so as to produce the same NoSuchMethodError as the non-reflective case.
     lookup_constructor = Function::null();
-    ThrowNoSuchMethod(AbstractType::Handle(RawTypeOfClass(klass)),
+    ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()),
                       internal_constructor_name,
                       lookup_constructor,
                       InvocationMirror::kConstructor,
                       InvocationMirror::kMethod);
     UNREACHABLE();
   }
 
   Class& redirected_klass = Class::Handle(klass.raw());
   Function& redirected_constructor = Function::Handle(lookup_constructor.raw());
   if (lookup_constructor.IsRedirectingFactory()) {
@@ skipping 20 matching lines @@
   const Array& args_descriptor_array =
       Array::Handle(ArgumentsDescriptor::New(args.Length(),
                                              arg_names));
 
   ArgumentsDescriptor args_descriptor(args_descriptor_array);
   if (!redirected_constructor.AreValidArguments(args_descriptor, NULL) ||
       !redirected_constructor.is_visible()) {
     // Pretend we didn't find the constructor at all when the arity is wrong
     // so as to produce the same NoSuchMethodError as the non-reflective case.
     redirected_constructor = Function::null();
-    ThrowNoSuchMethod(AbstractType::Handle(RawTypeOfClass(klass)),
+    ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()),
                       internal_constructor_name,
                       redirected_constructor,
                       InvocationMirror::kConstructor,
                       InvocationMirror::kMethod);
     UNREACHABLE();
   }
 
+  ASSERT(!type.IsNull());
+  const AbstractTypeArguments& type_arguments =
+      AbstractTypeArguments::Handle(type.arguments());
+
   Instance& new_object = Instance::Handle();
   if (redirected_constructor.IsConstructor()) {
     // Constructors get the uninitialized object and a constructor phase. Note
     // we have delayed allocation until after the function type and argument
     // matching checks.
     new_object = Instance::New(redirected_klass);
+    if (!type_arguments.IsNull()) {
+      // The type arguments will be null if the class has no type parameters, in
+      // which case the following call would fail because there is no slot
+      // reserved in the object for the type vector.
+      new_object.SetTypeArguments(type_arguments);
+    }
     args.SetAt(0, new_object);
     args.SetAt(1, Smi::Handle(Smi::New(Function::kCtorPhaseAll)));
   } else {
     // Factories get type arguments.
-    // TODO(12921): Should we allow the user to specify type arguments? Use type
-    // arguments from the mirror?
-    args.SetAt(0, Object::null_abstract_type_arguments());
+    args.SetAt(0, type_arguments);
   }
 
   // Invoke the constructor and return the new object.
   const Object& result =
       Object::Handle(DartEntry::InvokeFunction(redirected_constructor,
                                                args,
                                                args_descriptor_array));
   if (result.IsError()) {
     return result.raw();
   }
@@ skipping 159 matching lines @@
   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()));
   }
 
-  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());
+  Type& type = Type::Handle(owner.RareType());
+  return CreateClassMirror(owner, type, Bool::True(), 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