Keep track of type parameter processing in mixin application classes.

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 493 matching lines @@
     AbstractType& type_argument = AbstractType::Handle();
     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.mixin() != Type::null()) {

[siva, 2013/09/04 21:07:00]

Might be more readable to have a isMixin() method in 'class Class' which does
this check. I think this check is also used elsewhere.

[regis, 2013/09/04 22:14:27]

Added IsMixinApplication() to class Class.

+    // Copy the type parameters to the mixin application.
+    ApplyMixinType(cls);
+  }
   // 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,
                                      type_parameter,
@@ skipping 779 matching lines @@
       }
     }
   }
 }
 
 
 // Copy the type parameters of the super and mixin classes to the
 // 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);
+void ClassFinalizer::CloneTypeParameters(const Class& mixin_app_class) {
+  ASSERT(mixin_app_class.type_parameters() == AbstractTypeArguments::null());
 
   const AbstractType& super_type =
-      AbstractType::Handle(mixapp_class.super_type());
+      AbstractType::Handle(mixin_app_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 Type& mixin_type = Type::Handle(mixin_app_class.mixin());
   const Class& mixin_class = Class::Handle(mixin_type.type_class());
   const int num_super_parameters = super_class.NumTypeParameters();
   const int num_mixin_parameters = mixin_class.NumTypeParameters();
   if ((num_super_parameters + num_mixin_parameters) == 0) {
     return;
   }
 
   // First, clone the super class type parameters. Rename them so that
   // there can be no name conflict between the parameters of the super
   // class and the mixin class.
   const TypeArguments& cloned_type_params = TypeArguments::Handle(
       TypeArguments::New(num_super_parameters + num_mixin_parameters));
   TypeParameter& param = TypeParameter::Handle();
   TypeParameter& cloned_param = TypeParameter::Handle();
   String& param_name = String::Handle();
   AbstractType& param_bound = AbstractType::Handle();
   int cloned_index = 0;
   if (num_super_parameters > 0) {
     const TypeArguments& super_params =
         TypeArguments::Handle(super_class.type_parameters());
     const TypeArguments& super_type_args =
         TypeArguments::Handle(TypeArguments::New(num_super_parameters));
     for (int i = 0; i < num_super_parameters; i++) {
       param ^= super_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());
+        const Script& script = Script::Handle(mixin_app_class.script());
         ReportError(Error::Handle(),  // No previous error.
                     script, param.token_pos(),
                     "type parameter '%s': type bounds not yet"
                     " implemented for mixins\n",
                     param_name.ToCString());
       }
       param_name = String::Concat(param_name, Symbols::Backtick());
       param_name = Symbols::New(param_name);
-      cloned_param = TypeParameter::New(mixapp_class,
+      cloned_param = TypeParameter::New(mixin_app_class,
                                         cloned_index,
                                         param_name,
                                         param_bound,
                                         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++;
     }
@@ skipping 13 matching lines @@
         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());
+        const Script& script = Script::Handle(mixin_app_class.script());
         ReportError(Error::Handle(),  // No previous error.
                     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_param = TypeParameter::New(mixin_app_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());
+    Array& interface_types = Array::Handle(mixin_app_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);
+  mixin_app_class.set_type_parameters(cloned_type_params);
 }
 
 
-void ClassFinalizer::ApplyMixinTypes(const Class& cls) {
-  const Type& mixin_type = Type::Handle(cls.mixin());
+void ClassFinalizer::ApplyMixinType(const Class& mixin_app_class) {
+  if (mixin_app_class.is_mixin_type_applied()) {
+    return;
+  }
+  const Type& mixin_type = Type::Handle(mixin_app_class.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_type.Name()).ToCString(),
-              cls.ToCString(),
-              cls.token_pos());
+              mixin_app_class.ToCString(),
+              mixin_app_class.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 Script& script = Script::Handle(mixin_app_class.script());
     const String& class_name = String::Handle(mixin_cls.Name());
     ReportError(Error::Handle(),  // No previous error.
-                script, cls.token_pos(),
+                script, mixin_app_class.token_pos(),
                 "mixin class %s must extend class Object",
                 class_name.ToCString());
   }
 
   // Copy type parameters to mixin application class.
-  CloneTypeParameters(cls);
+  CloneTypeParameters(mixin_app_class);
 
   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(cls.Name()).ToCString(),
-              TypeArguments::Handle(cls.type_parameters()).ToCString(),
-              AbstractType::Handle(cls.super_type()).ToCString());
+              String::Handle(mixin_app_class.Name()).ToCString(),
+              TypeArguments::Handle(
+                  mixin_app_class.type_parameters()).ToCString(),
+              AbstractType::Handle(mixin_app_class.super_type()).ToCString());
   }
+  mixin_app_class.set_is_mixin_type_applied();
 }
 
 
 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 132 matching lines @@
     ReportError(Error::Handle(),  // No previous error.
                 script, cls.token_pos(),
                 "class '%s' has a cycle in its superclass relationship",
                 name.ToCString());
   }
   // Finalize super class.
   const Class& super_class = Class::Handle(cls.SuperClass());
   if (!super_class.IsNull()) {
     FinalizeTypesInClass(super_class);
   }
-  if (cls.mixin() != Type::null()) {
-    // Copy the type parameters to the mixin application.
-    ApplyMixinTypes(cls);
-  }
   // Finalize type parameters before finalizing the super type.
   FinalizeTypeParameters(cls);
   ResolveUpperBounds(cls);
   // Finalize super type.
   AbstractType& super_type = AbstractType::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     // In case of a bound error in the super type in production mode, the
     // finalized super type will be a BoundedType with a malformed bound.
     // It should not be a problem if the class is written to a snapshot and
     // later executed in checked mode. Note that the finalized type argument
@@ skipping 226 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) {
       const Script& script = Script::Handle(cls.script());
       const String& type_class_name = String::Handle(type_class.Name());
+      // TODO(regis): This should not be a compile time error anymore.
       ReportError(Error::Handle(),  // No previous error.
                   script, type.token_pos(),
                   "wrong number of type arguments for class '%s'",
                   type_class_name.ToCString());
     }
     for (int i = 0; i < num_type_arguments; i++) {
       arg = type_args.TypeAt(i);
       collected_args.Add(arg);
     }
   } else {
@@ skipping 449 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