Register synthesized mixin application classes in the library and reuse them

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 1341 matching lines @@
                     name.ToCString(),
                     class_name.ToCString(),
                     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 and of
-// interfaces to refer to the respective type parameters of the mixin
-// application class.
+// Clone the type parameters of the super class and of the mixin class of this
+// mixin application class and use them as the type parameters of this mixin
+// application class. Set the type arguments of the super type, of the mixin
+// type (as well as of the interface type, which is identical to the mixin type)
+// to refer to the respective type parameters of the mixin application class.
+// In other words, decorate this mixin application class with type parameters
+// that forward to the super type and mixin type (and interface type).
+// Example:
+//   class S<T> { }
+//   class M<T> { }
+//   class C<E> extends S<E> with M<List<E>> { }
+// results in
+//   class S&M<T`, T> extends S<T`> implements M<T> { } // mixin == M<T>
+//   class C<E> extends S&M<E, List<E>> { }
+// CloneMixinAppTypeParameters decorates class S&M with type parameters T` and
+// T, and use them as type arguments in S<T`> and M<T>.
 void ClassFinalizer::CloneMixinAppTypeParameters(const Class& mixin_app_class) {
   ASSERT(mixin_app_class.type_parameters() == AbstractTypeArguments::null());
   const AbstractType& super_type = AbstractType::Handle(
       mixin_app_class.super_type());
   ASSERT(super_type.IsResolved());
   const Class& super_class = Class::Handle(super_type.type_class());
   const intptr_t num_super_type_params = super_class.NumTypeParameters();
   const Type& mixin_type = Type::Handle(mixin_app_class.mixin());
   const Class& mixin_class = Class::Handle(mixin_type.type_class());
   const intptr_t num_mixin_type_params = mixin_class.NumTypeParameters();
   // The mixin class cannot be Object and this was checked earlier.
   ASSERT(!mixin_class.IsObjectClass());
 
   // Add the mixin type to the interfaces that the mixin application
   // class implements. This is necessary so that type tests work.
   const Array& interfaces = Array::Handle(Array::New(1));
   const Type& interface = Type::Handle(Type::New(
       mixin_class,
       Object::null_abstract_type_arguments(),  // Set again below if generic.
       mixin_app_class.token_pos()));
   ASSERT(!interface.IsFinalized());
   interfaces.SetAt(0, interface);
+  ASSERT(mixin_app_class.interfaces() == Object::empty_array().raw());
   mixin_app_class.set_interfaces(interfaces);
 
   // If both the super type and the mixin type are non generic, the mixin
   // application class is non generic as well and we can skip type parameter
   // cloning.
   if ((num_super_type_params + num_mixin_type_params) > 0) {
     // 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_type_params + num_mixin_type_params));
     TypeParameter& param = TypeParameter::Handle();
     TypeParameter& cloned_param = TypeParameter::Handle();
     String& param_name = String::Handle();
     AbstractType& param_bound = AbstractType::Handle();
     intptr_t cloned_index = 0;
     if (num_super_type_params > 0) {
       const TypeArguments& super_type_params =
           TypeArguments::Handle(super_class.type_parameters());
       const TypeArguments& super_type_args =
           TypeArguments::Handle(TypeArguments::New(num_super_type_params));
       for (intptr_t i = 0; i < num_super_type_params; i++) {
         param ^= super_type_params.TypeAt(i);
         param_name = param.name();
         param_bound = param.bound();
-        // TODO(hausner): handle type bounds.
+        // TODO(14453): handle type bounds.
         if (!param_bound.IsObjectType()) {
           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(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++;
       }
-      // TODO(hausner): May need to handle BoundedType here.
+      // TODO(14453): 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_type_params > 0) {
       const TypeArguments& mixin_params =
           TypeArguments::Handle(mixin_class.type_parameters());
+      const TypeArguments& mixin_type_args = TypeArguments::Handle(
+          TypeArguments::New(num_mixin_type_params));
+      // TODO(regis): Can we share interface type and mixin_type?
       const TypeArguments& interface_type_args = TypeArguments::Handle(
           TypeArguments::New(num_mixin_type_params));
       for (intptr_t i = 0; i < num_mixin_type_params; i++) {
         param ^= mixin_params.TypeAt(i);
         param_name = param.name();
         param_bound = param.bound();
 
-        // TODO(hausner): handle type bounds.
+        // TODO(14453): handle type bounds.
         if (!param_bound.IsObjectType()) {
           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(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);
+        mixin_type_args.SetTypeAt(i, cloned_param);
         cloned_index++;
       }
 
-      // Lastly, set the type arguments of the single interface type.
+      // Lastly, set the type arguments of the mixin type and of the single
+      // interface type.
+      ASSERT(!mixin_type.IsFinalized());
+      mixin_type.set_arguments(mixin_type_args);
       ASSERT(!interface.IsFinalized());
       interface.set_arguments(interface_type_args);
     }
     mixin_app_class.set_type_parameters(cloned_type_params);
   }
   // If the mixin class is a mixin application typedef class, we insert a new
   // synthesized mixin application class in the super chain of this mixin
   // application class. The new class will have the aliased mixin as actual
   // mixin.
   if (mixin_class.is_mixin_typedef()) {
@@ skipping 51 matching lines @@
 U and V in the super type S&A`<T`, Map<U, V>> of S&A must refer to the type
 parameters U and V of S&A. However, Map<U, V> is copied from the super type
 Object&M<Map<U, V>> of A and, therefore, U and V refer to A. An instantiation
 step with a properly crafted instantiator vector takes care of the required type
 parameter substitution.
 
 The instantiator vector must end with the type parameters U and V of S&A.
 The offset of the first type parameter U of S&A must be at the finalized index
 of type parameter U of A.
 */
+// TODO(regis): The syntax does not use 'typedef' anymore. Rename to 'alias'?
 void ClassFinalizer::ApplyMixinTypedef(const Class& mixin_app_class) {
   // If this mixin typedef is aliasing another mixin typedef, another class
   // will be inserted via recursion. No need to check here.
   // The mixin type may or may not be finalized yet.
+  AbstractType& super_type = AbstractType::Handle(mixin_app_class.super_type());
   const Type& mixin_type = Type::Handle(mixin_app_class.mixin());
   const Class& mixin_class = Class::Handle(mixin_type.type_class());
   ASSERT(mixin_class.is_mixin_typedef());
   const Class& aliased_mixin_app_class = Class::Handle(
       mixin_class.SuperClass());
   const Type& aliased_mixin_type = Type::Handle(
       aliased_mixin_app_class.mixin());
   // The name of the inserted mixin application class is the name of mixin
   // class name with a backtick added.
   String& inserted_class_name = String::Handle(mixin_app_class.Name());
   inserted_class_name = String::Concat(inserted_class_name,
                                        Symbols::Backtick());
-  inserted_class_name = Symbols::New(inserted_class_name);
-  const Script& script = Script::Handle(mixin_app_class.script());
   const Library& library = Library::Handle(mixin_app_class.library());
-  const Class& inserted_class = Class::Handle(Class::New(
-      inserted_class_name, script, mixin_app_class.token_pos()));
-  inserted_class.set_library(library);
-  inserted_class.set_is_synthesized_class();
+  Class& inserted_class = Class::Handle(
+      library.LookupLocalClass(inserted_class_name));
+  if (inserted_class.IsNull()) {
+    inserted_class_name = Symbols::New(inserted_class_name);
+    const Script& script = Script::Handle(mixin_app_class.script());
+    inserted_class = Class::New(
+        inserted_class_name, script, mixin_app_class.token_pos());
+    inserted_class.set_is_synthesized_class();
+    library.AddClass(inserted_class);
 
-  // The super type of the inserted class is identical to the super type of
-  // this mixin application class, except that it must refer to the type
-  // parameters of the inserted class rather than to those of the mixin
-  // application class.
-  // The type arguments of the super type will be set properly when calling
-  // CloneMixinAppTypeParameters on the inserted class, as long as the super
-  // type class is set properly.
-  AbstractType& super_type = AbstractType::Handle(mixin_app_class.super_type());
-  inserted_class.set_super_type(super_type);  // Super class only is used.
+    if (FLAG_trace_class_finalization) {
+      OS::Print("Creating mixin typedef application %s\n",
+                inserted_class.ToCString());
+    }
 
-  // The mixin type must also be set before calling CloneMixinAppTypeParameters.
-  // It refers to the type parameters of the mixin class typedef.
-  inserted_class.set_mixin(aliased_mixin_type);  // Mixin class only is used.
+    // The super type of the inserted class is identical to the super type of
+    // this mixin application class, except that it must refer to the type
+    // parameters of the inserted class rather than to those of the mixin
+    // application class.
+    // The type arguments of the super type will be set properly when calling
+    // CloneMixinAppTypeParameters on the inserted class, as long as the super
+    // type class is set properly.
+    inserted_class.set_super_type(super_type);  // Super class only is used.
+
+    // The mixin type and interface type must also be set before calling
+    // CloneMixinAppTypeParameters.
+    // After FinalizeTypesInClass, they will refer to the type parameters of
+    // the mixin class typedef.
+    const Type& generic_mixin_type = Type::Handle(
+        Type::New(Class::Handle(aliased_mixin_type.type_class()),
+                  Object::null_abstract_type_arguments(),
+                  aliased_mixin_type.token_pos()));
+    inserted_class.set_mixin(generic_mixin_type);
+    // The interface will be set in CloneMixinAppTypeParameters.
+  }
 
   // Finalize the types and call CloneMixinAppTypeParameters.
   FinalizeTypesInClass(inserted_class);
 
   // The super type of this mixin application class must point to the
   // inserted class. The super type arguments are the concatenation of the
   // old super type arguments (propagating type arguments to the super class)
   // with new type arguments providing type arguments to the mixin.
-  // The appended type arguments are those of the aliased mixin type, except
+  // The appended type arguments are those of the super type of the mixin
+  // typedef that are forwarding to the aliased mixin type, except
   // that they must refer to the type parameters of the mixin application
-  // class rather than to those of the aliased mixin class.
+  // class rather than to those of the mixin typedef class.
   // This type parameter substitution is performed by an instantiation step.
   // It is important that the type parameters of the mixin application class
   // are not finalized yet, because new type parameters may have been added
   // to the super class.
   Class& super_class = Class::Handle(super_type.type_class());
   ASSERT(mixin_app_class.SuperClass() == super_class.raw());
   while (super_class.IsMixinApplication()) {
     super_class = super_class.SuperClass();
   }
   const intptr_t num_super_type_params = super_class.NumTypeParameters();
@@ skipping 13 matching lines @@
   const Class& aliased_mixin_type_class = Class::Handle(
       aliased_mixin_type.type_class());
   const intptr_t num_aliased_mixin_type_params =
       aliased_mixin_type_class.NumTypeParameters();
   const intptr_t num_aliased_mixin_type_args =
       aliased_mixin_type_class.NumTypeArguments();
   offset = num_aliased_mixin_type_args - num_aliased_mixin_type_params;
   ASSERT(inserted_class.NumTypeParameters() ==
          (num_super_type_params + num_aliased_mixin_type_params));
   // The aliased_mixin_type may be raw.
-  const AbstractTypeArguments& aliased_mixin_type_args =
-      AbstractTypeArguments::Handle(aliased_mixin_type.arguments());
+  const AbstractTypeArguments& mixin_class_super_type_args =
+      AbstractTypeArguments::Handle(
+          AbstractType::Handle(mixin_class.super_type()).arguments());
   TypeArguments& new_mixin_type_args = TypeArguments::Handle();
   if ((num_aliased_mixin_type_params > 0) &&
-      !aliased_mixin_type_args.IsNull()) {
+      !mixin_class_super_type_args.IsNull()) {
     new_mixin_type_args = TypeArguments::New(num_aliased_mixin_type_params);
     for (intptr_t i = 0; i < num_aliased_mixin_type_params; i++) {
-      type = aliased_mixin_type_args.TypeAt(offset + i);
+      type = mixin_class_super_type_args.TypeAt(offset + i);
       new_mixin_type_args.SetTypeAt(i, type);
     }
   }
   if (!new_mixin_type_args.IsNull() &&
       !new_mixin_type_args.IsInstantiated()) {
     Error& bound_error = Error::Handle();
     new_mixin_type_args ^=
         new_mixin_type_args.InstantiateFrom(instantiator, &bound_error);
-    // TODO(regis): Handle bound error.
+    // TODO(14453): Handle bound error.
     ASSERT(bound_error.IsNull());
   }
   TypeArguments& new_super_type_args = TypeArguments::Handle();
   if ((num_super_type_params + num_aliased_mixin_type_params) > 0) {
     new_super_type_args = TypeArguments::New(num_super_type_params +
                                              num_aliased_mixin_type_params);
     for (intptr_t i = 0; i < num_super_type_params; i++) {
       type = type_params.TypeAt(i);
       new_super_type_args.SetTypeAt(i, type);
     }
@@ skipping 89 matching lines @@
   }
   // 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.
+  // TODO(14453): 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());
@@ skipping 452 matching lines @@
     // Discard provided type arguments and treat type as raw.
   }
   // Fill arguments with type dynamic.
   for (intptr_t i = 0; i < num_type_parameters; i++) {
     arg = Type::DynamicType();
     collected_args.Add(arg);
   }
 }
 
 
-RawType* ClassFinalizer::ResolveMixinAppType(const Class& cls,
-                                             const MixinAppType& mixin_app) {
-  // Resolve super type and all mixin types.
+RawType* ClassFinalizer::ResolveMixinAppType(
+    const Class& cls,
+    const MixinAppType& mixin_app_type) {
+  // Lookup or create mixin application classes in the library of cls
+  // and resolve super type and mixin types.
+  const Library& library = Library::Handle(cls.library());
+  ASSERT(!library.IsNull());
+  const Script& script = Script::Handle(cls.script());
+  ASSERT(!script.IsNull());
   const GrowableObjectArray& type_args =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
-  AbstractType& type = AbstractType::Handle(mixin_app.SuperType());
-  ResolveType(cls, type, kCanonicalizeWellFormed);
-  ASSERT(type.HasResolvedTypeClass());
-  // TODO(hausner): May need to handle BoundedType here.
-  ASSERT(type.IsType());
-  CollectTypeArguments(cls, Type::Cast(type), type_args);
+  AbstractType& mixin_super_type =
+      AbstractType::Handle(mixin_app_type.super_type());
+  ResolveType(cls, mixin_super_type, kCanonicalizeWellFormed);
+  ASSERT(mixin_super_type.HasResolvedTypeClass());
+  // TODO(14453): May need to handle BoundedType here.
+  ASSERT(mixin_super_type.IsType());
+  CollectTypeArguments(cls, Type::Cast(mixin_super_type), type_args);
+  AbstractType& mixin_type = AbstractType::Handle();
+  Type& generic_mixin_type = Type::Handle();
+  Class& mixin_type_class = Class::Handle();
   Class& mixin_app_class = Class::Handle();
-  const intptr_t depth = mixin_app.Depth();
+  String& mixin_app_class_name = String::Handle();
+  String& mixin_type_class_name = String::Handle();
+  const intptr_t depth = mixin_app_type.Depth();
   for (intptr_t i = 0; i < depth; i++) {
-    mixin_app_class = mixin_app.MixinAppAt(i);
-    type = mixin_app_class.mixin();
-    ASSERT(!type.IsNull());
-    ResolveType(cls, type, kCanonicalizeWellFormed);
-    ASSERT(type.HasResolvedTypeClass());
-    ASSERT(type.IsType());
-    CollectTypeArguments(cls, Type::Cast(type), type_args);
+    mixin_type = mixin_app_type.MixinTypeAt(i);
+    ASSERT(!mixin_type.IsNull());
+    ResolveType(cls, mixin_type, kCanonicalizeWellFormed);
+    ASSERT(mixin_type.HasResolvedTypeClass());
+    ASSERT(mixin_type.IsType());
+    CollectTypeArguments(cls, Type::Cast(mixin_type), type_args);
+
+    // The name of the mixin application class is a combination of
+    // the super class name and mixin class name.
+    mixin_app_class_name = mixin_super_type.ClassName();
+    mixin_app_class_name = String::Concat(mixin_app_class_name,
+                                          Symbols::Ampersand());
+    mixin_type_class_name = mixin_type.ClassName();
+    mixin_app_class_name = String::Concat(mixin_app_class_name,
+                                          mixin_type_class_name);
+    mixin_app_class = library.LookupLocalClass(mixin_app_class_name);
+    if (mixin_app_class.IsNull()) {
+      mixin_app_class_name = Symbols::New(mixin_app_class_name);
+      mixin_app_class = Class::New(mixin_app_class_name,
+                                   script,
+                                   mixin_type.token_pos());
+      mixin_app_class.set_super_type(mixin_super_type);
+      mixin_type_class = mixin_type.type_class();
+      generic_mixin_type = Type::New(mixin_type_class,
+                                     Object::null_abstract_type_arguments(),
+                                     mixin_type.token_pos());
+      mixin_app_class.set_mixin(generic_mixin_type);
+      mixin_app_class.set_is_synthesized_class();
+      library.AddClass(mixin_app_class);
+
+      // No need to add the new class to pending_classes, since it will be
+      // processed via the super_type chain of a pending class.
+
+      if (FLAG_trace_class_finalization) {
+        OS::Print("Creating mixin application %s\n",
+                  mixin_app_class.ToCString());
+      }
+    }
+    // This mixin application class becomes the type class of the super type of
+    // the next mixin application class. It is however too early to provide the
+    // correct super type arguments. We use the raw type for now.
+    mixin_super_type = Type::New(mixin_app_class,
+                                 Object::null_abstract_type_arguments(),
+                                 mixin_type.token_pos());
   }
+  AbstractType& type_arg = AbstractType::Handle();
   const TypeArguments& mixin_app_args =
     TypeArguments::Handle(TypeArguments::New(type_args.Length()));
   for (intptr_t i = 0; i < type_args.Length(); i++) {
-    type ^= type_args.At(i);
-    mixin_app_args.SetTypeAt(i, type);
+    type_arg ^= type_args.At(i);
+    mixin_app_args.SetTypeAt(i, type_arg);
   }
   if (FLAG_trace_class_finalization) {
     OS::Print("ResolveMixinAppType: mixin appl type args: %s\n",
               mixin_app_args.ToCString());
   }
   // The mixin application class at depth k is a subclass of mixin application
   // class at depth k - 1. Build a new super type with the class at the highest
   // depth (the last one processed by the loop above) as the type class and the
   // collected type arguments from the super type and all mixin types.
   // This super type replaces the MixinAppType object in the class that extends
   // the mixin application.
-  return Type::New(mixin_app_class, mixin_app_args, mixin_app.token_pos());
+  return Type::New(mixin_app_class, mixin_app_args, mixin_app_type.token_pos());
 }
 
 
 // Recursively walks the graph of explicitly declared super type and
 // interfaces, resolving unresolved super types and interfaces.
 // Reports an error if there is an interface reference that cannot be
 // resolved, or if there is a cycle in the graph. We detect cycles by
 // remembering interfaces we've visited in each path through the
 // graph. If we visit an interface a second time on a given path,
 // we found a loop.
@@ skipping 381 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