Share mixin type with interface type 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/code_generator.h"
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
@@ skipping 1390 matching lines @@
   const intptr_t num_super_type_params = super_class.NumTypeParameters();
   const Type& mixin_type = Type::Handle(isolate, mixin_app_class.mixin());
   const Class& mixin_class = Class::Handle(isolate, 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(isolate, Array::New(1));
-  const Type& interface = Type::Handle(isolate, 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);
+  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
@@ skipping 39 matching lines @@
     // 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(isolate, mixin_class.type_parameters());
       const TypeArguments& mixin_type_args = TypeArguments::Handle(isolate,
           TypeArguments::New(num_mixin_type_params));
-      // TODO(regis): Can we share interface type and mixin_type?
-      const TypeArguments& interface_type_args = TypeArguments::Handle(isolate,
-          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();  // The bound will be adjusted below.
         if (!param_bound.IsInstantiated()) {
           has_uninstantiated_bounds = true;
         }
         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++;
       }
 
       // Third, replace the type parameters appearing in the bounds of the mixin
       // type parameters, if any, by the cloned type parameters. This can be
       // done by instantiating each bound using the mixin_type_args as
       // instantiator. Since the mixin class must extend Object, its first type
       // parameter has index 0, therefore, the instantiator does not require
       // shifting. There is however an exception where the mixin class is an
@@ skipping 12 matching lines @@
                                                       &bound_error);
             // The instantiator contains only TypeParameter objects and no
             // BoundedType objects, so no bound error may occur.
             ASSERT(bound_error.IsNull());
             ASSERT(!param_bound.IsInstantiated());
             param.set_bound(param_bound);
           }
         }
       }
 
-      // Lastly, set the type arguments of the mixin type and of the single
-      // interface type.
+      // 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);
-      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 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 1319 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