Remove parent_level field of function type parameters.

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 93 matching lines @@
 // they are being used.
 #if defined(RAW_NULL)
 #error RAW_NULL should not be defined.
 #endif
 #define RAW_NULL kHeapObjectTag
 Object* Object::null_object_ = NULL;
 Array* Object::null_array_ = NULL;
 String* Object::null_string_ = NULL;
 Instance* Object::null_instance_ = NULL;
 TypeArguments* Object::null_type_arguments_ = NULL;
+TypeArguments* Object::empty_type_arguments_ = NULL;
 Array* Object::empty_array_ = NULL;
 Array* Object::zero_array_ = NULL;
 Context* Object::empty_context_ = NULL;
 ContextScope* Object::empty_context_scope_ = NULL;
 ObjectPool* Object::empty_object_pool_ = NULL;
 PcDescriptors* Object::empty_descriptors_ = NULL;
 LocalVarDescriptors* Object::empty_var_descriptors_ = NULL;
 ExceptionHandlers* Object::empty_exception_handlers_ = NULL;
 Array* Object::extractor_parameter_types_ = NULL;
 Array* Object::extractor_parameter_names_ = NULL;
@@ skipping 384 matching lines @@
   }
 
   Heap* heap = isolate->heap();
 
   // Allocate the read only object handles here.
   null_object_ = Object::ReadOnlyHandle();
   null_array_ = Array::ReadOnlyHandle();
   null_string_ = String::ReadOnlyHandle();
   null_instance_ = Instance::ReadOnlyHandle();
   null_type_arguments_ = TypeArguments::ReadOnlyHandle();
+  empty_type_arguments_ = TypeArguments::ReadOnlyHandle();
   empty_array_ = Array::ReadOnlyHandle();
   zero_array_ = Array::ReadOnlyHandle();
   empty_context_ = Context::ReadOnlyHandle();
   empty_context_scope_ = ContextScope::ReadOnlyHandle();
   empty_object_pool_ = ObjectPool::ReadOnlyHandle();
   empty_descriptors_ = PcDescriptors::ReadOnlyHandle();
   empty_var_descriptors_ = LocalVarDescriptors::ReadOnlyHandle();
   empty_exception_handlers_ = ExceptionHandlers::ReadOnlyHandle();
   extractor_parameter_types_ = Array::ReadOnlyHandle();
   extractor_parameter_names_ = Array::ReadOnlyHandle();
@@ skipping 221 matching lines @@
   isolate->object_store()->set_double_class(cls);
 
   // Ensure that class kExternalTypedDataUint8ArrayCid is registered as we
   // need it when reading in the token stream of bootstrap classes in the VM
   // isolate.
   Class::NewExternalTypedDataClass(kExternalTypedDataUint8ArrayCid);
 
   // Needed for object pools of VM isolate stubs.
   Class::NewTypedDataClass(kTypedDataInt8ArrayCid);
 
+  // Allocate and initialize the empty_type_arguments instance.
+  {
+    uword address = heap->Allocate(TypeArguments::InstanceSize(0), Heap::kOld);
+    InitializeObject(address, TypeArguments::kClassId,
+                     TypeArguments::InstanceSize(0), true);
+    TypeArguments::initializeHandle(
+        empty_type_arguments_,
+        reinterpret_cast<RawTypeArguments*>(address + kHeapObjectTag));
+    empty_type_arguments_->StoreSmi(&empty_type_arguments_->raw_ptr()->length_,
+                                    Smi::New(0));
+    empty_type_arguments_->StoreSmi(&empty_type_arguments_->raw_ptr()->hash_,
+                                    Smi::New(0));
+    // instantiations_ field is initialized to null and should not be used.
+    empty_type_arguments_->SetCanonical();
+  }
+
   // Allocate and initialize the empty_array instance.
   {
     uword address = heap->Allocate(Array::InstanceSize(0), Heap::kOld);
     InitializeObject(address, kImmutableArrayCid, Array::InstanceSize(0), true);
     Array::initializeHandle(
         empty_array_, reinterpret_cast<RawArray*>(address + kHeapObjectTag));
     empty_array_->StoreSmi(&empty_array_->raw_ptr()->length_, Smi::New(0));
     empty_array_->SetCanonical();
   }
 
@@ skipping 155 matching lines @@
 
   ASSERT(!null_object_->IsSmi());
   ASSERT(!null_array_->IsSmi());
   ASSERT(null_array_->IsArray());
   ASSERT(!null_string_->IsSmi());
   ASSERT(null_string_->IsString());
   ASSERT(!null_instance_->IsSmi());
   ASSERT(null_instance_->IsInstance());
   ASSERT(!null_type_arguments_->IsSmi());
   ASSERT(null_type_arguments_->IsTypeArguments());
+  ASSERT(!empty_type_arguments_->IsSmi());
+  ASSERT(empty_type_arguments_->IsTypeArguments());
   ASSERT(!empty_array_->IsSmi());
   ASSERT(empty_array_->IsArray());
   ASSERT(!zero_array_->IsSmi());
   ASSERT(zero_array_->IsArray());
   ASSERT(!empty_context_->IsSmi());
   ASSERT(empty_context_->IsContext());
   ASSERT(!empty_context_scope_->IsSmi());
   ASSERT(empty_context_scope_->IsContextScope());
   ASSERT(!empty_descriptors_->IsSmi());
   ASSERT(empty_descriptors_->IsPcDescriptors());
@@ skipping 3766 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()) {
-        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;
-        }
+        // 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 283 matching lines @@
 }
 
 
 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());
+  // TODO(regis): It is not clear yet whether we will canonicalize the result
+  // of the concatenation of function_type_arguments in a nested generic
+  // function. Leave the assert for now to be safe, but plan on revisiting.
   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) {
@@ skipping 11 matching lines @@
   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());
-  // 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 + 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) ? StubCode::kInstantiationSizeInWords + 1
                                   : ((length - 1) * 2 + 1));
@@ skipping 905 matching lines @@
   }
   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();
 }
 
 
+intptr_t Function::NumParentTypeParameters() const {
+  Thread* thread = Thread::Current();
+  Function& parent = Function::Handle(parent_function());
+  intptr_t num_parent_type_params = 0;
+  while (!parent.IsNull()) {
+    num_parent_type_params += parent.NumTypeParameters(thread);
+    parent ^= parent.parent_function();
+  }
+  return num_parent_type_params;
+}
+
+
 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);
   REUSABLE_TYPE_PARAMETER_HANDLESCOPE(thread);
   REUSABLE_STRING_HANDLESCOPE(thread);
   REUSABLE_FUNCTION_HANDLESCOPE(thread);
   TypeArguments& type_params = thread->TypeArgumentsHandle();
   TypeParameter& type_param = thread->TypeParameterHandle();
   String& type_param_name = thread->StringHandle();
   Function& function = thread->FunctionHandle();
 
   function ^= this->raw();
-  intptr_t parent_level = 0;
   while (!function.IsNull()) {
     type_params ^= function.type_parameters();
     if (!type_params.IsNull()) {
       const intptr_t num_type_params = type_params.Length();
       for (intptr_t i = 0; i < num_type_params; i++) {
         type_param ^= type_params.TypeAt(i);
         type_param_name = type_param.name();
         if (type_param_name.Equals(type_name)) {
-          if (parent_level > 0) {
-            // Clone type parameter and set parent_level.
-            type_param = TypeParameter::New(
-                Class::Handle(), function, type_param.index(), parent_level,
-                type_param_name, AbstractType::Handle(type_param.bound()),
-                TokenPosition::kNoSource);
-            type_param.SetIsFinalized();
-          }
           return type_param.raw();
         }
       }
     }
     function ^= function.parent_function();
-    parent_level++;
     if (function_level != NULL) {
       (*function_level)--;
     }
   }
   return TypeParameter::null();
 }
 
 
 void Function::set_kind(RawFunction::Kind value) const {
   set_kind_tag(KindBits::update(value, raw_ptr()->kind_tag_));
@@ skipping 503 matching lines @@
   const intptr_t num_ignored_params = NumImplicitParameters();
   const intptr_t other_num_ignored_params = other.NumImplicitParameters();
   if (((num_fixed_params - num_ignored_params) >
        (other_num_fixed_params - other_num_ignored_params)) ||
       ((num_fixed_params - num_ignored_params + num_opt_pos_params) <
        (other_num_fixed_params - other_num_ignored_params +
         other_num_opt_pos_params)) ||
       (num_opt_named_params < other_num_opt_named_params)) {
     return false;
   }
+
+  // TODO(regis): Check the type parameters and bounds of a generic function.
+
   // Check the result type.
   const AbstractType& other_res_type =
       AbstractType::Handle(other.result_type());
   if (!other_res_type.IsDynamicType() && !other_res_type.IsVoidType()) {
     const AbstractType& res_type = AbstractType::Handle(result_type());
     if (res_type.IsVoidType()) {
       return false;
     }
     if (test_kind == kIsSubtypeOf) {
       if (!res_type.IsSubtypeOf(other_res_type, bound_error, NULL, space) &&
@@ skipping 399 matching lines @@
       pieces->Add(Symbols::RBrace());
     }
   }
 }
 
 
 RawInstance* Function::ImplicitStaticClosure() const {
   if (implicit_static_closure() == Instance::null()) {
     Zone* zone = Thread::Current()->zone();
     const Context& context = Object::empty_context();
-    const TypeArguments& instantiator = TypeArguments::Handle(zone);
-    Instance& closure = Instance::Handle(
-        zone, Closure::New(instantiator, *this, context, Heap::kOld));
+    TypeArguments& function_type_arguments = TypeArguments::Handle(zone);
+    if (!HasInstantiatedSignature(kFunctions)) {
+      function_type_arguments = Object::empty_type_arguments().raw();
+    }
+    Instance& closure =
+        Instance::Handle(zone, Closure::New(Object::null_type_arguments(),
+                                            function_type_arguments, *this,
+                                            context, Heap::kOld));
     set_implicit_static_closure(closure);
   }
   return implicit_static_closure();
 }
 
 
 RawInstance* Function::ImplicitInstanceClosure(const Instance& receiver) const {
   ASSERT(IsImplicitClosureFunction());
   Zone* zone = Thread::Current()->zone();
   const Context& context = Context::Handle(zone, Context::New(1));
   context.SetAt(0, receiver);
-  TypeArguments& instantiator = TypeArguments::Handle(zone);
+  TypeArguments& instantiator_type_arguments = TypeArguments::Handle(zone);
+  TypeArguments& function_type_arguments = TypeArguments::Handle(zone);
   if (!HasInstantiatedSignature(kCurrentClass)) {
-    instantiator = receiver.GetTypeArguments();
+    instantiator_type_arguments = receiver.GetTypeArguments();
   }
-  return Closure::New(instantiator, *this, context);
+  if (!HasInstantiatedSignature(kFunctions)) {
+    function_type_arguments = Object::empty_type_arguments().raw();
+  }
+  return Closure::New(instantiator_type_arguments, function_type_arguments,
+                      *this, context);
 }
 
 
 RawSmi* Function::GetClosureHashCode() const {
   ASSERT(IsClosureFunction());
   const Object& obj = Object::Handle(raw_ptr()->data_);
   ASSERT(!obj.IsNull());
   if (ClosureData::Cast(obj).hash() != Object::null()) {
     return Smi::RawCast(ClosureData::Cast(obj).hash());
   }
@@ skipping 8647 matching lines @@
 RawAbstractType* Instance::GetType(Heap::Space space) const {
   if (IsNull()) {
     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());
+      const TypeArguments& instantiator_type_arguments = TypeArguments::Handle(
+          Closure::Cast(*this).instantiator_type_arguments());
       const TypeArguments& function_type_arguments =
-          TypeArguments::Handle(signature.type_parameters());
-      // TODO(regis): Pass the closure context to InstantiateSignatureFrom().
+          TypeArguments::Handle(Closure::Cast(*this).function_type_arguments());
       // 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()) {
@@ skipping 70 matching lines @@
         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());
-      const TypeArguments& function_type_arguments =
-          TypeArguments::Handle(zone, sig_fun.type_parameters());
-      // TODO(regis): Pass the closure context to InstantiateSignatureFrom().
+      const TypeArguments& instantiator_type_arguments = TypeArguments::Handle(
+          zone, Closure::Cast(*this).instantiator_type_arguments());
+      const TypeArguments& function_type_arguments = TypeArguments::Handle(
+          zone, Closure::Cast(*this).function_type_arguments());
       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
@@ skipping 810 matching lines @@
   // For example, with class A<K, V extends K>, new A<T, T> called from within
   // a class B<T> will never require a run time bound check, even if T is
   // uninstantiated at compile time.
   if (IsTypeParameter()) {
     const TypeParameter& type_param = TypeParameter::Cast(*this);
     if (other.IsTypeParameter()) {
       const TypeParameter& other_type_param = TypeParameter::Cast(other);
       if (type_param.Equals(other_type_param)) {
         return true;
       }
+      // TODO(regis): Should we update TypeParameter::IsEquivalent() instead?
+      if (type_param.IsFunctionTypeParameter() &&
+          other_type_param.IsFunctionTypeParameter() &&
+          type_param.IsFinalized() && other_type_param.IsFinalized() &&
+          (type_param.index() == other_type_param.index())) {
+        return true;
+      }
     }
     const AbstractType& bound = AbstractType::Handle(zone, type_param.bound());
     // We may be checking bounds at finalization time and can encounter
     // a still unfinalized bound. Finalizing the bound here may lead to cycles.
     if (!bound.IsFinalized()) {
       return false;  // TODO(regis): Return "maybe after instantiation".
     }
     // The current bound_trail cannot be used, because operands are swapped and
     // the test is different anyway (more specific vs. subtype).
     if (bound.IsMoreSpecificThan(other, bound_error, NULL, space)) {
@@ skipping 1191 matching lines @@
 
 bool TypeParameter::IsInstantiated(Genericity genericity,
                                    TrailPtr trail) const {
   switch (genericity) {
     case kAny:
       return false;
     case kCurrentClass:
       return IsFunctionTypeParameter();
     case kFunctions:
       return IsClassTypeParameter();
-    case kCurrentFunction:
-      return IsClassTypeParameter() || (parent_level() > 0);
-    case kParentFunctions:
-      return IsClassTypeParameter() || (parent_level() == 0);
     default:
       UNREACHABLE();
   }
   return false;
 }
 
 
 bool TypeParameter::IsEquivalent(const Instance& other, TrailPtr trail) const {
   if (raw() == other.raw()) {
     return true;
   }
   if (other.IsTypeRef()) {
     // Unfold right hand type. Divergence is controlled by left hand type.
     const AbstractType& other_ref_type =
         AbstractType::Handle(TypeRef::Cast(other).type());
     ASSERT(!other_ref_type.IsTypeRef());
     return IsEquivalent(other_ref_type, trail);
   }
   if (!other.IsTypeParameter()) {
     return false;
   }
   const TypeParameter& other_type_param = TypeParameter::Cast(other);
   if (parameterized_class_id() != other_type_param.parameterized_class_id()) {
     return false;
   }
+  // The function doesn't matter in type tests, but it does in canonicalization.
   if (parameterized_function() != other_type_param.parameterized_function()) {
     return false;
   }
   if (IsFinalized() == other_type_param.IsFinalized()) {
-    return (index() == other_type_param.index()) &&
-           (parent_level() == other_type_param.parent_level());
+    return (index() == other_type_param.index());
   }
   return name() == other_type_param.name();
 }
 
 
 void TypeParameter::set_parameterized_class(const Class& value) const {
   // Set value may be null.
   classid_t cid = kFunctionCid;  // Denotes a function type parameter.
   if (!value.IsNull()) {
     cid = value.id();
@@ skipping 41 matching lines @@
 
 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 make the distinction between a null function_type_arguments vector,
+    // which instantiates every function type parameter to dynamic, and a
+    // (possibly empty) function_type_arguments vector of length N, which only
+    // instantiates function type parameters with indices below N.
+    if (function_type_arguments.IsNull()) {
+      return Type::DynamicType();
     }
-    // We need to find the type argument vector of the parent function at
-    // parent_level() in the context.
-    UNIMPLEMENTED();
+    if (index() >= function_type_arguments.Length()) {
+      // Return uninstantiated type parameter unchanged.
+      return raw();
+    }
     return function_type_arguments.TypeAt(index());
   }
   ASSERT(IsClassTypeParameter());
   if (instantiator_type_arguments.IsNull()) {
     return Type::DynamicType();
   }
   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.
+  // Similarly, function type arguments are always instantiated before being
+  // passed to a function at run time and bounds are checked as part of the
+  // signature compatibility check (during call resolution or in the function
+  // prolog).
 }
 
 
 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 53 matching lines @@
 }
 
 
 RawAbstractType* TypeParameter::CloneUnfinalized() const {
   if (IsFinalized()) {
     return raw();
   }
   // No need to clone bound, as it is not part of the finalization state.
   return TypeParameter::New(Class::Handle(parameterized_class()),
                             Function::Handle(parameterized_function()), index(),
-                            parent_level(), String::Handle(name()),
+                            String::Handle(name()),
                             AbstractType::Handle(bound()), token_pos());
 }
 
 
 RawAbstractType* TypeParameter::CloneUninstantiated(const Class& new_owner,
                                                     TrailPtr trail) const {
   ASSERT(IsFinalized());
   TypeParameter& clone = TypeParameter::Handle();
   clone ^= OnlyBuddyInTrail(trail);
   if (!clone.IsNull()) {
     return clone.raw();
   }
   const Class& old_owner = Class::Handle(parameterized_class());
   if (old_owner.IsNull()) {
     ASSERT(IsFunctionTypeParameter());
     // Function type parameters do not need cloning.
     return raw();
   }
   const intptr_t new_index =
       index() + new_owner.NumTypeArguments() - old_owner.NumTypeArguments();
   AbstractType& upper_bound = AbstractType::Handle(bound());
   ASSERT(parameterized_function() == Function::null());
-  clone = TypeParameter::New(new_owner, Function::Handle(), new_index, 0,
+  clone = TypeParameter::New(new_owner, Function::Handle(), new_index,
                              String::Handle(name()),
                              upper_bound,  // Not cloned yet.
                              token_pos());
   clone.SetIsFinalized();
   AddOnlyBuddyToTrail(&trail, clone);
   upper_bound = upper_bound.CloneUninstantiated(new_owner, trail);
   clone.set_bound(upper_bound);
   return clone.raw();
 }
 
 
 RawString* TypeParameter::EnumerateURIs() const {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   GrowableHandlePtrArray<const String> pieces(zone, 4);
   pieces.Add(Symbols::TwoSpaces());
   pieces.Add(String::Handle(zone, name()));
-  pieces.Add(Symbols::SpaceOfSpace());
-  const Class& cls = Class::Handle(zone, parameterized_class());
-  pieces.Add(String::Handle(zone, cls.UserVisibleName()));
-  pieces.Add(Symbols::SpaceIsFromSpace());
-  const Library& library = Library::Handle(zone, cls.library());
-  pieces.Add(String::Handle(zone, library.url()));
+  Class& cls = Class::Handle(zone, parameterized_class());
+  if (cls.IsNull()) {
+    const Function& fun = Function::Handle(zone, parameterized_function());
+    pieces.Add(Symbols::SpaceOfSpace());
+    pieces.Add(String::Handle(zone, fun.UserVisibleName()));
+    cls = fun.Owner();  // May be null.
+    // TODO(regis): Should we keep the function owner for better error messages?
+  }
+  if (!cls.IsNull()) {
+    pieces.Add(Symbols::SpaceOfSpace());
+    pieces.Add(String::Handle(zone, cls.UserVisibleName()));
+    pieces.Add(Symbols::SpaceIsFromSpace());
+    const Library& library = Library::Handle(zone, cls.library());
+    pieces.Add(String::Handle(zone, library.url()));
+  }
   pieces.Add(Symbols::NewLine());
   return Symbols::FromConcatAll(thread, pieces);
 }
 
 
 intptr_t TypeParameter::ComputeHash() const {
   ASSERT(IsFinalized());
   uint32_t result;
   if (IsClassTypeParameter()) {
     result = parameterized_class_id();
   } else {
     result = Function::Handle(parameterized_function()).Hash();
-    result = CombineHashes(result, parent_level());
   }
   // No need to include the hash of the bound, since the type parameter is fully
   // identified by its class and index.
   result = CombineHashes(result, index());
   result = FinalizeHash(result, kHashBits);
   SetHash(result);
   return result;
 }
 
 
 RawTypeParameter* TypeParameter::New() {
   RawObject* raw = Object::Allocate(TypeParameter::kClassId,
                                     TypeParameter::InstanceSize(), Heap::kOld);
   return reinterpret_cast<RawTypeParameter*>(raw);
 }
 
 
 RawTypeParameter* TypeParameter::New(const Class& parameterized_class,
                                      const Function& parameterized_function,
                                      intptr_t index,
-                                     intptr_t parent_level,
                                      const String& name,
                                      const AbstractType& bound,
                                      TokenPosition token_pos) {
   ASSERT(parameterized_class.IsNull() != parameterized_function.IsNull());
   const TypeParameter& result = TypeParameter::Handle(TypeParameter::New());
   result.set_parameterized_class(parameterized_class);
   result.set_parameterized_function(parameterized_function);
   result.set_index(index);
-  result.set_parent_level(parent_level);
   result.set_name(name);
   result.set_bound(bound);
   result.SetHash(0);
   result.set_token_pos(token_pos);
   result.StoreNonPointer(&result.raw_ptr()->type_state_,
                          RawTypeParameter::kAllocated);
   return result.raw();
 }
 
 
 void TypeParameter::set_token_pos(TokenPosition token_pos) const {
   ASSERT(!token_pos.IsClassifying());
   StoreNonPointer(&raw_ptr()->token_pos_, token_pos);
 }
 
 
-void TypeParameter::set_parent_level(intptr_t value) const {
-  // TODO(regis): Report error in caller if not uint8.
-  ASSERT(Utils::IsUint(8, value));
-  StoreNonPointer(&raw_ptr()->parent_level_, value);
-}
-
-
 void TypeParameter::set_type_state(int8_t state) const {
   ASSERT((state == RawTypeParameter::kAllocated) ||
          (state == RawTypeParameter::kBeingFinalized) ||
          (state == RawTypeParameter::kFinalizedUninstantiated));
   StoreNonPointer(&raw_ptr()->type_state_, state);
 }
 
 
 const char* TypeParameter::ToCString() const {
   const char* name_cstr = String::Handle(Name()).ToCString();
   const AbstractType& upper_bound = AbstractType::Handle(bound());
   const char* bound_cstr = String::Handle(upper_bound.Name()).ToCString();
   if (IsFunctionTypeParameter()) {
     const char* format =
-        "TypeParameter: name %s; index: %d; parent_level: %d, "
-        "function: %s; bound: %s";
+        "TypeParameter: name %s; index: %d; function: %s; bound: %s";
     const Function& function = Function::Handle(parameterized_function());
     const char* fun_cstr = String::Handle(function.name()).ToCString();
-    intptr_t len = OS::SNPrint(NULL, 0, format, name_cstr, index(),
-                               parent_level(), fun_cstr, bound_cstr) +
-                   1;
+    intptr_t len =
+        OS::SNPrint(NULL, 0, format, name_cstr, index(), fun_cstr, bound_cstr) +
+        1;
     char* chars = Thread::Current()->zone()->Alloc<char>(len);
-    OS::SNPrint(chars, len, format, name_cstr, index(), parent_level(),
-                fun_cstr, bound_cstr);
+    OS::SNPrint(chars, len, format, name_cstr, index(), fun_cstr, bound_cstr);
     return chars;
   } else {
     const char* format =
         "TypeParameter: name %s; index: %d; class: %s; bound: %s";
     const Class& cls = Class::Handle(parameterized_class());
     const char* cls_cstr =
         cls.IsNull() ? " null" : String::Handle(cls.Name()).ToCString();
     intptr_t len =
         OS::SNPrint(NULL, 0, format, name_cstr, index(), cls_cstr, bound_cstr) +
         1;
@@ skipping 4380 matching lines @@
   const Function& fun = Function::Handle(function());
   const bool is_implicit_closure = fun.IsImplicitClosureFunction();
   const char* fun_sig = String::Handle(fun.UserVisibleSignature()).ToCString();
   const char* from = is_implicit_closure ? " from " : "";
   const char* fun_desc = is_implicit_closure ? fun.ToCString() : "";
   return OS::SCreate(Thread::Current()->zone(), "Closure: %s%s%s", fun_sig,
                      from, fun_desc);
 }
 
 
-RawClosure* Closure::New(const TypeArguments& instantiator,
+RawClosure* Closure::New(const TypeArguments& instantiator_type_arguments,
+                         const TypeArguments& function_type_arguments,
                          const Function& function,
                          const Context& context,
                          Heap::Space space) {
   Closure& result = Closure::Handle();
   {
     RawObject* raw =
         Object::Allocate(Closure::kClassId, Closure::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
-    result.StorePointer(&result.raw_ptr()->instantiator_, instantiator.raw());
+    result.StorePointer(&result.raw_ptr()->instantiator_type_arguments_,
+                        instantiator_type_arguments.raw());
+    result.StorePointer(&result.raw_ptr()->function_type_arguments_,
+                        function_type_arguments.raw());
     result.StorePointer(&result.raw_ptr()->function_, function.raw());
     result.StorePointer(&result.raw_ptr()->context_, context.raw());
   }
   return result.raw();
 }
 
 
 RawClosure* Closure::New() {
   RawObject* raw =
       Object::Allocate(Closure::kClassId, Closure::InstanceSize(), Heap::kOld);
@@ skipping 595 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart