Pass a second type argument vector to all type instantiation calls in the VM.

runtime/vm/parser.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 "vm/parser.h"
 #include "vm/flags.h"
 
 #ifndef DART_PRECOMPILED_RUNTIME
 
 #include "lib/invocation_mirror.h"
@@ skipping 13466 matching lines @@
         TypeArguments::Handle(Z, list_type_arguments.Canonicalize()));
     Error& bound_error = Error::Handle(Z);
     for (int i = 0; i < element_list.length(); i++) {
       AstNode* elem = element_list[i];
       // Arguments have been evaluated to a literal value already.
       ASSERT(elem->IsLiteralNode());
       ASSERT(!is_top_level_);  // We cannot check unresolved types.
       if (I->type_checks() && !element_type.IsDynamicType() &&
           (!elem->AsLiteralNode()->literal().IsNull() &&
            !elem->AsLiteralNode()->literal().IsInstanceOf(
-               element_type, Object::null_type_arguments(), &bound_error))) {
+               element_type, Object::null_type_arguments(),
+               Object::null_type_arguments(), &bound_error))) {
         // If the failure is due to a bound error, display it instead.
         if (!bound_error.IsNull()) {
           ReportError(bound_error);
         } else {
           ReportError(
               elem->AsLiteralNode()->token_pos(),
               "list literal element at index %d must be "
               "a constant of type '%s'",
               i, String::Handle(Z, element_type.UserVisibleName()).ToCString());
         }
@@ skipping 203 matching lines @@
         if ((i % 2) == 0) {
           // Check key type.
           arg_type = key_type.raw();
         } else {
           // Check value type.
           arg_type = value_type.raw();
         }
         if (!arg_type.IsDynamicType() &&
             (!arg->AsLiteralNode()->literal().IsNull() &&
              !arg->AsLiteralNode()->literal().IsInstanceOf(
-                 arg_type, Object::null_type_arguments(), &bound_error))) {
+                 arg_type, Object::null_type_arguments(),
+                 Object::null_type_arguments(), &bound_error))) {
           // If the failure is due to a bound error, display it.
           if (!bound_error.IsNull()) {
             ReportError(bound_error);
           } else {
             ReportError(
                 arg->AsLiteralNode()->token_pos(),
                 "map literal %s at index %d must be "
                 "a constant of type '%s'",
                 ((i % 2) == 0) ? "key" : "value", i >> 1,
                 String::Handle(Z, arg_type.UserVisibleName()).ToCString());
@@ skipping 259 matching lines @@
       BuildConstructorName(T, type_class_name, named_constructor);
   *constructor = type_class.LookupConstructor(constructor_name);
   if (constructor->IsNull()) {
     *constructor = type_class.LookupFactory(constructor_name);
     ASSERT(!constructor->IsNull());
     if (constructor->IsRedirectingFactory()) {
       ClassFinalizer::ResolveRedirectingFactory(type_class, *constructor);
       type = constructor->RedirectionType();
       ASSERT(!type.IsMalformedOrMalbounded());
       if (!type.IsInstantiated()) {
+        ASSERT(type.IsInstantiated(kFunctions));  // No generic constructors.
         Error& error = Error::Handle(Z);
-        type ^= type.InstantiateFrom(*type_arguments, &error,
+        type ^= type.InstantiateFrom(*type_arguments,
+                                     Object::null_type_arguments(), &error,
                                      NULL,  // instantiation_trail
                                      NULL,  // bound_trail
                                      Heap::kOld);
         ASSERT(error.IsNull());
       }
       *type_arguments = type.arguments();
       *constructor = constructor->RedirectionTarget();
     }
   }
 }
@@ skipping 142 matching lines @@
       }
       return ThrowNoSuchMethodError(
           call_pos, type_class, external_constructor_name, arguments,
           InvocationMirror::kConstructor, InvocationMirror::kMethod,
           NULL);  // No existing function.
     } else if (constructor.IsRedirectingFactory()) {
       ClassFinalizer::ResolveRedirectingFactory(type_class, constructor);
       Type& redirect_type = Type::ZoneHandle(Z, constructor.RedirectionType());
       if (!redirect_type.IsMalformedOrMalbounded() &&
           !redirect_type.IsInstantiated()) {
+        // No generic constructors allowed.
+        ASSERT(redirect_type.IsInstantiated(kFunctions));
         // The type arguments of the redirection type are instantiated from the
         // type arguments of the parsed type of the 'new' or 'const' expression.
         Error& error = Error::Handle(Z);
-        redirect_type ^=
-            redirect_type.InstantiateFrom(type_arguments, &error,
-                                          NULL,  // instantiation_trail
-                                          NULL,  // bound_trail
-                                          Heap::kOld);
+        redirect_type ^= redirect_type.InstantiateFrom(
+            type_arguments, Object::null_type_arguments(), &error,
+            NULL,  // instantiation_trail
+            NULL,  // bound_trail
+            Heap::kOld);
         if (!error.IsNull()) {
           redirect_type = ClassFinalizer::NewFinalizedMalformedType(
               error, script_, call_pos,
               "redirecting factory type '%s' cannot be instantiated",
               String::Handle(Z, redirect_type.UserVisibleName()).ToCString());
         }
       }
       if (!redirect_type.HasResolvedTypeClass()) {
         // If the redirection type is unresolved, we convert the allocation
         // into throwing a type error.
@@ skipping 142 matching lines @@
       }
       const_instance ^= constructor_result.raw();
       CacheConstantValue(new_pos, const_instance);
     }
     new_object = new (Z) LiteralNode(new_pos, const_instance);
     if (!type_bound.IsNull()) {
       ASSERT(!type_bound.IsMalformed());
       Error& bound_error = Error::Handle(Z);
       ASSERT(!is_top_level_);  // We cannot check unresolved types.
       if (!const_instance.IsInstanceOf(
-              type_bound, Object::null_type_arguments(), &bound_error)) {
+              type_bound, Object::null_type_arguments(),
+              Object::null_type_arguments(), &bound_error)) {
         type_bound = ClassFinalizer::NewFinalizedMalformedType(
             bound_error, script_, new_pos,
             "const factory result is not an instance of '%s'",
             String::Handle(Z, type_bound.UserVisibleName()).ToCString());
         new_object = ThrowTypeError(new_pos, type_bound);
       }
       type_bound = AbstractType::null();
     }
   } else {
     CheckConstructorCallTypeArguments(new_pos, constructor, type_arguments);
@@ skipping 871 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME