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

runtime/vm/class_finalizer.cc

 // Copyright (c) 2013, 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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 488 matching lines @@
     for (intptr_t i = 0; i < num_arguments; i++) {
       type_argument = arguments.TypeAt(i);
       ResolveType(cls, type_argument, finalization);
     }
   }
 }
 
 
 void ClassFinalizer::FinalizeTypeParameters(const Class& cls) {
   if (cls.IsMixinApplication()) {
-    // Copy the type parameters to the mixin application.
+    // Setup the type parameters of the mixin application and finalize the
+    // mixin type.
     ApplyMixinType(cls);
-    // Finalize the mixin type.
-    Type& mixin_type = Type::Handle(cls.mixin());
-    mixin_type ^= FinalizeType(cls, mixin_type, kCanonicalizeWellFormed);
-    // TODO(regis): Check for a malbounded mixin_type.
-    cls.set_mixin(mixin_type);
   }
   // The type parameter bounds are not finalized here.
   const TypeArguments& type_parameters =
       TypeArguments::Handle(cls.type_parameters());
   if (!type_parameters.IsNull()) {
     TypeParameter& type_parameter = TypeParameter::Handle();
     const intptr_t num_types = type_parameters.Length();
     for (intptr_t i = 0; i < num_types; i++) {
       type_parameter ^= type_parameters.TypeAt(i);
       type_parameter ^= FinalizeType(cls,
@@ skipping 212 matching lines @@
     const Class& parameterized_class =
         Class::Handle(type_parameter.parameterized_class());
     ASSERT(!parameterized_class.IsNull());
     // The index must reflect the position of this type parameter in the type
     // arguments vector of its parameterized class. The offset to add is the
     // number of type arguments in the super type, which is equal to the
     // difference in number of type arguments and type parameters of the
     // parameterized class.
     const intptr_t offset = parameterized_class.NumTypeArguments() -
                             parameterized_class.NumTypeParameters();
-    type_parameter.set_index(type_parameter.index() + offset);
-    type_parameter.set_is_finalized();
+    // Calling NumTypeParameters() may finalize this type parameter if it
+    // belongs to a mixin application class.
+    if (!type_parameter.IsFinalized()) {
+      type_parameter.set_index(type_parameter.index() + offset);
+      type_parameter.set_is_finalized();
+    } else {
+      ASSERT(cls.IsMixinApplication());
+    }
     // We do not canonicalize type parameters.
     return type_parameter.raw();
   }
 
   // At this point, we can only have a parameterized_type.
   const Type& parameterized_type = Type::Cast(type);
 
   // Types illegally referring to themselves should have been detected earlier.
   ASSERT(!parameterized_type.IsBeingFinalized());
 
@@ skipping 917 matching lines @@
   ResolveSuperTypeAndInterfaces(mixin_app_class, &visited_interfaces);
 
   if (FLAG_trace_class_finalization) {
     OS::Print("Done applying mixin type '%s' to class '%s' %s extending '%s'\n",
               String::Handle(mixin_type.Name()).ToCString(),
               String::Handle(mixin_app_class.Name()).ToCString(),
               TypeArguments::Handle(
                   mixin_app_class.type_parameters()).ToCString(),
               AbstractType::Handle(mixin_app_class.super_type()).ToCString());
   }
+  // Mark the application class as having been applied its mixin type in order
+  // to avoid cycles while finalizing its mixin type.
   mixin_app_class.set_is_mixin_type_applied();
+  // Finalize the mixin type, which may have been changed in case
+  // mixin_app_class is a typedef.
+  mixin_type = mixin_app_class.mixin();
+  ASSERT(!mixin_type.IsBeingFinalized());
+  mixin_type ^=
+      FinalizeType(mixin_app_class, mixin_type, kCanonicalizeWellFormed);
+  // TODO(regis): Check for a malbounded mixin_type.
+  mixin_app_class.set_mixin(mixin_type);
 }
 
 
 void ClassFinalizer::CreateForwardingConstructors(
     const Class& mixin_app,
     const GrowableObjectArray& cloned_funcs) {
   const String& mixin_name = String::Handle(mixin_app.Name());
   const Class& super_class = Class::Handle(mixin_app.SuperClass());
   const String& super_name = String::Handle(super_class.Name());
   const Type& dynamic_type = Type::Handle(Type::DynamicType());
@@ skipping 427 matching lines @@
   AbstractTypeArguments& type_args =
       AbstractTypeArguments::Handle(type.arguments());
   const intptr_t num_type_parameters = type_class.NumTypeParameters();
   const intptr_t num_type_arguments =
       type_args.IsNull() ? 0 : type_args.Length();
   AbstractType& arg = AbstractType::Handle();
   if (num_type_arguments > 0) {
     if (num_type_arguments == num_type_parameters) {
       for (intptr_t i = 0; i < num_type_arguments; i++) {
         arg = type_args.TypeAt(i);
+        arg = arg.CloneUnfinalized();
+        ASSERT(!arg.IsBeingFinalized());
         collected_args.Add(arg);
       }
       return;
     }
     if (FLAG_error_on_bad_type) {
       const Script& script = Script::Handle(cls.script());
       const String& type_class_name = String::Handle(type_class.Name());
       ReportError(Error::Handle(),  // No previous error.
                   script, type.token_pos(),
                   "wrong number of type arguments for class '%s'",
@@ skipping 452 matching lines @@
   expected_name ^= String::New("_offset");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
   field ^= fields_array.At(2);
   ASSERT(field.Offset() == TypedDataView::length_offset());
   name ^= field.name();
   ASSERT(name.Equals("length"));
 #endif
 }
 
 }  // namespace dart