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.IsMixinApplication()) {
+    // 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",
+    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(),
-                "mixin class %s must extend class Object",
+                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",
+    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 36 matching lines @@
       clone.set_parameter_types(Array::Handle(Array::New(num_parameters)));
       for (intptr_t n = 0; n < num_parameters; n++) {
         clone.SetParameterTypeAt(n, dynamic_type);
       }
       cloned_funcs.Add(clone);
     }
   }
 }
 
 
-void ClassFinalizer::ApplyMixin(const Class& cls) {
+void ClassFinalizer::ApplyMixinMembers(const Class& cls) {
   Isolate* isolate = Isolate::Current();
   const Type& mixin_type = Type::Handle(isolate, cls.mixin());
   ASSERT(!mixin_type.IsNull());
   ASSERT(mixin_type.HasResolvedTypeClass());
   const Class& mixin_cls = Class::Handle(isolate, mixin_type.type_class());
   mixin_cls.EnsureIsFinalized(isolate);
 
   if (FLAG_trace_class_finalization) {
-    OS::Print("Applying mixin '%s' to '%s' at pos %" Pd "\n",
-              String::Handle(mixin_cls.Name()).ToCString(),
+    OS::Print("Applying mixin members of %s to %s at pos %" Pd "\n",
+              mixin_cls.ToCString(),
               cls.ToCString(),
               cls.token_pos());
   }
 
   const GrowableObjectArray& cloned_funcs =
       GrowableObjectArray::Handle(isolate, GrowableObjectArray::New());
 
   CreateForwardingConstructors(cls, cloned_funcs);
 
   Array& functions = Array::Handle(isolate);
   Function& func = Function::Handle(isolate);
   // The parser creates the mixin application class with no functions.
   ASSERT((functions = cls.functions(), functions.Length() == 0));
   // Now clone the functions from the mixin class.
   functions = mixin_cls.functions();
   const intptr_t num_functions = functions.Length();
   for (int i = 0; i < num_functions; i++) {
     func ^= functions.At(i);
     if (func.IsConstructor()) {
       // A mixin class must not have explicit constructors.
       if (!func.IsImplicitConstructor()) {
         const Script& script = Script::Handle(isolate, cls.script());
         ReportError(Error::Handle(),  // No previous error.
                     script, cls.token_pos(),
-                    "mixin class %s must not have constructors\n",
+                    "mixin class '%s' must not have constructors\n",
                     String::Handle(isolate, mixin_cls.Name()).ToCString());
       }
       continue;  // Skip the implicit constructor.
     }
     if (!func.is_static()) {
       func = func.Clone(cls);
       cloned_funcs.Add(func);
     }
   }
   functions = Array::MakeArray(cloned_funcs);
@@ skipping 11 matching lines @@
     field ^= fields.At(i);
     if (!field.is_static()) {
       field = field.Clone(cls);
       cloned_fields.Add(field);
     }
   }
   fields = Array::MakeArray(cloned_fields);
   cls.SetFields(fields);
 
   if (FLAG_trace_class_finalization) {
-    OS::Print("done mixin appl '%s' '%s' extending '%s'\n",
-              String::Handle(cls.Name()).ToCString(),
-              TypeArguments::Handle(cls.type_parameters()).ToCString(),
-              AbstractType::Handle(cls.super_type()).ToCString());
+    OS::Print("done applying mixin members of %s to %s\n",
+              mixin_cls.ToCString(),
+              cls.ToCString());
   }
 }
 
 
 void ClassFinalizer::FinalizeTypesInClass(const Class& cls) {
   HANDLESCOPE(Isolate::Current());
   if (cls.is_type_finalized()) {
     return;
   }
   if (FLAG_trace_class_finalization) {
     OS::Print("Finalize types in %s\n", cls.ToCString());
   }
   if (!IsSuperCycleFree(cls)) {
     const String& name = String::Handle(cls.Name());
     const Script& script = Script::Handle(cls.script());
     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 90 matching lines @@
 
 
 void ClassFinalizer::FinalizeClass(const Class& cls) {
   HANDLESCOPE(Isolate::Current());
   if (cls.is_finalized()) {
     return;
   }
   if (FLAG_trace_class_finalization) {
     OS::Print("Finalize %s\n", cls.ToCString());
   }
-  if (cls.mixin() != Type::null()) {
+  if (cls.IsMixinApplication()) {
     // Copy instance methods and fields from the mixin class.
     // This has to happen before the check whether the methods of
     // the class conflict with inherited methods.
-    ApplyMixin(cls);
+    ApplyMixinMembers(cls);
   }
   // Ensure super class is finalized.
   const Class& super = Class::Handle(cls.SuperClass());
   if (!super.IsNull()) {
     FinalizeClass(super);
   }
   // Mark as parsed and finalized.
   cls.Finalize();
   // Mixin typedef classes may still lack their implicit constructor.
   // TODO(regis): Implement mixin typedefs with an alias class.
@@ skipping 111 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