Resubmit fix for Function::Clone() and Field::Clone() to adjust the class owner

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/cpu.h"
@@ skipping 4937 matching lines @@
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     type = type.CloneUnfinalized();
     clone.SetTypeAt(i, type);
   }
   ASSERT(clone.IsResolved());
   return clone.raw();
 }
 
 
+RawTypeArguments* TypeArguments::CloneUninstantiated(
+    const Class& new_owner) const {
+  ASSERT(!IsNull());
+  ASSERT(IsFinalized());
+  ASSERT(!IsInstantiated());
+  AbstractType& type = AbstractType::Handle();
+  const intptr_t num_types = Length();
+  const TypeArguments& clone = TypeArguments::Handle(
+      TypeArguments::New(num_types));
+  for (intptr_t i = 0; i < num_types; i++) {
+    type = TypeAt(i);
+    if (!type.IsInstantiated()) {
+      type = type.CloneUninstantiated(new_owner);
+    }
+    clone.SetTypeAt(i, type);
+  }
+  ASSERT(clone.IsFinalized());
+  return clone.raw();
+}
+
+
 RawTypeArguments* TypeArguments::Canonicalize(
     GrowableObjectArray* trail) const {
   if (IsNull() || IsCanonical()) {
     ASSERT(IsOld());
     return this->raw();
   }
   const intptr_t num_types = Length();
   if (IsRaw(0, num_types)) {
     return TypeArguments::null();
   }
@@ skipping 1180 matching lines @@
   const Class& origin = Class::Handle(this->origin());
   const PatchClass& clone_owner =
       PatchClass::Handle(PatchClass::New(new_owner, origin));
   clone.set_owner(clone_owner);
   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_ic_data_array(Array::Handle());
+  if (new_owner.NumTypeParameters() > 0) {
+    // Adjust uninstantiated types to refer to type parameters of the new owner.
+    AbstractType& type = AbstractType::Handle(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 ^= 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();
 }
 
 
 RawFunction* Function::NewClosureFunction(const String& name,
                                           const Function& parent,
                                           intptr_t token_pos) {
   ASSERT(!parent.IsNull());
   // Use the owner defining the parent function and not the class containing it.
   const Object& parent_owner = Object::Handle(parent.raw_ptr()->owner_);
@@ skipping 852 matching lines @@
   Field& clone = Field::Handle();
   clone ^= Object::Clone(*this, Heap::kOld);
   const Class& owner = Class::Handle(this->owner());
   const PatchClass& clone_owner =
       PatchClass::Handle(PatchClass::New(new_owner, owner));
   clone.set_owner(clone_owner);
   clone.set_dependent_code(Object::null_array());
   if (!clone.is_static()) {
     clone.SetOffset(0);
   }
+  if (new_owner.NumTypeParameters() > 0) {
+    // Adjust the field type to refer to type parameters of the new owner.
+    AbstractType& type = AbstractType::Handle(clone.type());
+    type ^= type.CloneUninstantiated(new_owner);
+    clone.set_type(type);
+  }
   return clone.raw();
 }
 
 
 RawString* Field::PrettyName() const {
   const String& str = String::Handle(name());
   return String::IdentifierPrettyName(str);
 }
 
 
@@ skipping 6776 matching lines @@
 }
 
 
 RawAbstractType* AbstractType::CloneUnfinalized() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
+RawAbstractType* AbstractType::CloneUninstantiated(
+    const Class& new_owner) const {
+  // AbstractType is an abstract class.
+  UNREACHABLE();
+  return NULL;
+}
+
+
 RawAbstractType* AbstractType::Canonicalize(GrowableObjectArray* trail) const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
 RawObject* AbstractType::OnlyBuddyInTrail(GrowableObjectArray* trail) const {
   if (trail == NULL) {
     return Object::null();
@@ skipping 679 matching lines @@
 RawAbstractType* Type::CloneUnfinalized() const {
   ASSERT(IsResolved());
   if (IsFinalized()) {
     return raw();
   }
   ASSERT(!IsMalformed());  // Malformed types are finalized.
   ASSERT(!IsBeingFinalized());  // Cloning must occur prior to finalization.
   TypeArguments& type_args = TypeArguments::Handle(arguments());
   type_args = type_args.CloneUnfinalized();
   const Class& type_cls = Class::Handle(type_class());
-  const Type& type = Type::Handle(Type::New(type_cls, type_args, token_pos()));
-  type.set_is_resolved();
-  return type.raw();
+  const Type& clone = Type::Handle(Type::New(type_cls, type_args, token_pos()));
+  clone.set_is_resolved();
+  return clone.raw();
+}
+
+
+RawAbstractType* Type::CloneUninstantiated(const Class& new_owner) const {
+  ASSERT(IsFinalized());
+  ASSERT(!IsMalformed());
+  if (IsInstantiated()) {
+    return raw();
+  }
+  TypeArguments& type_args = TypeArguments::Handle(arguments());
+  type_args = type_args.CloneUninstantiated(new_owner);
+  const Class& type_cls = Class::Handle(type_class());
+  const Type& clone = Type::Handle(Type::New(type_cls, type_args, token_pos()));
+  clone.SetIsFinalized();
+  return clone.raw();
 }
 
 
 RawAbstractType* Type::Canonicalize(GrowableObjectArray* trail) const {
   ASSERT(IsFinalized());
   if (IsCanonical() || IsMalformed()) {
     ASSERT(IsMalformed() || TypeArguments::Handle(arguments()).IsOld());
     return this->raw();
   }
   Isolate* isolate = Isolate::Current();
@@ skipping 519 matching lines @@
   }
   // No need to clone bound, as it is not part of the finalization state.
   return TypeParameter::New(Class::Handle(parameterized_class()),
                             index(),
                             String::Handle(name()),
                             AbstractType::Handle(bound()),
                             token_pos());
 }
 
 
+RawAbstractType* TypeParameter::CloneUninstantiated(
+    const Class& new_owner) const {
+  ASSERT(IsFinalized());
+  AbstractType& upper_bound = AbstractType::Handle(bound());
+  upper_bound = upper_bound.CloneUninstantiated(new_owner);
+  const Class& old_owner = Class::Handle(parameterized_class());
+  const intptr_t new_index = index() +
+      new_owner.NumTypeArguments() - old_owner.NumTypeArguments();
+  const TypeParameter& clone = TypeParameter::Handle(
+      TypeParameter::New(new_owner,
+                         new_index,
+                         String::Handle(name()),
+                         upper_bound,
+                         token_pos()));
+  clone.set_is_finalized();
+  return clone.raw();
+}
+
+
 intptr_t TypeParameter::Hash() const {
   ASSERT(IsFinalized());
   uint32_t result = Class::Handle(parameterized_class()).id();
   // 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());
   return FinalizeHash(result);
 }
 
 
@@ skipping 200 matching lines @@
 
   bounded_type = bounded_type.CloneUnfinalized();
   // No need to clone bound or type parameter, as they are not part of the
   // finalization state of this bounded type.
   return BoundedType::New(bounded_type,
                           AbstractType::Handle(bound()),
                           TypeParameter::Handle(type_parameter()));
 }
 
 
+RawAbstractType* BoundedType::CloneUninstantiated(
+    const Class& new_owner) const {
+  if (IsInstantiated()) {
+    return raw();
+  }
+  AbstractType& bounded_type = AbstractType::Handle(type());
+  bounded_type = bounded_type.CloneUninstantiated(new_owner);
+  AbstractType& upper_bound = AbstractType::Handle(bound());
+  upper_bound = upper_bound.CloneUninstantiated(new_owner);
+  TypeParameter& type_param =  TypeParameter::Handle(type_parameter());
+  type_param ^= type_param.CloneUninstantiated(new_owner);
+  return BoundedType::New(bounded_type, upper_bound, type_param);
+}
+
+
 intptr_t BoundedType::Hash() const {
   uint32_t result = AbstractType::Handle(type()).Hash();
   // No need to include the hash of the bound, since the bound is defined by the
   // type parameter (modulo instantiation state).
   result = CombineHashes(result,
                          TypeParameter::Handle(type_parameter()).Hash());
   return FinalizeHash(result);
 }
 
 
@@ skipping 5006 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart