Fix generic mixins (issue 11803).

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 1239 matching lines @@
                     class_name.ToCString(),
                     function_name.ToCString(),
                     super_class_name.ToCString());
       }
     }
   }
 }
 
 
 // Copy the type parameters of the super and mixin classes to the
-// mixin application class. Change type arguments of super type to
-// refer to the respective type parameters of the mixin application
-// class.
+// mixin application class. Change type arguments of super type and of
+// interfaces to refer to the respective type parameters of the mixin
+// application class.
 void ClassFinalizer::CloneTypeParameters(const Class& mixapp_class) {
   ASSERT(mixapp_class.NumTypeParameters() == 0);
 
   const AbstractType& super_type =
       AbstractType::Handle(mixapp_class.super_type());
   ASSERT(super_type.IsResolved());
   const Class& super_class = Class::Handle(super_type.type_class());
   const Type& mixin_type = Type::Handle(mixapp_class.mixin());
   const Class& mixin_class = Class::Handle(mixin_type.type_class());
   const int num_super_parameters = super_class.NumTypeParameters();
@@ skipping 38 matching lines @@
                                         param.token_pos());
       cloned_type_params.SetTypeAt(cloned_index, cloned_param);
       // Change the type arguments of the super type to refer to the
       // cloned type parameters of the mixin application class.
       super_type_args.SetTypeAt(cloned_index, cloned_param);
       cloned_index++;
     }
     // TODO(hausner): May need to handle BoundedType here.
     ASSERT(super_type.IsType());
     Type::Cast(super_type).set_arguments(super_type_args);
+    ASSERT(!super_type.IsFinalized());
   }
 
   // Second, clone the type parameters of the mixin class.
   // We need to retain the parameter names of the mixin class
   // since the code that will be compiled in the context of the
   // mixin application class may refer to the type parameters
   // with that name.
   if (num_mixin_parameters > 0) {
     const TypeArguments& mixin_params =
         TypeArguments::Handle(mixin_class.type_parameters());
+    const TypeArguments& interface_type_args = TypeArguments::Handle(
+        TypeArguments::New(num_mixin_parameters));
     for (int i = 0; i < num_mixin_parameters; i++) {
       param ^= mixin_params.TypeAt(i);
       param_name = param.name();
       param_bound = param.bound();
 
       // TODO(hausner): handle type bounds.
       if (!param_bound.IsObjectType()) {
         const Script& script = Script::Handle(mixapp_class.script());
         ReportError(script, param.token_pos(),
                     "type parameter '%s': type bounds not yet"
                     " implemented for mixins\n",
                     param_name.ToCString());
       }
       cloned_param = TypeParameter::New(mixapp_class,
                                         cloned_index,
                                         param_name,
                                         param_bound,
                                         param.token_pos());
       cloned_type_params.SetTypeAt(cloned_index, cloned_param);
+      interface_type_args.SetTypeAt(i, cloned_param);
       cloned_index++;
     }
+
+    // Lastly, change the type arguments of the single interface type to
+    // refer to the cloned type parameters of the mixin application class.
+    Array& interface_types = Array::Handle(mixapp_class.interfaces());
+    ASSERT(interface_types.Length() == 1);
+    AbstractType& interface_type = AbstractType::Handle();
+    interface_type ^= interface_types.At(0);
+    ASSERT(interface_type.IsResolved());
+    // TODO(hausner): May need to handle BoundedType here.
+    ASSERT(interface_type.IsType());
+    Type::Cast(interface_type).set_arguments(interface_type_args);
+    ASSERT(!interface_type.IsFinalized());
   }
   mixapp_class.set_type_parameters(cloned_type_params);
 }
 
 
 void ClassFinalizer::ApplyMixinTypes(const Class& cls) {
   const Type& mixin_type = Type::Handle(cls.mixin());
   ASSERT(!mixin_type.IsNull());
   ASSERT(mixin_type.HasResolvedTypeClass());
   const Class& mixin_cls = Class::Handle(mixin_type.type_class());
 
   if (FLAG_trace_class_finalization) {
     OS::Print("Applying mixin type '%s' to '%s' at pos %"Pd"\n",
-              String::Handle(mixin_cls.Name()).ToCString(),
+              String::Handle(mixin_type.Name()).ToCString(),
               cls.ToCString(),
               cls.token_pos());
   }
 
   // Check that the super class of the mixin class is extending
   // class Object.
   const AbstractType& mixin_super_type =
       AbstractType::Handle(mixin_cls.super_type());
   if (!mixin_super_type.IsObjectType()) {
     const Script& script = Script::Handle(cls.script());
     const String& class_name = String::Handle(mixin_cls.Name());
     ReportError(script, cls.token_pos(),
                 "mixin class %s must extend class Object",
                 class_name.ToCString());
   }
 
   // Copy type parameters to mixin application class.
   CloneTypeParameters(cls);
 
   if (FLAG_trace_class_finalization) {
-    OS::Print("done mixin type appl %s %s extending '%s'\n",
+    OS::Print("Done applying mixin type '%s' to class %s %s extending '%s'\n",
+              String::Handle(mixin_type.Name()).ToCString(),
               String::Handle(cls.Name()).ToCString(),
               TypeArguments::Handle(cls.type_parameters()).ToCString(),
               AbstractType::Handle(cls.super_type()).ToCString());
   }
 }
 
 
 void ClassFinalizer::CreateForwardingConstructors(
     const Class& mixin_app,
     const GrowableObjectArray& cloned_funcs) {
@@ skipping 791 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