Do not share type arguments of mixin types, but clone them to avoid finalization

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 1691 matching lines @@
   const TypeArguments& type_params = TypeArguments::Handle(type_parameters());
   return type_params.Length();
 }
 
 
 intptr_t Class::NumTypeArguments() const {
   // To work properly, this call requires the super class of this class to be
   // resolved, which is checked by the type_class() call on the super type.
   // Note that calling type_class() on a MixinAppType fails.
   Isolate* isolate = Isolate::Current();
-  ReusableHandleScope reused_handles(isolate);
-  Class& cls = reused_handles.ClassHandle();
-  TypeArguments& type_params = reused_handles.TypeArgumentsHandle();
-  AbstractType& sup_type = reused_handles.AbstractTypeHandle();
+  Class& cls = Class::Handle(isolate);

[Ivan Posva, 2013/10/01 18:50:04]

Why was this changed?

[regis, 2013/10/01 19:11:58]

We were just lucky before. NumTypeArguments() is reentrant.

+  TypeArguments& type_params = TypeArguments::Handle(isolate);
+  AbstractType& sup_type = AbstractType::Handle(isolate);
   cls ^= raw();
   intptr_t num_type_args = 0;
 
   do {
     if (cls.IsSignatureClass()) {
-      Function& signature_fun = reused_handles.FunctionHandle();
+      Function& signature_fun = Function::Handle(isolate);
       signature_fun ^= cls.signature_function();
       if (!signature_fun.is_static() &&
           !signature_fun.HasInstantiatedSignature()) {
         cls = signature_fun.Owner();
       }
     }
     // Calling NumTypeParameters() on a mixin application class will setup the
     // type parameters if not already done.
     if (cls.NumTypeParameters() > 0) {
       type_params ^= cls.type_parameters();
@@ skipping 1690 matching lines @@
     type_arg = TypeAt(i);
     super_type_arg = super_type_args.TypeAt(i);
     if (!type_arg.Equals(super_type_arg)) {
       return false;
     }
   }
   return true;
 }
 
 
+bool TypeArguments::IsFinalized() const {
+  ASSERT(!IsNull());
+  AbstractType& type = AbstractType::Handle();
+  const intptr_t num_types = Length();
+  for (intptr_t i = 0; i < num_types; i++) {
+    type = TypeAt(i);
+    if (!type.IsFinalized()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+
 bool TypeArguments::IsBounded() const {
   AbstractType& type = AbstractType::Handle();
   const intptr_t num_types = Length();
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     if (type.IsBoundedType()) {
       return true;
     }
     if (type.IsTypeParameter()) {
       const AbstractType& bound = AbstractType::Handle(
@@ skipping 136 matching lines @@
   TypeArguments& current = TypeArguments::Handle(isolate);
   current ^= table.At(index);
   while (!current.IsNull() && !current.Equals(arguments)) {
     index = (index + 1) & (table_size - 1);  // Move to next element.
     current ^= table.At(index);
   }
   return index;  // Index of element if found or slot into which to add it.
 }
 
 
+RawAbstractTypeArguments* TypeArguments::CloneUnfinalized() const {
+  if (IsFinalized()) {
+    return raw();
+  }
+  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);
+    type = type.CloneUnfinalized();
+    clone.SetTypeAt(i, type);
+  }
+  return clone.raw();
+}
+
+
 RawAbstractTypeArguments* TypeArguments::Canonicalize() const {
   if (IsNull() || IsCanonical()) {
     ASSERT(IsOld());
     return this->raw();
   }
   Isolate* isolate = Isolate::Current();
   ObjectStore* object_store = isolate->object_store();
   const Array& table = Array::Handle(isolate,
                                      object_store->canonical_type_arguments());
   ASSERT(table.Length() > 0);
@@ skipping 7227 matching lines @@
 
 RawAbstractType* AbstractType::InstantiateFrom(
     const AbstractTypeArguments& instantiator_type_arguments,
     Error* bound_error) const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
+RawAbstractType* AbstractType::CloneUnfinalized() const {
+  // AbstractType is an abstract class.
+  UNREACHABLE();
+  return NULL;
+}
+
+
 RawAbstractType* AbstractType::Canonicalize() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
 RawString* AbstractType::BuildName(NameVisibility name_visibility) const {
   if (IsBoundedType()) {
     // TODO(regis): Should the bound be visible in the name for debug purposes
@@ skipping 509 matching lines @@
   }
   if (!IsFinalized() || !other_type.IsFinalized()) {
     return false;
   }
   return AbstractTypeArguments::AreEqual(
       AbstractTypeArguments::Handle(arguments()),
       AbstractTypeArguments::Handle(other_type.arguments()));
 }
 
 
+RawAbstractType* Type::CloneUnfinalized() const {
+  ASSERT(IsResolved());
+  if (IsFinalized()) {
+    return raw();
+  }
+  ASSERT(!IsMalformed());  // Malformed types are finalized.
+  ASSERT(!IsBeingFinalized());  // Cloning must occur prior to finalization.
+  AbstractTypeArguments& type_args = AbstractTypeArguments::Handle(arguments());
+  type_args = type_args.CloneUnfinalized();
+  const Class& type_cls = Class::Handle(type_class());
+  return Type::New(type_cls, type_args, token_pos());
+}
+
+
 RawAbstractType* Type::Canonicalize() const {
   ASSERT(IsFinalized());
   if (IsCanonical() || IsMalformed()) {
     ASSERT(IsMalformed() || AbstractTypeArguments::Handle(arguments()).IsOld());
     return this->raw();
   }
   const Class& cls = Class::Handle(type_class());
   Array& canonical_types = Array::Handle(cls.canonical_types());
   if (canonical_types.IsNull()) {
     // Types defined in the VM isolate are canonicalized via the object store.
@@ skipping 269 matching lines @@
         type_param_name.ToCString(),
         class_name.ToCString(),
         declared_bound_name.ToCString(),
         bounded_type_name.ToCString(),
         upper_bound_name.ToCString());
   }
   return false;
 }
 
 
+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()),
+                            index(),
+                            String::Handle(name()),
+                            AbstractType::Handle(bound()),
+                            token_pos());
+}
+
+
 intptr_t TypeParameter::Hash() const {
   ASSERT(IsFinalized());
   uword result = 0;
   result += Class::Handle(parameterized_class()).id();
   // Do not include the hash of the bound, which could lead to cycles.
   result <<= index();
   return FinalizeHash(result);
 }
 
 
@@ skipping 159 matching lines @@
     }
     if (bound_error->IsNull()) {
       type_param.CheckBound(bounded_type, upper_bound, bound_error);
     }
     set_is_being_checked(false);
   }
   return bounded_type.raw();
 }
 
 
+RawAbstractType* BoundedType::CloneUnfinalized() const {
+  if (IsFinalized()) {
+    return raw();
+  }
+  AbstractType& bounded_type = AbstractType::Handle(type());
+
+  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()));
+}
+
+
 intptr_t BoundedType::Hash() const {
   uword result = 0;
   result += AbstractType::Handle(type()).Hash();
   // Do not include the hash of the bound, which could lead to cycles.
   TypeParameter& type_param = TypeParameter::Handle(type_parameter());
   if (!type_param.IsNull()) {
     result += type_param.Hash();
   }
 return FinalizeHash(result);
 }
@@ skipping 3395 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
 }  // namespace dart