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

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/become.h"
@@ skipping 3880 matching lines @@
         // This type class implements an interface that is parameterized with
         // generic type(s), e.g. it implements List<T>.
         // The uninstantiated type T must be instantiated using the type
         // parameters of this type before performing the type test.
         // The type arguments of this type that are referred to by the type
         // parameters of the interface are at the end of the type vector,
         // after the type arguments of the super type of this type.
         // The index of the type parameters is adjusted upon finalization.
         error = Error::null();
         interface_args = interface_args.InstantiateFrom(
-            type_arguments, &error, NULL, bound_trail, space);
+            type_arguments, Object::null_type_arguments(), &error, NULL,
+            bound_trail, space);
         if (!error.IsNull()) {
           // Return the first bound error to the caller if it requests it.
           if ((bound_error != NULL) && bound_error->IsNull()) {
             *bound_error = error.raw();
           }
           continue;  // Another interface may work better.
         }
       }
       if (interface_class.TypeTest(test_kind, interface_args, other,
                                    other_type_arguments, bound_error,
@@ skipping 797 matching lines @@
 bool TypeArguments::IsDynamicTypes(bool raw_instantiated,
                                    intptr_t from_index,
                                    intptr_t len) const {
   ASSERT(Length() >= (from_index + len));
   AbstractType& type = AbstractType::Handle();
   Class& type_class = Class::Handle();
   for (intptr_t i = 0; i < len; i++) {
     type = TypeAt(from_index + i);
     if (!type.HasResolvedTypeClass()) {
       if (raw_instantiated && type.IsTypeParameter()) {
-        // An uninstantiated type parameter is equivalent to dynamic (even in
-        // the presence of a malformed bound in checked mode).
-        continue;
+        const TypeParameter& type_param = TypeParameter::Cast(type);
+        if (type_param.IsClassTypeParameter() ||
+            (type_param.IsFunctionTypeParameter() &&
+             type_param.parent_level() == 0)) {
+          // An uninstantiated type parameter is equivalent to dynamic (even in
+          // the presence of a malformed bound in checked mode).
+          continue;
+        }
       }
       return false;
     }
     type_class = type.type_class();
     if (!type_class.IsDynamicClass()) {
       return false;
     }
   }
   return true;
 }
@@ skipping 28 matching lines @@
 bool TypeArguments::HasInstantiations() const {
   const Array& prior_instantiations = Array::Handle(instantiations());
   ASSERT(prior_instantiations.Length() > 0);  // Always at least a sentinel.
   return prior_instantiations.Length() > 1;
 }
 
 
 intptr_t TypeArguments::NumInstantiations() const {
   const Array& prior_instantiations = Array::Handle(instantiations());
   ASSERT(prior_instantiations.Length() > 0);  // Always at least a sentinel.
+  intptr_t num = 0;
   intptr_t i = 0;
   while (prior_instantiations.At(i) != Smi::New(StubCode::kNoInstantiator)) {
-    i += 2;
+    i += StubCode::kInstantiationSizeInWords;
+    num++;
   }
-  return i / 2;
+  return num;
 }
 
 
 RawArray* TypeArguments::instantiations() const {
   return raw_ptr()->instantiations_;
 }
 
 
 void TypeArguments::set_instantiations(const Array& value) const {
   ASSERT(!value.IsNull());
@@ skipping 188 matching lines @@
     if (!type_args.IsNull() && type_args.IsBounded()) {
       return true;
     }
   }
   return false;
 }
 
 
 RawTypeArguments* TypeArguments::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
+    const TypeArguments& function_type_arguments,
     Error* bound_error,
     TrailPtr instantiation_trail,
     TrailPtr bound_trail,
     Heap::Space space) const {
   ASSERT(!IsInstantiated());
   if (!instantiator_type_arguments.IsNull() && IsUninstantiatedIdentity() &&
       (instantiator_type_arguments.Length() == Length())) {
     return instantiator_type_arguments.raw();
   }
   const intptr_t num_types = Length();
   TypeArguments& instantiated_array =
       TypeArguments::Handle(TypeArguments::New(num_types, space));
   AbstractType& type = AbstractType::Handle();
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     // If this type argument T is null, the type A containing T in its flattened
     // type argument vector V is recursive and is still being finalized.
     // T is the type argument of a super type of A. T is being instantiated
     // during finalization of V, which is also the instantiator. T depends
     // solely on the type parameters of A and will be replaced by a non-null
     // type before A is marked as finalized.
     if (!type.IsNull() && !type.IsInstantiated()) {
-      type = type.InstantiateFrom(instantiator_type_arguments, bound_error,
+      type = type.InstantiateFrom(instantiator_type_arguments,
+                                  function_type_arguments, bound_error,
                                   instantiation_trail, bound_trail, space);
     }
     instantiated_array.SetTypeAt(i, type);
   }
   return instantiated_array.raw();
 }
 
 
 RawTypeArguments* TypeArguments::InstantiateAndCanonicalizeFrom(
     const TypeArguments& instantiator_type_arguments,
+    const TypeArguments& function_type_arguments,
     Error* bound_error) const {
   ASSERT(!IsInstantiated());
   ASSERT(instantiator_type_arguments.IsNull() ||
          instantiator_type_arguments.IsCanonical());
+  ASSERT(function_type_arguments.IsNull() ||
+         function_type_arguments.IsCanonical());
   // Lookup instantiator and, if found, return paired instantiated result.
   Array& prior_instantiations = Array::Handle(instantiations());
   ASSERT(!prior_instantiations.IsNull() && prior_instantiations.IsArray());
   // The instantiations cache is initialized with Object::zero_array() and is
   // therefore guaranteed to contain kNoInstantiator. No length check needed.
   ASSERT(prior_instantiations.Length() > 0);  // Always at least a sentinel.
   intptr_t index = 0;
   while (true) {
-    if (prior_instantiations.At(index) == instantiator_type_arguments.raw()) {
-      return TypeArguments::RawCast(prior_instantiations.At(index + 1));
+    if ((prior_instantiations.At(index) == instantiator_type_arguments.raw()) &&
+        (prior_instantiations.At(index + 1) == function_type_arguments.raw())) {
+      return TypeArguments::RawCast(prior_instantiations.At(index + 2));
     }
     if (prior_instantiations.At(index) == Smi::New(StubCode::kNoInstantiator)) {
       break;
     }
-    index += 2;
+    index += StubCode::kInstantiationSizeInWords;
   }
   // Cache lookup failed. Instantiate the type arguments.
   TypeArguments& result = TypeArguments::Handle();
-  result = InstantiateFrom(instantiator_type_arguments, bound_error, NULL, NULL,
-                           Heap::kOld);
+  result = InstantiateFrom(instantiator_type_arguments, function_type_arguments,
+                           bound_error, NULL, NULL, Heap::kOld);
   if ((bound_error != NULL) && !bound_error->IsNull()) {
     return result.raw();
   }
   // Instantiation did not result in bound error. Canonicalize type arguments.
   result = result.Canonicalize();
   // InstantiateAndCanonicalizeFrom is not reentrant. It cannot have been called
   // indirectly, so the prior_instantiations array cannot have grown.
   ASSERT(prior_instantiations.raw() == instantiations());
-  // Add instantiator and result to instantiations array.
+  // Do not cache result if the context is required to instantiate the
+  // type arguments, i.e. they refer to the type parameters of parent functions.
+  if (!IsInstantiated(kParentFunctions)) {
+    return result.raw();
+  }
+  // Add instantiator and function type args and result to instantiations array.
   intptr_t length = prior_instantiations.Length();
-  if ((index + 2) >= length) {
+  if ((index + StubCode::kInstantiationSizeInWords) >= length) {
+    // TODO(regis): Should we limit the number of cached instantiations?
     // Grow the instantiations array.
     // The initial array is Object::zero_array() of length 1.
-    length = (length > 64) ? (length + 64)
-                           : ((length == 1) ? 3 : ((length - 1) * 2 + 1));
+    length = (length > 64)
+                 ? (length + 64)
+                 : ((length == 1) ? StubCode::kInstantiationSizeInWords + 1
+                                  : ((length - 1) * 2 + 1));
     prior_instantiations =
         Array::Grow(prior_instantiations, length, Heap::kOld);
     set_instantiations(prior_instantiations);
-    ASSERT((index + 2) < length);
+    ASSERT((index + StubCode::kInstantiationSizeInWords) < length);
   }
-  prior_instantiations.SetAt(index, instantiator_type_arguments);
-  prior_instantiations.SetAt(index + 1, result);
-  prior_instantiations.SetAt(index + 2,
+  prior_instantiations.SetAt(index + 0, instantiator_type_arguments);
+  prior_instantiations.SetAt(index + 1, function_type_arguments);
+  prior_instantiations.SetAt(index + 2, result);
+  prior_instantiations.SetAt(index + 3,
                              Smi::Handle(Smi::New(StubCode::kNoInstantiator)));
   return result.raw();
 }
 
 
 RawTypeArguments* TypeArguments::New(intptr_t len, Heap::Space space) {
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in TypeArguments::New: invalid len %" Pd "\n", len);
   }
@@ skipping 880 matching lines @@
 }
 
 
 intptr_t Function::NumTypeParameters(Thread* thread) const {
   if (type_parameters() == TypeArguments::null()) {
     return 0;
   }
   REUSABLE_TYPE_ARGUMENTS_HANDLESCOPE(thread);
   TypeArguments& type_params = thread->TypeArgumentsHandle();
   type_params = type_parameters();
+  // We require null to represent a non-generic function.
+  ASSERT(type_params.Length() != 0);
   return type_params.Length();
 }
 
 
 RawTypeParameter* Function::LookupTypeParameter(
     const String& type_name,
     intptr_t* function_level) const {
   ASSERT(!type_name.IsNull());
   Thread* thread = Thread::Current();
   REUSABLE_TYPE_ARGUMENTS_HANDLESCOPE(thread);
@@ skipping 407 matching lines @@
   ASSERT(Isolate::Current()->error_on_bad_override());
   ASSERT((bound_error != NULL) && bound_error->IsNull());
   // Check that this function's signature type is a subtype of the other
   // function's signature type.
   // Map type parameters in the signature to dynamic before the test.
   Function& this_fun = Function::Handle(raw());
   if (!this_fun.HasInstantiatedSignature()) {
     // TODO(regis): Should we pass the context explicitly here (i.e. null) once
     // we support generic functions?
     this_fun = this_fun.InstantiateSignatureFrom(Object::null_type_arguments(),
+                                                 Object::null_type_arguments(),
                                                  Heap::kOld);
   }
   Function& other_fun = Function::Handle(other.raw());
   if (!other_fun.HasInstantiatedSignature()) {
     // TODO(regis): Should we pass the context explicitly here (i.e. null) once
     // we support generic functions?
     other_fun = other_fun.InstantiateSignatureFrom(
-        Object::null_type_arguments(), Heap::kOld);
+        Object::null_type_arguments(), Object::null_type_arguments(),
+        Heap::kOld);
   }
   if (!this_fun.TypeTest(kIsSubtypeOf, other_fun, bound_error, Heap::kOld)) {
     // For more informative error reporting, use the location of the other
     // function here, since the caller will use the location of this function.
     *bound_error = LanguageError::NewFormatted(
         *bound_error,  // A bound error if non null.
         Script::Handle(other.script()), other.token_pos(), Report::AtLocation,
         Report::kError, Heap::kNew,
         "signature type '%s' of function '%s' is not a subtype of signature "
         "type '%s' of function '%s'\n",
         String::Handle(UserVisibleSignature()).ToCString(),
         String::Handle(UserVisibleName()).ToCString(),
         String::Handle(other.UserVisibleSignature()).ToCString(),
         String::Handle(other.UserVisibleName()).ToCString());
     return false;
   }
   // We should also check that if the other function explicitly specifies a
   // default value for a formal parameter, this function does not specify a
   // different default value for the same parameter. However, this check is not
   // possible in the current implementation, because the default parameter
   // values are not stored in the Function object, but discarded after a
   // function is compiled.
   return true;
 }
 
 
 RawFunction* Function::InstantiateSignatureFrom(
     const TypeArguments& instantiator_type_arguments,
+    const TypeArguments& function_type_arguments,
     Heap::Space space) const {
   Zone* zone = Thread::Current()->zone();
   const Object& owner = Object::Handle(zone, RawOwner());
   // TODO(regis): Should we change Function::New() to accept a space, since
   // InstantiateFrom is sometimes called with Heap::kNew?
   ASSERT(!HasInstantiatedSignature());
   Function& sig = Function::Handle(
       zone, Function::NewSignatureFunction(owner, TokenPosition::kNoSource));
   sig.set_type_parameters(TypeArguments::Handle(zone, type_parameters()));
   AbstractType& type = AbstractType::Handle(zone, result_type());
   if (!type.IsInstantiated()) {
-    type = type.InstantiateFrom(instantiator_type_arguments, NULL, NULL, NULL,
-                                space);
+    type =
+        type.InstantiateFrom(instantiator_type_arguments,
+                             function_type_arguments, NULL, NULL, NULL, space);
   }
   sig.set_result_type(type);
   const intptr_t num_params = NumParameters();
   sig.set_num_fixed_parameters(num_fixed_parameters());
   sig.SetNumOptionalParameters(NumOptionalParameters(),
                                HasOptionalPositionalParameters());
   sig.set_parameter_types(Array::Handle(Array::New(num_params, space)));
   for (intptr_t i = 0; i < num_params; i++) {
     type = ParameterTypeAt(i);
     if (!type.IsInstantiated()) {
-      type = type.InstantiateFrom(instantiator_type_arguments, NULL, NULL, NULL,
+      type = type.InstantiateFrom(instantiator_type_arguments,
+                                  function_type_arguments, NULL, NULL, NULL,
                                   space);
     }
     sig.SetParameterTypeAt(i, type);
   }
   sig.set_parameter_names(Array::Handle(zone, parameter_names()));
   return sig.raw();
 }
 
 
 // If test_kind == kIsSubtypeOf, checks if the type of the specified parameter
@@ skipping 8616 matching lines @@
   NoSafepointScope no_safepoint;
   // Do not count the sentinel;
   return (Smi::Value(cache()->ptr()->length_) / kTestEntryLength) - 1;
 }
 
 
 void SubtypeTestCache::AddCheck(
     const Object& instance_class_id_or_function,
     const TypeArguments& instance_type_arguments,
     const TypeArguments& instantiator_type_arguments,
+    const TypeArguments& function_type_arguments,
     const Bool& test_result) const {
   intptr_t old_num = NumberOfChecks();
   Array& data = Array::Handle(cache());
   intptr_t new_len = data.Length() + kTestEntryLength;
   data = Array::Grow(data, new_len);
   set_cache(data);
   intptr_t data_pos = old_num * kTestEntryLength;
   data.SetAt(data_pos + kInstanceClassIdOrFunction,
              instance_class_id_or_function);
   data.SetAt(data_pos + kInstanceTypeArguments, instance_type_arguments);
   data.SetAt(data_pos + kInstantiatorTypeArguments,
              instantiator_type_arguments);
+  data.SetAt(data_pos + kFunctionTypeArguments, function_type_arguments);
   data.SetAt(data_pos + kTestResult, test_result);
 }
 
 
 void SubtypeTestCache::GetCheck(intptr_t ix,
                                 Object* instance_class_id_or_function,
                                 TypeArguments* instance_type_arguments,
                                 TypeArguments* instantiator_type_arguments,
+                                TypeArguments* function_type_arguments,
                                 Bool* test_result) const {
   Array& data = Array::Handle(cache());
   intptr_t data_pos = ix * kTestEntryLength;
   *instance_class_id_or_function =
       data.At(data_pos + kInstanceClassIdOrFunction);
   *instance_type_arguments ^= data.At(data_pos + kInstanceTypeArguments);
   *instantiator_type_arguments ^=
       data.At(data_pos + kInstantiatorTypeArguments);
+  *function_type_arguments ^= data.At(data_pos + kFunctionTypeArguments);
   *test_result ^= data.At(data_pos + kTestResult);
 }
 
 
 const char* SubtypeTestCache::ToCString() const {
   return "SubtypeTestCache";
 }
 
 
 const char* Error::ToErrorCString() const {
@@ skipping 489 matching lines @@
     return Type::NullType();
   }
   const Class& cls = Class::Handle(clazz());
   if (cls.IsClosureClass()) {
     const Function& signature =
         Function::Handle(Closure::Cast(*this).function());
     Type& type = Type::Handle(signature.SignatureType());
     if (!type.IsInstantiated()) {
       TypeArguments& instantiator_type_arguments =
           TypeArguments::Handle(Closure::Cast(*this).instantiator());
-      // TODO(regis): Should we pass the context explicitly here (i.e. null)
-      // once we support generic functions?
-      type ^= type.InstantiateFrom(instantiator_type_arguments, NULL, NULL,
-                                   NULL, space);
+      const TypeArguments& function_type_arguments =
+          TypeArguments::Handle(signature.type_parameters());
+      // TODO(regis): Pass the closure context to InstantiateSignatureFrom().
+      // No bound error possible, since the instance exists.
+      type ^= type.InstantiateFrom(instantiator_type_arguments,
+                                   function_type_arguments, NULL, NULL, NULL,
+                                   space);
     }
     type ^= type.Canonicalize();
     return type.raw();
   }
   Type& type = Type::Handle();
   if (!cls.IsGeneric()) {
     type = cls.CanonicalType();
   }
   if (type.IsNull()) {
     TypeArguments& type_arguments = TypeArguments::Handle();
@@ skipping 20 matching lines @@
 
 void Instance::SetTypeArguments(const TypeArguments& value) const {
   ASSERT(value.IsNull() || value.IsCanonical());
   const Class& cls = Class::Handle(clazz());
   intptr_t field_offset = cls.type_arguments_field_offset();
   ASSERT(field_offset != Class::kNoTypeArguments);
   SetFieldAtOffset(field_offset, value);
 }
 
 
-bool Instance::IsInstanceOf(const AbstractType& other,
-                            const TypeArguments& other_instantiator,
-                            Error* bound_error) const {
+bool Instance::IsInstanceOf(
+    const AbstractType& other,
+    const TypeArguments& other_instantiator_type_arguments,
+    const TypeArguments& other_function_type_arguments,
+    Error* bound_error) const {
   ASSERT(other.IsFinalized());
   ASSERT(!other.IsDynamicType());
   ASSERT(!other.IsTypeRef());  // Must be dereferenced at compile time.
   ASSERT(!other.IsMalformed());
   ASSERT(!other.IsMalbounded());
   if (other.IsVoidType()) {
     return false;
   }
   Zone* zone = Thread::Current()->zone();
   const Class& cls = Class::Handle(zone, clazz());
   if (cls.IsClosureClass()) {
     if (other.IsObjectType() || other.IsDartFunctionType() ||
         other.IsDartClosureType()) {
       return true;
     }
     AbstractType& instantiated_other = AbstractType::Handle(zone, other.raw());
     // Note that we may encounter a bound error in checked mode.
     if (!other.IsInstantiated()) {
       instantiated_other = other.InstantiateFrom(
-          other_instantiator, bound_error, NULL, NULL, Heap::kOld);
+          other_instantiator_type_arguments, other_function_type_arguments,
+          bound_error, NULL, NULL, Heap::kOld);
       if ((bound_error != NULL) && !bound_error->IsNull()) {
         ASSERT(Isolate::Current()->type_checks());
         return false;
       }
       if (instantiated_other.IsTypeRef()) {
         instantiated_other = TypeRef::Cast(instantiated_other).type();
       }
       if (instantiated_other.IsDynamicType() ||
           instantiated_other.IsObjectType() ||
           instantiated_other.IsDartFunctionType()) {
         return true;
       }
     }
     if (!instantiated_other.IsFunctionType()) {
       return false;
     }
     Function& other_signature =
         Function::Handle(zone, Type::Cast(instantiated_other).signature());
     Function& sig_fun = Function::Handle(zone, Closure::Cast(*this).function());
     if (!sig_fun.HasInstantiatedSignature()) {
       const TypeArguments& instantiator_type_arguments =
           TypeArguments::Handle(zone, Closure::Cast(*this).instantiator());
-      // TODO(regis): If sig_fun is generic, pass its type parameters
-      // as function instantiator, otherwise pass null.
-      // Pass the closure context as well to InstantiateSignatureFrom().
-      // No bound error possible, since the instance exists.
-      sig_fun = sig_fun.InstantiateSignatureFrom(instantiator_type_arguments,
-                                                 Heap::kOld);
+      const TypeArguments& function_type_arguments =
+          TypeArguments::Handle(zone, sig_fun.type_parameters());
+      // TODO(regis): Pass the closure context to InstantiateSignatureFrom().
+      sig_fun = sig_fun.InstantiateSignatureFrom(
+          instantiator_type_arguments, function_type_arguments, Heap::kOld);
     }
     return sig_fun.IsSubtypeOf(other_signature, bound_error, Heap::kOld);
   }
   TypeArguments& type_arguments = TypeArguments::Handle(zone);
   if (cls.NumTypeArguments() > 0) {
     type_arguments = GetTypeArguments();
     ASSERT(type_arguments.IsNull() || type_arguments.IsCanonical());
     // The number of type arguments in the instance must be greater or equal to
     // the number of type arguments expected by the instance class.
     // A discrepancy is allowed for closures, which borrow the type argument
     // vector of their instantiator, which may be of a subclass of the class
     // defining the closure. Truncating the vector to the correct length on
     // instantiation is unnecessary. The vector may therefore be longer.
     // Also, an optimization reuses the type argument vector of the instantiator
     // of generic instances when its layout is compatible.
     ASSERT(type_arguments.IsNull() ||
            (type_arguments.Length() >= cls.NumTypeArguments()));
   }
   Class& other_class = Class::Handle(zone);
   TypeArguments& other_type_arguments = TypeArguments::Handle(zone);
   AbstractType& instantiated_other = AbstractType::Handle(zone, other.raw());
   // Note that we may encounter a bound error in checked mode.
   if (!other.IsInstantiated()) {
-    instantiated_other = other.InstantiateFrom(other_instantiator, bound_error,
-                                               NULL, NULL, Heap::kOld);
+    instantiated_other = other.InstantiateFrom(
+        other_instantiator_type_arguments, other_function_type_arguments,
+        bound_error, NULL, NULL, Heap::kOld);
     if ((bound_error != NULL) && !bound_error->IsNull()) {
       ASSERT(Isolate::Current()->type_checks());
       return false;
     }
     if (instantiated_other.IsTypeRef()) {
       instantiated_other = TypeRef::Cast(instantiated_other).type();
     }
     if (instantiated_other.IsDynamicType()) {
       return true;
     }
   }
   other_type_arguments = instantiated_other.arguments();
   const bool other_is_dart_function = instantiated_other.IsDartFunctionType();
   if (other_is_dart_function || instantiated_other.IsFunctionType()) {
     // Check if this instance understands a call() method of a compatible type.
     Function& sig_fun =
         Function::Handle(zone, cls.LookupCallFunctionForTypeTest());
     if (!sig_fun.IsNull()) {
       if (other_is_dart_function) {
         return true;
       }
       if (!sig_fun.HasInstantiatedSignature()) {
-        // TODO(regis): If sig_fun is generic, pass its type parameters
-        // as function instantiator, otherwise pass null.
-        // Pass the closure context as well to InstantiateSignatureFrom().
+        const TypeArguments& function_type_arguments =
+            TypeArguments::Handle(zone, sig_fun.type_parameters());
+        // TODO(regis): Pass the closure context to InstantiateSignatureFrom().
         // No bound error possible, since the instance exists.
-        sig_fun = sig_fun.InstantiateSignatureFrom(type_arguments, Heap::kOld);
+        sig_fun = sig_fun.InstantiateSignatureFrom(
+            type_arguments, function_type_arguments, Heap::kOld);
       }
       const Function& other_signature =
           Function::Handle(zone, Type::Cast(instantiated_other).signature());
       if (sig_fun.IsSubtypeOf(other_signature, bound_error, Heap::kOld)) {
         return true;
       }
     }
   }
   if (!instantiated_other.IsType()) {
     return false;
@@ skipping 334 matching lines @@
 
 bool AbstractType::IsRecursive() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
 RawAbstractType* AbstractType::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
+    const TypeArguments& function_type_arguments,
     Error* bound_error,
     TrailPtr instantiation_trail,
     TrailPtr bound_trail,
     Heap::Space space) const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
@@ skipping 747 matching lines @@
     len = cls.NumTypeParameters();  // Check the type parameters only.
   }
   return (len == 0) ||
          args.IsSubvectorInstantiated(num_type_args - len, len, genericity,
                                       trail);
 }
 
 
 RawAbstractType* Type::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
+    const TypeArguments& function_type_arguments,
     Error* bound_error,
     TrailPtr instantiation_trail,
     TrailPtr bound_trail,
     Heap::Space space) const {
   Zone* zone = Thread::Current()->zone();
   ASSERT(IsFinalized() || IsBeingFinalized());
   ASSERT(!IsInstantiated());
   // Return the uninstantiated type unchanged if malformed. No copy needed.
   if (IsMalformed()) {
     return raw();
   }
   // Note that the type class has to be resolved at this time, but not
   // necessarily finalized yet. We may be checking bounds at compile time or
   // finalizing the type argument vector of a recursive type.
   const Class& cls = Class::Handle(zone, type_class());
   TypeArguments& type_arguments = TypeArguments::Handle(zone, arguments());
   Function& sig_fun = Function::Handle(zone, signature());
   if (!type_arguments.IsNull() &&
       (sig_fun.IsNull() || !type_arguments.IsInstantiated())) {
     // This type is uninstantiated because either its type arguments or its
     // signature, or both are uninstantiated.
     // Note that the type arguments of a function type merely document the
     // parameterization of a generic typedef. They are otherwise ignored.
     ASSERT(type_arguments.Length() == cls.NumTypeArguments());
-    type_arguments =
-        type_arguments.InstantiateFrom(instantiator_type_arguments, bound_error,
-                                       instantiation_trail, bound_trail, space);
+    type_arguments = type_arguments.InstantiateFrom(
+        instantiator_type_arguments, function_type_arguments, bound_error,
+        instantiation_trail, bound_trail, space);
   }
   // This uninstantiated type is not modified, as it can be instantiated
   // with different instantiators. Allocate a new instantiated version of it.
   const Type& instantiated_type =
       Type::Handle(zone, Type::New(cls, type_arguments, token_pos(), space));
   // Preserve the bound error if any.
   if (IsMalbounded()) {
     const LanguageError& bound_error = LanguageError::Handle(zone, error());
     instantiated_type.set_error(bound_error);
   }
   // If this type is a function type, instantiate its signature.
   if (!sig_fun.IsNull()) {
     // If we are finalizing a typedef, do not yet instantiate its signature.
     // Other function types should never be instantiated while unfinalized.
     if (IsFinalized()) {
       // A generic typedef may actually declare an instantiated signature.
       if (!sig_fun.HasInstantiatedSignature()) {
-        sig_fun = sig_fun.InstantiateSignatureFrom(instantiator_type_arguments,
-                                                   space);
+        sig_fun = sig_fun.InstantiateSignatureFrom(
+            instantiator_type_arguments, function_type_arguments, space);
       }
     } else {
       ASSERT(cls.IsTypedefClass());
     }
     instantiated_type.set_signature(sig_fun);
   }
   if (IsFinalized()) {
     instantiated_type.SetIsFinalized();
   } else {
     instantiated_type.SetIsResolved();
@@ skipping 636 matching lines @@
   }
   if (TestAndAddBuddyToTrail(&trail, AbstractType::Cast(other))) {
     return true;
   }
   return AbstractType::Handle(type()).IsEquivalent(other, trail);
 }
 
 
 RawTypeRef* TypeRef::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
+    const TypeArguments& function_type_arguments,
     Error* bound_error,
     TrailPtr instantiation_trail,
     TrailPtr bound_trail,
     Heap::Space space) const {
   TypeRef& instantiated_type_ref = TypeRef::Handle();
   instantiated_type_ref ^= OnlyBuddyInTrail(instantiation_trail);
   if (!instantiated_type_ref.IsNull()) {
     return instantiated_type_ref.raw();
   }
   instantiated_type_ref = TypeRef::New();
   AddOnlyBuddyToTrail(&instantiation_trail, instantiated_type_ref);
 
   AbstractType& ref_type = AbstractType::Handle(type());
   ASSERT(!ref_type.IsTypeRef());
   AbstractType& instantiated_ref_type = AbstractType::Handle();
-  instantiated_ref_type =
-      ref_type.InstantiateFrom(instantiator_type_arguments, bound_error,
-                               instantiation_trail, bound_trail, space);
+  instantiated_ref_type = ref_type.InstantiateFrom(
+      instantiator_type_arguments, function_type_arguments, bound_error,
+      instantiation_trail, bound_trail, space);
   ASSERT(!instantiated_ref_type.IsTypeRef());
   instantiated_type_ref.set_type(instantiated_ref_type);
   return instantiated_type_ref.raw();
 }
 
 
 RawTypeRef* TypeRef::CloneUninstantiated(const Class& new_owner,
                                          TrailPtr trail) const {
   TypeRef& cloned_type_ref = TypeRef::Handle();
   cloned_type_ref ^= OnlyBuddyInTrail(trail);
@@ skipping 201 matching lines @@
 }
 
 
 void TypeParameter::set_bound(const AbstractType& value) const {
   StorePointer(&raw_ptr()->bound_, value.raw());
 }
 
 
 RawAbstractType* TypeParameter::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
+    const TypeArguments& function_type_arguments,
     Error* bound_error,
     TrailPtr instantiation_trail,
     TrailPtr bound_trail,
     Heap::Space space) const {
   ASSERT(IsFinalized());
+  if (IsFunctionTypeParameter()) {
+    if (parent_level() == 0) {
+      if (function_type_arguments.IsNull()) {
+        return Type::DynamicType();
+      }
+      return function_type_arguments.TypeAt(index());
+    }
+    // We need to find the type argument vector of the parent function at
+    // parent_level() in the context.
+    UNIMPLEMENTED();
+    return function_type_arguments.TypeAt(index());
+  }
+  ASSERT(IsClassTypeParameter());
   if (instantiator_type_arguments.IsNull()) {
     return Type::DynamicType();
   }
-  const AbstractType& type_arg =
-      AbstractType::Handle(instantiator_type_arguments.TypeAt(index()));
+  return instantiator_type_arguments.TypeAt(index());
   // There is no need to canonicalize the instantiated type parameter, since all
   // type arguments are canonicalized at type finalization time. It would be too
   // early to canonicalize the returned type argument here, since instantiation
   // not only happens at run time, but also during type finalization.
 
   // If the instantiated type parameter type_arg is a BoundedType, it means that
   // it is still uninstantiated and that we are instantiating at finalization
   // time (i.e. compile time).
   // Indeed, the instantiator (type arguments of an instance) is always
   // instantiated at run time and any bounds were checked during allocation.
-  return type_arg.raw();
 }
 
 
 bool TypeParameter::CheckBound(const AbstractType& bounded_type,
                                const AbstractType& upper_bound,
                                Error* bound_error,
                                TrailPtr bound_trail,
                                Heap::Space space) const {
   ASSERT((bound_error != NULL) && bound_error->IsNull());
   ASSERT(bounded_type.IsFinalized());
@@ skipping 290 matching lines @@
 void BoundedType::set_type_parameter(const TypeParameter& value) const {
   // A null type parameter is set when marking a type malformed because of a
   // bound error at compile time.
   ASSERT(value.IsNull() || value.IsFinalized());
   StorePointer(&raw_ptr()->type_parameter_, value.raw());
 }
 
 
 RawAbstractType* BoundedType::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
+    const TypeArguments& function_type_arguments,
     Error* bound_error,
     TrailPtr instantiation_trail,
     TrailPtr bound_trail,
     Heap::Space space) const {
   ASSERT(IsFinalized());
   AbstractType& bounded_type = AbstractType::Handle(type());
   ASSERT(bounded_type.IsFinalized());
   AbstractType& instantiated_bounded_type =
       AbstractType::Handle(bounded_type.raw());
   if (!bounded_type.IsInstantiated()) {
-    instantiated_bounded_type =
-        bounded_type.InstantiateFrom(instantiator_type_arguments, bound_error,
-                                     instantiation_trail, bound_trail, space);
+    instantiated_bounded_type = bounded_type.InstantiateFrom(
+        instantiator_type_arguments, function_type_arguments, bound_error,
+        instantiation_trail, bound_trail, space);
     // In case types of instantiator_type_arguments are not finalized
     // (or instantiated), then the instantiated_bounded_type is not finalized
     // (or instantiated) either.
     // Note that instantiator_type_arguments must have the final length, though.
   }
   if ((Isolate::Current()->type_checks()) && (bound_error != NULL) &&
       bound_error->IsNull()) {
     AbstractType& upper_bound = AbstractType::Handle(bound());
     ASSERT(upper_bound.IsFinalized());
     ASSERT(!upper_bound.IsObjectType() && !upper_bound.IsDynamicType());
     AbstractType& instantiated_upper_bound =
         AbstractType::Handle(upper_bound.raw());
     if (!upper_bound.IsInstantiated()) {
-      instantiated_upper_bound =
-          upper_bound.InstantiateFrom(instantiator_type_arguments, bound_error,
-                                      instantiation_trail, bound_trail, space);
+      instantiated_upper_bound = upper_bound.InstantiateFrom(
+          instantiator_type_arguments, function_type_arguments, bound_error,
+          instantiation_trail, bound_trail, space);
       // The instantiated_upper_bound may not be finalized or instantiated.
       // See comment above.
     }
     if (bound_error->IsNull()) {
       // Shortcut the F-bounded case where we have reached a fixpoint.
       if (instantiated_bounded_type.Equals(bounded_type) &&
           instantiated_upper_bound.Equals(upper_bound)) {
         return bounded_type.raw();
       }
       const TypeParameter& type_param = TypeParameter::Handle(type_parameter());
@@ skipping 4877 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart