Share the same type parameters of a mixin application class to propagate

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/code_generator.h"
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
@@ skipping 1405 matching lines @@
   const Array& interfaces = Array::Handle(isolate, Array::New(1));
   interfaces.SetAt(0, mixin_type);
   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.
   bool has_uninstantiated_bounds = false;
   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.
+    // If the last ampersand in the name of the mixin application class is
+    // doubled, the same type parameters can propagate the type arguments to
+    // the super type and to the mixin type.
+    bool share_type_params = false;
+    if (num_super_type_params == num_mixin_type_params) {
+      const String& name = String::Handle(isolate, mixin_app_class.Name());
+      for (intptr_t i = name.Length(); --i > 0; ) {

[srdjan, 2014/01/29 20:33:27]

Why that form? Wouldn't this be simpler to read:
for (intptr_t i = name.Length()  - 1; i > 0;  --i){

[regis, 2014/01/29 21:10:34]

Done.

+        if (name.CharAt(i) == '&') {
+          if (name.CharAt(i - 1) == '&') {
+            share_type_params = true;
+          }
+          break;
+        }
+      }
+    }
+
     const TypeArguments& cloned_type_params = TypeArguments::Handle(isolate,
-        TypeArguments::New(num_super_type_params + num_mixin_type_params));
+        TypeArguments::New((share_type_params ? 0 : num_super_type_params) +
+                           num_mixin_type_params));
     TypeParameter& param = TypeParameter::Handle(isolate);
     TypeParameter& cloned_param = TypeParameter::Handle(isolate);
     String& param_name = String::Handle(isolate);
     AbstractType& param_bound = AbstractType::Handle(isolate);
     intptr_t cloned_index = 0;
-    if (num_super_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.
+    if (!share_type_params && (num_super_type_params > 0)) {
       const TypeArguments& super_type_params =
           TypeArguments::Handle(isolate, super_class.type_parameters());
       const TypeArguments& super_type_args = TypeArguments::Handle(isolate,
           TypeArguments::New(num_super_type_params));
       // The cloned super class type parameters do not need to repeat their
       // bounds, since the bound checks will be performed at the super class
       // level.
       param_bound = isolate->object_store()->object_type();
       for (intptr_t i = 0; i < num_super_type_params; i++) {
         param ^= super_type_params.TypeAt(i);
@@ skipping 69 matching lines @@
             ASSERT(!param_bound.IsInstantiated());
             param.set_bound(param_bound);
           }
         }
       }
 
       // Lastly, set the type arguments of the mixin type, which is also the
       // single interface type.
       ASSERT(!mixin_type.IsFinalized());
       mixin_type.set_arguments(mixin_type_args);
+      if (share_type_params) {
+        Type::Cast(super_type).set_arguments(mixin_type_args);
+        ASSERT(!super_type.IsFinalized());
+      }
     }
     mixin_app_class.set_type_parameters(cloned_type_params);
   }
   // If the mixin class is a mixin application alias 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_app_alias()) {
     ApplyMixinAppAlias(mixin_app_class, has_uninstantiated_bounds);
   }
@@ skipping 834 matching lines @@
   ASSERT(mixin_super_type.HasResolvedTypeClass());  // Even if malformed.
   // The super type may have a BoundedType as type argument, but cannot be
   // a BoundedType itself.
   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();
   String& mixin_app_class_name = String::Handle();
   String& mixin_type_class_name = String::Handle();
+  AbstractType& super_type_arg = AbstractType::Handle();
+  AbstractType& mixin_type_arg = AbstractType::Handle();
   const intptr_t depth = mixin_app_type.Depth();
   for (intptr_t i = 0; i < depth; i++) {
     mixin_type = mixin_app_type.MixinTypeAt(i);
     ASSERT(!mixin_type.IsNull());
     ResolveType(cls, mixin_type);
     ASSERT(mixin_type.HasResolvedTypeClass());  // Even if malformed.
     ASSERT(mixin_type.IsType());
+    const intptr_t num_super_type_args = type_args.Length();
     CollectTypeArguments(cls, Type::Cast(mixin_type), type_args);
 
+    // If the mixin type has identical type arguments as the super type, they
+    // can share the same type parameters of the mixin application class,
+    // thereby allowing for further optimizations, such as instantiator vector
+    // reuse or sharing of type arguments with the super class.
+    bool share_type_params = (num_super_type_args > 0) &&
+        (type_args.Length() == 2*num_super_type_args);
+    if (share_type_params) {
+      for (intptr_t i = 0; i < num_super_type_args; i++) {
+        super_type_arg ^= type_args.At(i);
+        mixin_type_arg ^= type_args.At(num_super_type_args + i);
+        if (!super_type_arg.Equals(mixin_type_arg)) {
+          share_type_params = false;
+          break;
+        }
+      }
+      if (share_type_params) {
+        // Cut the type argument vector in half.
+        type_args.SetLength(num_super_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());
+    // If the type parameters are shared between the super type and the mixin
+    // type, use two ampersand symbols, so that the class has a different name
+    // and is not reused in a context where this optimization is not possible.
+    if (share_type_params) {
+      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);
@@ skipping 451 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