Process generic function type arguments in more places (function type tests,

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 34 matching lines @@
 #include "vm/thread_registry.h"
 #include "vm/timeline.h"
 #include "vm/timer.h"
 #include "vm/type_table.h"
 #include "vm/unicode.h"
 #include "vm/weak_code.h"
 #include "vm/zone_text_buffer.h"
 
 namespace dart {
 
+DEFINE_FLAG(bool,

[zra, 2017/04/20 19:22:09]

Should we put this in flag_list.h?

[regis, 2017/04/20 20:23:30]

Done.

+            reify_generic_functions,
+            false,
+            "Enable reification of generic functions (not yet supported).");
 DEFINE_FLAG(int,
             huge_method_cutoff_in_code_size,
             200000,
             "Huge method cutoff in unoptimized code size (in bytes).");
 DEFINE_FLAG(
     bool,
     overlap_type_arguments,
     true,
     "When possible, partially or fully overlap the type arguments of a type "
     "with the type arguments of its super type.");
@@ skipping 6360 matching lines @@
   return chars;
 }
 
 
 bool Function::HasCompatibleParametersWith(const Function& other,
                                            Error* bound_error) const {
   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.
+  // Map type parameters referred to by formal parameter types and result type
+  // in the signature to dynamic before the test.
+  // Note that type parameters declared by a generic signature are preserved.
   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(), 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,
@@ skipping 19 matching lines @@
 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());
   ASSERT(!HasInstantiatedSignature());
   Function& sig = Function::Handle(
       zone,
       Function::NewSignatureFunction(owner, TokenPosition::kNoSource, space));
-  // TODO(regis): If type parameter bounds are not IsInstantiated(kFunctions),
-  // clone finalized type parameters and instantiate bounds.
   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,
                              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());
@@ skipping 71 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.
-
+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
+  if (FLAG_reify_generic_functions) {
+    // Check the type parameters and bounds of a generic function.
+    const intptr_t num_type_params = NumTypeParameters(thread);
+    if (num_type_params != other.NumTypeParameters(thread)) {
+      return false;
+    }
+    if (num_type_params > 0) {
+      const TypeArguments& type_params =
+          TypeArguments::Handle(zone, type_parameters());
+      ASSERT(!type_params.IsNull());
+      const TypeArguments& other_type_params =
+          TypeArguments::Handle(zone, other.type_parameters());
+      ASSERT(!other_type_params.IsNull());
+      TypeParameter& type_param = TypeParameter::Handle(zone);
+      TypeParameter& other_type_param = TypeParameter::Handle(zone);
+      AbstractType& bound = AbstractType::Handle(zone);
+      AbstractType& other_bound = AbstractType::Handle(zone);
+      for (intptr_t i = 0; i < num_type_params; i++) {
+        type_param ^= type_params.TypeAt(i);
+        other_type_param ^= other_type_params.TypeAt(i);
+        bound = type_param.bound();
+        other_bound = other_type_param.bound();

[siva, 2017/04/20 20:32:08]

Should we assert here that the two types are finalized? I am wondering about the
recursive case...

[regis, 2017/04/20 21:18:26]

The Equals call should do the right thing in case one or the other type are not
finalized. However, we are performing a type test here, which assumes that types
are finalized. So you are right, it is better to detect a problem early. I added
asserts.

+        if (!bound.Equals(other_bound)) {
+          return false;
+        }
+      }
+    }
+  }
   // Check the result type.
   const AbstractType& other_res_type =
