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

runtime/vm/class_finalizer.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 "vm/class_finalizer.h"
 
 #include "vm/code_generator.h"
 #include "vm/flags.h"
 #include "vm/hash_table.h"
 #include "vm/heap.h"
@@ skipping 442 matching lines @@
   // of the redirection chain.
   ResolveRedirectingFactoryTarget(target_class, target, visited_factories);
   Type& target_type = Type::Handle(target.RedirectionType());
   Function& target_target = Function::Handle(target.RedirectionTarget());
   if (target_target.IsNull()) {
     ASSERT(target_type.IsMalformed());
   } else {
     // If the target type refers to type parameters, substitute them with the
     // type arguments of the redirection type.
     if (!target_type.IsInstantiated()) {
+      // We do not support generic constructors.
+      ASSERT(target_type.IsInstantiated(kFunctions));
       const TypeArguments& type_args = TypeArguments::Handle(type.arguments());
       Error& bound_error = Error::Handle();
-      target_type ^= target_type.InstantiateFrom(type_args, &bound_error, NULL,
-                                                 NULL, Heap::kOld);
+      target_type ^=
+          target_type.InstantiateFrom(type_args, Object::null_type_arguments(),
+                                      &bound_error, NULL, NULL, Heap::kOld);
       if (bound_error.IsNull()) {
         target_type ^= FinalizeType(cls, target_type);
       } else {
         ASSERT(target_type.IsInstantiated() && type_args.IsInstantiated());
         const Script& script = Script::Handle(target_class.script());
         FinalizeMalformedType(bound_error, script, target_type,
                               "cannot resolve redirecting factory");
         target_target = Function::null();
       }
     }
@@ skipping 457 matching lines @@
           // While finalizing D<T>, the super type arg D<T> (a typeref) gets
           // instantiated from vector [T], yielding itself.
           //
           if (super_type_arg.IsTypeRef() && super_type_arg.IsBeingFinalized() &&
               (super_type_arg.arguments() == arguments.raw())) {
             arguments.SetTypeAt(i, super_type_arg);
             continue;
           }
           Error& error = Error::Handle();
           super_type_arg = super_type_arg.InstantiateFrom(
-              arguments, &error, instantiation_trail, NULL, Heap::kOld);
+              arguments, Object::null_type_arguments(), &error,
+              instantiation_trail, NULL, Heap::kOld);
           if (!error.IsNull()) {
             // InstantiateFrom does not report an error if the type is still
             // uninstantiated. Instead, it will return a new BoundedType so
             // that the check is postponed to run time.
             ASSERT(super_type_arg.IsInstantiated());
             // Keep only the first bound error.
             if (bound_error->IsNull()) {
               *bound_error = error.raw();
             }
           }
@@ skipping 76 matching lines @@
         type_param.set_bound(declared_bound);
       }
       ASSERT(declared_bound.IsFinalized() || declared_bound.IsBeingFinalized());
       Error& error = Error::Handle();
       // Note that the bound may be malformed, in which case the bound check
       // will return an error and the bound check will be postponed to run time.
       if (declared_bound.IsInstantiated()) {
         instantiated_bound = declared_bound.raw();
       } else {
         instantiated_bound = declared_bound.InstantiateFrom(
-            arguments, &error, NULL, NULL, Heap::kOld);
+            arguments, Object::null_type_arguments(), &error, NULL, NULL,
+            Heap::kOld);
       }
       if (!instantiated_bound.IsFinalized()) {
         // The bound refers to type parameters, creating a cycle; postpone
         // bound check to run time, when the bound will be finalized.
         // The bound may not necessarily be 'IsBeingFinalized' yet, as is the
         // case with a pair of type parameters of the same class referring to
         // each other via their bounds.
         type_arg = BoundedType::New(type_arg, instantiated_bound, type_param);
         arguments.SetTypeAt(offset + i, type_arg);
         continue;
@@ skipping 195 matching lines @@
     const Type& fun_type = Type::Cast(type);
     const Class& scope_class = Class::Handle(zone, fun_type.type_class());
     if (scope_class.IsTypedefClass()) {
       Function& signature =
           Function::Handle(zone, scope_class.signature_function());
       if (!scope_class.is_type_finalized()) {
         FinalizeSignature(scope_class, signature);
       }
       // If the function type is a generic typedef, instantiate its signature
       // from its type arguments.
-      // Example: typedef T F<T>(T x) has uninstantiated signature (T x) => T.
-      // The instantiated signature of F(int) becomes (int x) => int.
+      // Example: typedef F<T> = S Function<S>(T x) has uninstantiated
+      // signature (T x) => S.
+      // The instantiated signature of F(int) becomes (int x) => S.
       // Note that after this step, the signature of the function type is not
       // identical to the canonical signature of the typedef class anymore.
       if (scope_class.IsGeneric() && !signature.HasInstantiatedSignature()) {
-        const TypeArguments& type_args =
-            TypeArguments::Handle(zone, fun_type.arguments());
         if (FLAG_trace_type_finalization) {
           THR_Print("Instantiating signature '%s' of typedef '%s'\n",
                     String::Handle(zone, signature.Signature()).ToCString(),
                     String::Handle(zone, fun_type.Name()).ToCString());
         }
-        signature = signature.InstantiateSignatureFrom(type_args, Heap::kOld);
-        // Note that if type_args contains type parameters, signature is still
-        // uninstantiated here (typedef type parameters were substituted in the
-        // signature with typedef type arguments).
+        const TypeArguments& instantiator_type_arguments =
+            TypeArguments::Handle(zone, fun_type.arguments());
+        const TypeArguments& function_type_arguments =
+            TypeArguments::Handle(zone, signature.type_parameters());
+        signature = signature.InstantiateSignatureFrom(
+            instantiator_type_arguments, function_type_arguments, Heap::kOld);
+        // Note that if instantiator_type_arguments contains type parameters,
+        // as in F<K>, the signature is still uninstantiated (the typedef type
+        // parameters were substituted in the signature with typedef type
+        // arguments). Note also that the function type parameters were not
+        // modified.
       }
       fun_type.set_signature(signature);
       // The type was already marked as finalized and uninstantiated in
       // ExpandAndFinalizeTypeArguments above when its signature was not
       // instantiated yet. Check again by calling ResetIsFinalized().
       fun_type.ResetIsFinalized();
     } else {
       const Function& signature = Function::Handle(zone, fun_type.signature());
       FinalizeSignature(cls, signature);
     }
@@ skipping 265 matching lines @@
       Error& error = Error::Handle(zone);
       if (type.IsMalformedOrMalbounded()) {
         error = type.error();
       } else {
         ASSERT(type.IsInstantiated());
       }
       const Instance& const_value = Instance::Handle(zone, field.StaticValue());
       if (!error.IsNull() ||
           (!type.IsDynamicType() &&
            !const_value.IsInstanceOf(type, Object::null_type_arguments(),
-                                     &error))) {
+                                     Object::null_type_arguments(), &error))) {
         if (Isolate::Current()->error_on_bad_type()) {
           const AbstractType& const_value_type =
               AbstractType::Handle(zone, const_value.GetType(Heap::kNew));
           const String& const_value_type_name =
               String::Handle(zone, const_value_type.UserVisibleName());
           const String& type_name =
               String::Handle(zone, type.UserVisibleName());
           ReportErrors(error, cls, field.token_pos(),
                        "error initializing static %s field '%s': "
                        "type '%s' is not a subtype of type '%s'",
@@ skipping 306 matching lines @@
         for (intptr_t i = 0; i < num_mixin_type_params; i++) {
           param ^= mixin_type_args.TypeAt(i);
           param_bound = param.bound();
           if (!param_bound.IsInstantiated()) {
             // Make sure the bound is finalized before instantiating it.
             if (!param_bound.IsFinalized() && !param_bound.IsBeingFinalized()) {
               param_bound = FinalizeType(mixin_app_class, param_bound);
               param.set_bound(param_bound);  // In case part of recursive type.
             }
             param_bound = param_bound.InstantiateFrom(
-                instantiator, &bound_error, NULL, NULL, Heap::kOld);
+                instantiator, Object::null_type_arguments(), &bound_error, NULL,
+                NULL, Heap::kOld);
             // The instantiator contains only TypeParameter objects and no
             // BoundedType objects, so no bound error may occur.
             ASSERT(!param_bound.IsBoundedType());
             ASSERT(bound_error.IsNull());
             ASSERT(!param_bound.IsInstantiated());
             param.set_bound(param_bound);
           }
         }
       }
 
@@ skipping 214 matching lines @@
         mixin_class_super_type_args.Length() - num_aliased_mixin_type_params;
     for (intptr_t i = 0; i < num_aliased_mixin_type_params; i++) {
       type = mixin_class_super_type_args.TypeAt(offset + i);
       if (!type.IsInstantiated()) {
         // In the presence of bounds, the bounded type and the upper bound must
         // be instantiated separately. Instantiating a BoundedType would wrap
         // the BoundedType in another BoundedType.
         if (type.IsBoundedType()) {
           bounded_type = BoundedType::Cast(type).type();
           bounded_type = bounded_type.InstantiateFrom(
-              instantiator, &bound_error, NULL, NULL, Heap::kOld);
+              instantiator, Object::null_type_arguments(), &bound_error, NULL,
+              NULL, Heap::kOld);
           // The instantiator contains only TypeParameter objects and no
           // BoundedType objects, so no bound error may occur.
           ASSERT(bound_error.IsNull());
           upper_bound = BoundedType::Cast(type).bound();
-          upper_bound = upper_bound.InstantiateFrom(instantiator, &bound_error,
-                                                    NULL, NULL, Heap::kOld);
+          upper_bound = upper_bound.InstantiateFrom(
+              instantiator, Object::null_type_arguments(), &bound_error, NULL,
+              NULL, Heap::kOld);
           ASSERT(bound_error.IsNull());
           type_parameter = BoundedType::Cast(type).type_parameter();
           // The type parameter that declared the bound does not change.
           type = BoundedType::New(bounded_type, upper_bound, type_parameter);
         } else {
-          type = type.InstantiateFrom(instantiator, &bound_error, NULL, NULL,
-                                      Heap::kOld);
+          type =
+              type.InstantiateFrom(instantiator, Object::null_type_arguments(),
+                                   &bound_error, NULL, NULL, Heap::kOld);
           ASSERT(bound_error.IsNull());
         }
       }
       new_mixin_type_args.SetTypeAt(i, type);
     }
   }
   TypeArguments& new_super_type_args = TypeArguments::Handle(zone);
   if ((num_super_type_params + num_aliased_mixin_type_params) > 0) {
     new_super_type_args = TypeArguments::New(num_super_type_params +
                                              num_aliased_mixin_type_params);
@@ skipping 1609 matching lines @@
   ProgramVisitor::VisitFunctions(&function_visitor);
 
   class ClearCodeClassVisitor : public ClassVisitor {
     void Visit(const Class& cls) { cls.DisableAllocationStub(); }
   };
   ClearCodeClassVisitor class_visitor;
   ProgramVisitor::VisitClasses(&class_visitor);
 }
 
 }  // namespace dart