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

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2013, 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_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
@@ skipping 2828 matching lines @@
         "%s expects argument 'number_of_arguments' to be non-negative.",
         CURRENT_FUNC);
   }
 
   // Get the class to instantiate.
   result = Api::UnwrapHandle(type);
   if (result.IsNull()) {
     RETURN_TYPE_ERROR(isolate, type, Type);
   }
   Class& cls = Class::Handle(isolate);
+  AbstractTypeArguments& type_arguments =
+      AbstractTypeArguments::Handle(isolate);
+
   if (result.IsType()) {
     cls = Type::Cast(result).type_class();
+    type_arguments = Type::Cast(result).arguments();
   } else if (result.IsClass()) {
     // For backwards compatibility we allow class objects to be passed in
     // for now. This needs to be removed once all code that uses class
     // objects to invoke Dart_New is removed.
     cls ^= result.raw();
+    type_arguments = Type::Handle(cls.BasicType()).arguments();
   } else {
     RETURN_TYPE_ERROR(isolate, type, Type);
   }
 
   String& base_constructor_name = String::Handle();
   base_constructor_name = cls.Name();
 
   // And get the name of the constructor to invoke.
   String& dot_name = String::Handle(isolate);
   result = Api::UnwrapHandle(constructor_name);
@@ skipping 40 matching lines @@
     new_object = Instance::New(cls);
   }
 
   // Create the argument list.
   intptr_t arg_index = 0;
   int extra_args = (constructor.IsConstructor() ? 2 : 1);
   const Array& args =
       Array::Handle(isolate, Array::New(number_of_arguments + extra_args));
   if (constructor.IsConstructor()) {
     // Constructors get the uninitialized object and a constructor phase.
+    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(arg_index++, new_object);
     args.SetAt(arg_index++,
                Smi::Handle(isolate, Smi::New(Function::kCtorPhaseAll)));
   } else {
     // Factories get type arguments.
-    args.SetAt(arg_index++, TypeArguments::Handle(isolate));
+    args.SetAt(arg_index++, type_arguments);
   }
   Object& argument = Object::Handle(isolate);
   for (int i = 0; i < number_of_arguments; i++) {
     argument = Api::UnwrapHandle(arguments[i]);
     if (!argument.IsNull() && !argument.IsInstance()) {
       if (argument.IsError()) {
         return Api::NewHandle(isolate, argument.raw());
       } else {
         return Api::NewError(
             "%s expects arguments[%d] to be an Instance handle.",
@@ skipping 1394 matching lines @@
   }
   {
     NoGCScope no_gc;
     RawObject* raw_obj = obj.raw();
     isolate->heap()->SetPeer(raw_obj, peer);
   }
   return Api::Success();
 }
 
 }  // namespace dart