-      AbstractType::Handle(other.result_type());
+      AbstractType::Handle(zone, other.result_type());
   if (!other_res_type.IsDynamicType() && !other_res_type.IsVoidType()) {
-    const AbstractType& res_type = AbstractType::Handle(result_type());
+    const AbstractType& res_type = AbstractType::Handle(zone, result_type());
     if (res_type.IsVoidType()) {
       return false;
     }
     if (test_kind == kIsSubtypeOf) {
       if (!res_type.IsSubtypeOf(other_res_type, bound_error, NULL, space) &&
           !other_res_type.IsSubtypeOf(res_type, bound_error, NULL, space)) {
         return false;
       }
     } else {
       ASSERT(test_kind == kIsMoreSpecificThan);
@@ skipping 21 matching lines @@
   // function type, there exists an optional named parameter of this function
   // type with an identical name and with a type S that is a either a subtype
   // or supertype of T (if test_kind == kIsSubtypeOf) or that is more specific
   // than T (if test_kind == kIsMoreSpecificThan).
   // Note that SetParameterNameAt() guarantees that names are symbols, so we
   // can compare their raw pointers.
   const int num_params = num_fixed_params + num_opt_named_params;
   const int other_num_params =
       other_num_fixed_params + other_num_opt_named_params;
   bool found_param_name;
-  String& other_param_name = String::Handle();
+  String& other_param_name = String::Handle(zone);
   for (intptr_t i = other_num_fixed_params; i < other_num_params; i++) {
     other_param_name = other.ParameterNameAt(i);
     ASSERT(other_param_name.IsSymbol());
     found_param_name = false;
     for (intptr_t j = num_fixed_params; j < num_params; j++) {
-      ASSERT(String::Handle(ParameterNameAt(j)).IsSymbol());
+      ASSERT(String::Handle(zone, ParameterNameAt(j)).IsSymbol());
       if (ParameterNameAt(j) == other_param_name.raw()) {
         found_param_name = true;
         if (!TestParameterType(test_kind, j, i, other, bound_error, space)) {
           return false;
         }
         break;
       }
     }
     if (!found_param_name) {
       return false;
@@ skipping 109 matching lines @@
     // Functions other than signature functions have no reason to be allocated
     // in new space.
     ASSERT(space == Heap::kOld);
   }
   return result.raw();
 }
 
 
 RawFunction* Function::Clone(const Class& new_owner) const {
   ASSERT(!IsGenerativeConstructor());
-  Function& clone = Function::Handle();
+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
+  Function& clone = Function::Handle(zone);
   clone ^= Object::Clone(*this, Heap::kOld);
-  const Class& origin = Class::Handle(this->origin());
+  const Class& origin = Class::Handle(zone, this->origin());
   const PatchClass& clone_owner =
-      PatchClass::Handle(PatchClass::New(new_owner, origin));
+      PatchClass::Handle(zone, PatchClass::New(new_owner, origin));
   clone.set_owner(clone_owner);
   clone.ClearICDataArray();
   clone.ClearCode();
   clone.set_usage_counter(0);
   clone.set_deoptimization_counter(0);
   clone.set_optimized_instruction_count(0);
   clone.set_optimized_call_site_count(0);
   clone.set_kernel_function(kernel_function());
-  // TODO(regis): Clone function type parameters (their bounds may change).
   if (new_owner.NumTypeParameters() > 0) {
     // Adjust uninstantiated types to refer to type parameters of the new owner.
-    AbstractType& type = AbstractType::Handle(clone.result_type());
+    const TypeArguments& type_params =
+        TypeArguments::Handle(zone, type_parameters());
+    if (!type_params.IsNull()) {
+      const intptr_t num_type_params = type_params.Length();
+      const TypeArguments& type_params_clone =
+          TypeArguments::Handle(zone, TypeArguments::New(num_type_params));
+      TypeParameter& type_param = TypeParameter::Handle(zone);
+      for (intptr_t i = 0; i < num_type_params; i++) {
+        type_param ^= type_params.TypeAt(i);
+        type_param ^= type_param.CloneUninstantiated(new_owner);
+        type_params_clone.SetTypeAt(i, type_param);
+      }
+      clone.set_type_parameters(type_params_clone);
+    }
+    AbstractType& type = AbstractType::Handle(zone, clone.result_type());
     type ^= type.CloneUninstantiated(new_owner);
     clone.set_result_type(type);
     const intptr_t num_params = clone.NumParameters();
-    Array& array = Array::Handle(clone.parameter_types());
+    Array& array = Array::Handle(zone, clone.parameter_types());
     array ^= Object::Clone(array, Heap::kOld);
     clone.set_parameter_types(array);
     for (intptr_t i = 0; i < num_params; i++) {
       type = clone.ParameterTypeAt(i);
       type ^= type.CloneUninstantiated(new_owner);
       clone.SetParameterTypeAt(i, type);
     }
   }
   return clone.raw();
 }
@@ skipping 57 matching lines @@
   return result.raw();
 }
 
 RawFunction* Function::ImplicitClosureFunction() const {
   // Return the existing implicit closure function if any.
   if (implicit_closure_function() != Function::null()) {
     return implicit_closure_function();
   }
   ASSERT(!IsSignatureFunction() && !IsClosureFunction());
   // Create closure function.
   const String& closure_name = String::Handle(name());

[zra, 2017/04/20 19:22:09]

Maybe grab the Zone ahead of time for this function as well.

[regis, 2017/04/20 20:23:30]

Done.

   const Function& closure_function =
       Function::Handle(NewClosureFunction(closure_name, *this, token_pos()));
 
   // Set closure function's context scope.
   if (is_static()) {
     closure_function.set_context_scope(Object::empty_context_scope());
   } else {
     const ContextScope& context_scope =
         ContextScope::Handle(LocalScope::CreateImplicitClosureScope(*this));
     closure_function.set_context_scope(context_scope);
   }
 
+  // Set closure function's type parameters.
+  closure_function.set_type_parameters(
+      TypeArguments::Handle(type_parameters()));
+
   // Set closure function's result type to this result type.
   closure_function.set_result_type(AbstractType::Handle(result_type()));
 
   // Set closure function's end token to this end token.
   closure_function.set_end_token_pos(end_token_pos());
 
   // The closurized method stub just calls into the original method and should
   // therefore be skipped by the debugger and in stack traces.
   closure_function.set_is_debuggable(false);
   closure_function.set_is_visible(false);
@@ skipping 172 matching lines @@
   result &= ((static_cast<intptr_t>(1) << String::kHashBits) - 1);
   ClosureData::Cast(obj).set_hash(result);
   return Smi::New(result);
 }
 
 
 RawString* Function::BuildSignature(NameVisibility name_visibility) const {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   GrowableHandlePtrArray<const String> pieces(zone, 4);
+  String& name = String::Handle(zone);
+  if (FLAG_reify_generic_functions) {
+    const TypeArguments& type_params =
+        TypeArguments::Handle(zone, type_parameters());
+    if (!type_params.IsNull()) {
+      const intptr_t num_type_params = type_params.Length();
+      TypeParameter& type_param = TypeParameter::Handle(zone);
+      AbstractType& bound = AbstractType::Handle(zone);
+      pieces.Add(Symbols::LAngleBracket());
+      for (intptr_t i = 0; i < num_type_params; i++) {
+        type_param ^= type_params.TypeAt(i);
+        name = type_param.name();
+        pieces.Add(name);
+        bound = type_param.bound();
+        if (!bound.IsNull() && !bound.IsObjectType()) {
+          pieces.Add(Symbols::SpaceExtendsSpace());
+          name = bound.BuildName(name_visibility);
+          pieces.Add(name);
+        }
+        if (i < num_type_params - 1) {
+          pieces.Add(Symbols::CommaSpace());
+        }
+      }
+      pieces.Add(Symbols::RAngleBracket());

[siva, 2017/04/20 20:32:08]

Do we still want '<>' if num_type_params is 0? or maybe we just need to assert
above that num_type_params is not 0 as !type_params.IsNull() means we should
have at least one type parameter.

[regis, 2017/04/20 21:18:26]

Yes, we should never see an empty array. I added an assert.

+    }
+  }
   pieces.Add(Symbols::LParen());
   BuildSignatureParameters(thread, zone, name_visibility, &pieces);
   pieces.Add(Symbols::RParenArrow());
   const AbstractType& res_type = AbstractType::Handle(zone, result_type());
-  const String& name =
-      String::Handle(zone, res_type.BuildName(name_visibility));
+  name = res_type.BuildName(name_visibility);
   pieces.Add(name);
   return Symbols::FromConcatAll(thread, pieces);
 }
 
 
 bool Function::HasInstantiatedSignature(Genericity genericity,
                                         TrailPtr trail) const {
   AbstractType& type = AbstractType::Handle(result_type());
   if (!type.IsInstantiated(genericity, trail)) {
     return false;
@@ skipping 8723 matching lines @@
     // 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()) {
         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, 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;
       }
     }
@@ skipping 1288 matching lines @@
   ASSERT(Type::Cast(other).IsFunctionType());
   // Equal function types must have equal signature types and equal optional
   // named arguments.
   if (signature() == other_type.signature()) {
     return true;
   }
   const Function& sig_fun = Function::Handle(zone, signature());
   const Function& other_sig_fun =
       Function::Handle(zone, other_type.signature());
 
+  if (FLAG_reify_generic_functions) {
+    // Compare function type parameters and their bounds.
+    const intptr_t num_type_params = sig_fun.NumTypeParameters(thread);
+    if (num_type_params != other_sig_fun.NumTypeParameters(thread)) {
+      return false;
+    }
+    if (num_type_params > 0) {
+      const TypeArguments& type_params =
+          TypeArguments::Handle(zone, sig_fun.type_parameters());
+      ASSERT(!type_params.IsNull());
+      const TypeArguments& other_type_params =
+          TypeArguments::Handle(zone, other_sig_fun.type_parameters());
+      ASSERT(!other_type_params.IsNull());
+      TypeParameter& type_param = TypeParameter::Handle(zone);
+      TypeParameter& other_type_param = TypeParameter::Handle(zone);
+      AbstractType& bound = AbstractType::Handle(zone);
+      AbstractType& other_bound = AbstractType::Handle(zone);
+      for (intptr_t i = 0; i < num_type_params; i++) {
+        type_param ^= type_params.TypeAt(i);
+        other_type_param ^= other_type_params.TypeAt(i);
+        bound = type_param.bound();
+        other_bound = other_type_param.bound();
+        if (!bound.Equals(other_bound)) {
+          return false;
+        }
+      }
+    }

[siva, 2017/04/20 20:32:08]

This code here is very similar to the one in Function::TypeTest maybe extract
this into a helper function?

[regis, 2017/04/20 21:18:26]

That was bugging me too, and then I forgot :-)
I added a Function::HasSameTypeParametersAndBounds(other).

+  }
+
   // Compare number of function parameters.
   const intptr_t num_fixed_params = sig_fun.num_fixed_parameters();
   const intptr_t other_num_fixed_params = other_sig_fun.num_fixed_parameters();
   if (num_fixed_params != other_num_fixed_params) {
     return false;
   }
   const intptr_t num_opt_pos_params = sig_fun.NumOptionalPositionalParameters();
   const intptr_t other_num_opt_pos_params =
       other_sig_fun.NumOptionalPositionalParameters();
   if (num_opt_pos_params != other_num_opt_pos_params) {
@@ skipping 68 matching lines @@
   if (IsMalbounded()) {
     const LanguageError& bound_error = LanguageError::Handle(zone, error());
     clone.set_error(bound_error);
   }
   // Clone the signature if this type represents a function type.
   Function& fun = Function::Handle(zone, signature());
   if (!fun.IsNull()) {
     const Class& owner = Class::Handle(zone, fun.Owner());
     Function& fun_clone = Function::Handle(
         zone, Function::NewSignatureFunction(owner, TokenPosition::kNoSource));
-    // TODO(regis): Handle cloning of a generic function type.
+    const TypeArguments& type_params =
+        TypeArguments::Handle(zone, fun.type_parameters());
+    if (!type_params.IsNull()) {
+      const intptr_t num_type_params = type_params.Length();
+      const TypeArguments& type_params_clone =
+          TypeArguments::Handle(zone, TypeArguments::New(num_type_params));
+      TypeParameter& type_param = TypeParameter::Handle(zone);
+      for (intptr_t i = 0; i < num_type_params; i++) {
+        type_param ^= type_params.TypeAt(i);
+        type_param ^= type_param.CloneUnfinalized();
+        type_params_clone.SetTypeAt(i, type_param);
+      }
+      fun_clone.set_type_parameters(type_params_clone);
+    }

[siva, 2017/04/20 20:32:08]

ditto comment about this matching up with the one in Function::Clone and the
chunk below.

[regis, 2017/04/20 21:18:25]

This one cannot easily be factored out. One is calling CloneUnfinalized() and
the other one CloneUninstantiated(new_owner, trail).
This is not worth it.

     AbstractType& type = AbstractType::Handle(zone, fun.result_type());
     type = type.CloneUnfinalized();
     fun_clone.set_result_type(type);
     const intptr_t num_params = fun.NumParameters();
     fun_clone.set_num_fixed_parameters(fun.num_fixed_parameters());
     fun_clone.SetNumOptionalParameters(fun.NumOptionalParameters(),
                                        fun.HasOptionalPositionalParameters());
     fun_clone.set_parameter_types(
         Array::Handle(Array::New(num_params, Heap::kOld)));
     for (intptr_t i = 0; i < num_params; i++) {
@@ skipping 35 matching lines @@
   }
   // Clone the signature if this type represents a function type.
   const Function& fun = Function::Handle(zone, signature());
   if (!fun.IsNull()) {
     ASSERT(type_cls.IsTypedefClass() || type_cls.IsClosureClass());
     // If the scope class is not a typedef and if it is generic, it must be the
     // mixin class, set it to the new owner.
     Function& fun_clone = Function::Handle(
         zone,
         Function::NewSignatureFunction(new_owner, TokenPosition::kNoSource));
+    const TypeArguments& type_params =
+        TypeArguments::Handle(zone, fun.type_parameters());
+    if (!type_params.IsNull()) {
+      const intptr_t num_type_params = type_params.Length();
+      const TypeArguments& type_params_clone =
+          TypeArguments::Handle(zone, TypeArguments::New(num_type_params));
+      TypeParameter& type_param = TypeParameter::Handle(zone);
+      for (intptr_t i = 0; i < num_type_params; i++) {
+        type_param ^= type_params.TypeAt(i);
+        type_param ^= type_param.CloneUninstantiated(new_owner, trail);
+        type_params_clone.SetTypeAt(i, type_param);
+      }
+      fun_clone.set_type_parameters(type_params_clone);
+    }
     AbstractType& type = AbstractType::Handle(zone, fun.result_type());
     type = type.CloneUninstantiated(new_owner, trail);
     fun_clone.set_result_type(type);
     const intptr_t num_params = fun.NumParameters();
     fun_clone.set_num_fixed_parameters(fun.num_fixed_parameters());
     fun_clone.SetNumOptionalParameters(fun.NumOptionalParameters(),
                                        fun.HasOptionalPositionalParameters());
     fun_clone.set_parameter_types(
         Array::Handle(Array::New(num_params, Heap::kOld)));
     for (intptr_t i = 0; i < num_params; i++) {
@@ skipping 106 matching lines @@
     ASSERT(type_args.IsNull() || type_args.IsOld());
 
     // In case of a function type, replace the actual function by a signature
     // function.
     if (IsFunctionType()) {
       const Function& fun = Function::Handle(zone, signature());
       if (!fun.IsSignatureFunction()) {
         Function& sig_fun = Function::Handle(
             zone,
             Function::NewSignatureFunction(cls, TokenPosition::kNoSource));
+        sig_fun.set_type_parameters(
+            TypeArguments::Handle(zone, fun.type_parameters()));
         type = fun.result_type();
         type = type.Canonicalize(trail);
         sig_fun.set_result_type(type);
         const intptr_t num_params = fun.NumParameters();
         sig_fun.set_num_fixed_parameters(fun.num_fixed_parameters());
         sig_fun.SetNumOptionalParameters(fun.NumOptionalParameters(),
                                          fun.HasOptionalPositionalParameters());
         sig_fun.set_parameter_types(
             Array::Handle(Array::New(num_params, Heap::kOld)));
         for (intptr_t i = 0; i < num_params; i++) {
@@ skipping 607 matching lines @@
   return TypeParameter::New(Class::Handle(parameterized_class()),
                             Function::Handle(parameterized_function()), index(),
                             String::Handle(name()),
                             AbstractType::Handle(bound()), token_pos());
 }
 
 
 RawAbstractType* TypeParameter::CloneUninstantiated(const Class& new_owner,
                                                     TrailPtr trail) const {
   ASSERT(IsFinalized());
   TypeParameter& clone = TypeParameter::Handle();

[zra, 2017/04/20 19:22:09]

ditto

[regis, 2017/04/20 20:23:30]

Done.

   clone ^= OnlyBuddyInTrail(trail);
   if (!clone.IsNull()) {
     return clone.raw();
   }
-  const Class& old_owner = Class::Handle(parameterized_class());
-  if (old_owner.IsNull()) {
+  intptr_t new_index = index();
+  AbstractType& upper_bound = AbstractType::Handle(bound());
+  const Function& fun = Function::Handle(parameterized_function());
+  Class& cls = Class::Handle(parameterized_class());
+  if (!cls.IsNull()) {
+    ASSERT(fun.IsNull());
+    new_index += new_owner.NumTypeArguments() - cls.NumTypeArguments();
+    cls = new_owner.raw();
+  } else {
     ASSERT(IsFunctionTypeParameter());
-    // Function type parameters do not need cloning.
-    return raw();
+    // Only the bounds of function type parameters need cloning.
   }
-  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,
-                             String::Handle(name()),
+  clone = TypeParameter::New(cls, fun, 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();
 }
 
 
@@ skipping 5118 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart