Allow super calls in mixins (for now behind a --supermixin flag).

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"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 #include "vm/report.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, print_classes, false, "Prints details about loaded classes.");
 DEFINE_FLAG(bool, trace_class_finalization, false, "Trace class finalization.");
 DEFINE_FLAG(bool, trace_type_finalization, false, "Trace type finalization.");
+DECLARE_FLAG(bool, supermixin);
 DECLARE_FLAG(bool, use_cha_deopt);
 
 
 bool ClassFinalizer::AllClassesFinalized() {
   ObjectStore* object_store = Isolate::Current()->object_store();
   const GrowableObjectArray& classes =
       GrowableObjectArray::Handle(object_store->pending_classes());
   return classes.Length() == 0;
 }
 
@@ skipping 1523 matching lines @@
 
 
 // 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>> { }
+//   class S<T extends BT> { }
+//   class M<T extends BT> { }
+//   class C<E extends BE> 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>> { }
+//   class S&M<T`, T extends BT> extends S<T`> implements M<T> { }
+//   class C<E extends BE> 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>.
+// Note that the bound BT on T of S is not applied to T` of S&M. However, the
+// bound BT on T of M is applied to T of S&M. See comments below.
 void ClassFinalizer::CloneMixinAppTypeParameters(const Class& mixin_app_class) {
   ASSERT(mixin_app_class.type_parameters() == TypeArguments::null());
   Isolate* isolate = Isolate::Current();
   const AbstractType& super_type = AbstractType::Handle(isolate,
       mixin_app_class.super_type());
   ASSERT(super_type.IsResolved());
   const Class& super_class = Class::Handle(isolate, super_type.type_class());
   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());
 
   // The mixin type (in raw form) should have been added to the interfaces
   // implemented by the mixin application class. This is necessary so that cycle
   // check works at compile time (type arguments are ignored) and so that
   // type tests work at runtime (by then, type arguments will have been set, see
   // below).
   ASSERT(mixin_app_class.interfaces() != Object::empty_array().raw());
 
   // 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;
+  TypeArguments& instantiator = TypeArguments::Handle(isolate);
   if ((num_super_type_params + num_mixin_type_params) > 0) {
     // 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() - 1; i > 0; --i) {
         if (name.CharAt(i) == '&') {
           if (name.CharAt(i - 1) == '&') {
@@ skipping 16 matching lines @@
     // 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.
+      // level. As a consequence, if this mixin application is used itself as a
+      // mixin in another mixin application, the bounds will be ignored, which
+      // is correct, because the other mixin application does not inherit from
+      // the super class of its mixin. Note also that the other mixin
+      // application will only mixin the last mixin type listed in the first
+      // mixin application it is mixing in.
       param_bound = isolate->object_store()->object_type();
       for (intptr_t i = 0; i < num_super_type_params; i++) {
         param ^= super_type_params.TypeAt(i);
         param_name = param.name();
         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++;
       }
       // The super type may have a BoundedType as type argument, but cannot be
       // a BoundedType itself.
       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.
+    // with that name. We also retain the type parameter bounds.
     if (num_mixin_type_params > 0) {
       const TypeArguments& mixin_params =
           TypeArguments::Handle(isolate, mixin_class.type_parameters());
+      const intptr_t offset =
+          mixin_class.NumTypeArguments() - mixin_class.NumTypeParameters();
       const TypeArguments& mixin_type_args = TypeArguments::Handle(isolate,
           TypeArguments::New(num_mixin_type_params));
+      instantiator ^= TypeArguments::New(offset + num_mixin_type_params);
+      bool has_uninstantiated_bounds = false;
       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,
+                                          cloned_index,  // Unfinalized index.
                                           param_name,
                                           param_bound,
                                           param.token_pos());
         cloned_type_params.SetTypeAt(cloned_index, cloned_param);
-        mixin_type_args.SetTypeAt(i, cloned_param);
+        mixin_type_args.SetTypeAt(i, cloned_param);  // Unfinalized length.
+        instantiator.SetTypeAt(offset + i, cloned_param);  // Finalized length.
         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
-      // alias, in which case shifting is required and performed later in
-      // ApplyMixinAppAlias.
+      // done by instantiating each bound using the instantiator built above.
+      // If the mixin class extends a generic super class, its first finalized
+      // type parameter has a non-zero index, therefore, the instantiator
+      // requires shifting by the offset calculated above.
       // Unfinalized type parameters replace finalized type parameters, which
       // is not a problem since they will get finalized shortly as the mixin
       // application class gets finalized.
-      if (has_uninstantiated_bounds && !mixin_class.is_mixin_app_alias()) {
+      if (has_uninstantiated_bounds) {
         Error& bound_error = Error::Handle(isolate);
         for (intptr_t i = 0; i < num_mixin_type_params; i++) {
           param ^= mixin_type_args.TypeAt(i);
           param_bound = param.bound();
           if (!param_bound.IsInstantiated()) {
             // Make sure the bound is finalized before instantiating it.
             if (!param_bound.IsFinalized() &&
                 !param_bound.IsBeingFinalized()) {
               param_bound =
                   FinalizeType(mixin_app_class, param_bound, kCanonicalize);
               param.set_bound(param_bound);  // In case part of recursive type.
             }
-            param_bound = param_bound.InstantiateFrom(mixin_type_args,
+            param_bound = param_bound.InstantiateFrom(instantiator,
                                                       &bound_error);
             // The instantiator contains only TypeParameter objects and no
             // BoundedType objects, so no bound error may occur.
+            ASSERT(!param_bound.IsBoundedType());
             ASSERT(bound_error.IsNull());
             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);
+    ApplyMixinAppAlias(mixin_app_class, instantiator);
   }
 }
 
 
 /* Support for mixin alias.
 Consider the following example:
 
 class I<T> { }
 class J<T> { }
-class S<T> { }
-class M<T> { }
-class A<U, V> = Object with M<Map<U, V>> implements I<V>;
-class C<T, K> = S<T> with A<T, List<K>> implements J<K>;
+class S<T extends num> { }
+class M<T extends Map> { }
+class A<U, V extends List> = Object with M<Map<U, V>> implements I<V>;
+class C<T, K extends T> = S<T> with A<T, List<K>> implements J<K>;
 
 Before the call to ApplyMixinAppAlias, the VM has already synthesized 2 mixin
 application classes Object&M and S&A:
 
-Object&M<T> extends Object implements M<T> { ... members of M applied here ... }
-A<U, V> extends Object&M<Map<U, V>> implements I<V> { }
+Object&M<T extends Map> extends Object implements M<T> {
+  ... members of M applied here ...
+}
+A<U, V extends List> extends Object&M<Map<U, V>> implements I<V> { }
 
-S&A<T`, U, V> extends S<T`> implements A<U, V> { }
-C<T, K> extends S&A<T, T, List<K>> implements J<K> { }
+S&A<T`, U, V extends List> extends S<T`> implements A<U, V> {
+  ... members of A applied here, but A has no members ...
+}
+C<T, K extends T> extends S&A<T, T, List<K>> implements J<K> { }
 
 In theory, class A should be an alias of Object&M instead of extending it.
 In practice, the additional class provides a hook for implemented interfaces
 (e.g. I<V>) and for type argument substitution via the super type relation (e.g.
 type parameter T of Object&M is substituted with Map<U, V>, U and V being the
 type parameters of the alias A).
 
 Similarly, class C should be an alias of S&A instead of extending it.
 
-Since A is used as a mixin, it must extend Object. The fact that it extends
-Object&M must be hidden so that no error is wrongly reported.
-
 Now, A does not have any members to be mixed into S&A, because A is an alias.
 The members to be mixed in are actually those of M, and they should appear in a
 scope where the type parameter T is visible. The class S&A declares the type
 parameters of A, i.e. U and V, but not T.
 
 Therefore, the call to ApplyMixinAppAlias inserts another synthesized class S&A`
 as the superclass of S&A. The class S&A` declares a type argument T:
 
 Instead of
-S&A<T`, U, V> extends S<T`> implements A<U, V> { }
+S&A<T`, U, V extends List> extends S<T`> implements A<U, V> { }
 
 We now have:
-S&A`<T`, T> extends S<T`> implements M<T> { ... members of M applied here ... }
-S&A<T`, U, V> extends S&A`<T`, Map<U, V>> implements A<U, V> { }
+S&A`<T`, T extends Map> extends S<T`> implements M<T> {
+  ... members of M applied here ...
+}
+S&A<T`, U, V extends List> extends S&A`<T`, Map<U, V>> implements A<U, V> { }
 
 The main implementation difficulty resides in the fact that the type parameters
 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.
+The offset in the instantiator of the type parameter U of S&A must be at the
+finalized index of type parameter U of A.
 
 The same instantiator vector is used to adjust the type parameter bounds on U
-and V, if any. This step was postponed from CloneMixinAppTypeParameters above.
+and V, if any. This step is done in CloneMixinAppTypeParameters above, and the
+already built instantiator is passed here.
 
-Also, a possible bound on type parameter T of M (not shown in the example above)
-must be applied to type parameter T of S&A`. If the bound is uninstantiated,
-i.e. if it refers to T or other type parameters of M, an instantiation step is
-required to substitute these type parameters of M with type parameters of S&A`.
-The instantiator vector consists of the cloned type parameters of M without
-offset, since class M must extend Object. This is done in the recursive call to
-CloneMixinAppTypeParameters and does not require specific code in
-ApplyMixinAppAlias.
+Also, a possible bound on type parameter T of M must be applied to type
+parameter T of S&A`. If the bound is uninstantiated, i.e. if it refers to T or
+other type parameters of M, an instantiation step is required to substitute
+these type parameters of M with type parameters of S&A`.
+The instantiator vector consists of the cloned type parameters of M shifted by
+an offset corresponding to the finalized index of the first type parameter of M.
+This is done in the recursive call to CloneMixinAppTypeParameters and does not
+require specific code in ApplyMixinAppAlias.
 */
 void ClassFinalizer::ApplyMixinAppAlias(const Class& mixin_app_class,
-                                        bool has_uninstantiated_bounds) {
+                                        const TypeArguments& instantiator) {
   // If this mixin alias is aliasing another mixin alias, another class
   // will be inserted via recursion. No need to check here.
   // The mixin type may or may not be finalized yet.
   Isolate* isolate = Isolate::Current();
   AbstractType& super_type = AbstractType::Handle(isolate,
                                                   mixin_app_class.super_type());
   const Type& mixin_type = Type::Handle(isolate, mixin_app_class.mixin());
   const Class& mixin_class = Class::Handle(isolate, mixin_type.type_class());
   ASSERT(mixin_class.is_mixin_app_alias());
   const Class& aliased_mixin_app_class = Class::Handle(isolate,
       mixin_class.SuperClass());
+  // Note that the super class of aliased_mixin_app_class can itself be a
+  // mixin application class (this happens if the alias is mixing more than one
+  // type). Instead of trying to recursively insert yet another class as the
+  // super class of this inserted class, we apply the composition rules of the
+  // spec and only mixin the members of aliased_mixin_app_class, not those of
+  // its super class. In other words, we only mixin the last mixin of the alias.
   const Type& aliased_mixin_type = Type::Handle(isolate,
       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(isolate, mixin_app_class.Name());
   inserted_class_name = String::Concat(inserted_class_name,
                                        Symbols::Backtick());
   const Library& library = Library::Handle(isolate, mixin_app_class.library());
   Class& inserted_class = Class::Handle(isolate,
       library.LookupLocalClass(inserted_class_name));
@@ skipping 14 matching lines @@
     // 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(isolate,
+    // After FinalizeTypesInClass, if the mixin type and interface type are
+    // generic, their type arguments will refer to the type parameters of
+    // inserted_class.
+    const Type& inserted_class_mixin_type = Type::Handle(isolate,
         Type::New(Class::Handle(isolate, aliased_mixin_type.type_class()),
                   Object::null_type_arguments(),
                   aliased_mixin_type.token_pos()));
-    inserted_class.set_mixin(generic_mixin_type);
+    inserted_class.set_mixin(inserted_class_mixin_type);
     // Add the mixin type to the list of interfaces that the mixin application
     // class implements. This is necessary so that cycle check work at
     // compile time (type arguments are ignored by that check).
     const Array& interfaces = Array::Handle(Array::New(1));
-    interfaces.SetAt(0, generic_mixin_type);
+    interfaces.SetAt(0, inserted_class_mixin_type);
     ASSERT(inserted_class.interfaces() == Object::empty_array().raw());
     inserted_class.set_interfaces(interfaces);
     // The type arguments of the interface, if any, will be set in
     // CloneMixinAppTypeParameters, which is called indirectly from
     // FinalizeTypesInClass below.
   }
 
   // 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 super type of the mixin
   // application alias 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 mixin application alias 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(isolate, super_type.type_class());
-  ASSERT(mixin_app_class.SuperClass() == super_class.raw());
-  while (super_class.IsMixinApplication()) {
-    super_class = super_class.SuperClass();
-  }
+  const Class& super_class = Class::Handle(isolate, super_type.type_class());
+  ASSERT(mixin_app_class.SuperClass() == super_class.raw());  // Will change.
   const intptr_t num_super_type_params = super_class.NumTypeParameters();
-  const intptr_t num_mixin_type_params = mixin_class.NumTypeParameters();
-  intptr_t offset =
-      mixin_class.NumTypeArguments() - mixin_class.NumTypeParameters();
-  const TypeArguments& type_params =
-      TypeArguments::Handle(isolate, mixin_app_class.type_parameters());
-  TypeArguments& instantiator = TypeArguments::Handle(isolate,
-      TypeArguments::New(offset + num_mixin_type_params));
   AbstractType& type = AbstractType::Handle(isolate);
-  for (intptr_t i = 0; i < num_mixin_type_params; i++) {
-    type = type_params.TypeAt(num_super_type_params + i);
-    instantiator.SetTypeAt(offset + i, type);
-  }
+  // The instantiator is mapping finalized type parameters of mixin_class to
+  // unfinalized type parameters of mixin_app_class.
   ASSERT(aliased_mixin_type.IsFinalized());
   const Class& aliased_mixin_type_class = Class::Handle(isolate,
       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));
+  const AbstractType& mixin_class_super_type =
+      AbstractType::Handle(isolate, mixin_class.super_type());
+  ASSERT(mixin_class_super_type.IsFinalized());
   // The aliased_mixin_type may be raw.
   const TypeArguments& mixin_class_super_type_args =
-      TypeArguments::Handle(isolate,
-          AbstractType::Handle(isolate, mixin_class.super_type()).arguments());
+      TypeArguments::Handle(isolate, mixin_class_super_type.arguments());
   TypeArguments& new_mixin_type_args = TypeArguments::Handle(isolate);
   if ((num_aliased_mixin_type_params > 0) &&
       !mixin_class_super_type_args.IsNull()) {
     new_mixin_type_args = TypeArguments::New(num_aliased_mixin_type_params);
+    AbstractType& bounded_type = AbstractType::Handle(isolate);
+    AbstractType& upper_bound = AbstractType::Handle(isolate);
+    TypeParameter& type_parameter = TypeParameter::Handle(isolate);
+    Error& bound_error = Error::Handle(isolate);
+    const intptr_t offset =
+        mixin_class_super_type_args.Length() - num_aliased_mixin_type_params;
     for (intptr_t i = 0; i < num_aliased_mixin_type_params; i++) {
       type = mixin_class_super_type_args.TypeAt(offset + i);
+      if (!type.IsInstantiated()) {
+        // In the presence of bounds, the bounded type and the upper bound must
+        // be instantiated separately. Instantiating a BoundedType would wrap
+        // the BoundedType in another BoundedType.
+        if (type.IsBoundedType()) {
+          bounded_type = BoundedType::Cast(type).type();
+          bounded_type = bounded_type.InstantiateFrom(instantiator,
+                                                      &bound_error);
+          // The instantiator contains only TypeParameter objects and no
+          // BoundedType objects, so no bound error may occur.
+          ASSERT(bound_error.IsNull());
+          upper_bound = BoundedType::Cast(type).bound();
+          upper_bound = upper_bound.InstantiateFrom(instantiator, &bound_error);
+          ASSERT(bound_error.IsNull());
+          type_parameter = BoundedType::Cast(type).type_parameter();
+          // The type parameter that declared the bound does not change.
+          type = BoundedType::New(bounded_type, upper_bound, type_parameter);
+        } else {
+          type = type.InstantiateFrom(instantiator, &bound_error);
+          ASSERT(bound_error.IsNull());
+        }
+      }
       new_mixin_type_args.SetTypeAt(i, type);
     }
   }
-  if (!new_mixin_type_args.IsNull() &&
-      !new_mixin_type_args.IsInstantiated()) {
-    Error& bound_error = Error::Handle(isolate);
-    new_mixin_type_args ^=
-        new_mixin_type_args.InstantiateFrom(instantiator, &bound_error);
-    // The instantiator contains only TypeParameter objects and no BoundedType
-    // objects, so no bound error may occur.
-    ASSERT(bound_error.IsNull());
-  }
   TypeArguments& new_super_type_args = TypeArguments::Handle(isolate);
   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);
+    const TypeArguments& type_params =
+        TypeArguments::Handle(isolate, mixin_app_class.type_parameters());
     for (intptr_t i = 0; i < num_super_type_params; i++) {
       type = type_params.TypeAt(i);
       new_super_type_args.SetTypeAt(i, type);
     }
     for (intptr_t i = 0; i < num_aliased_mixin_type_params; i++) {
       if (new_mixin_type_args.IsNull()) {
         type = Type::DynamicType();
       } else {
         type = new_mixin_type_args.TypeAt(i);
       }
       new_super_type_args.SetTypeAt(num_super_type_params + i, type);
     }
   }
   super_type = Type::New(inserted_class,
                          new_super_type_args,
                          mixin_app_class.token_pos());
   mixin_app_class.set_super_type(super_type);
 
-  // Perform the bound adjustment posponed from CloneMixinAppTypeParameters.
-  if (has_uninstantiated_bounds) {
-    TypeParameter& param = TypeParameter::Handle(isolate);
-    AbstractType& param_bound = AbstractType::Handle(isolate);
-    Error& bound_error = Error::Handle(isolate);
-    for (intptr_t i = 0; i < num_mixin_type_params; i++) {
-      param ^= type_params.TypeAt(num_super_type_params + i);
-      param_bound = param.bound();
-      if (!param_bound.IsInstantiated()) {
-        param_bound = param_bound.InstantiateFrom(instantiator, &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);
-      }
-    }
-  }
-
   // Mark this mixin application class as being an alias.
   mixin_app_class.set_is_mixin_app_alias();
   ASSERT(!mixin_app_class.is_type_finalized());
   ASSERT(!mixin_app_class.is_mixin_type_applied());
   if (FLAG_trace_class_finalization) {
-    OS::Print("Inserting class %s to mixin application alias %s "
-              "with super type '%s'\n",
-              inserted_class.ToCString(),
-              mixin_app_class.ToCString(),
-              String::Handle(isolate, super_type.Name()).ToCString());
+    OS::Print("Inserting class '%s' %s\n"
+              "  as super type '%s' with %" Pd " type args: %s\n"
+              "  of mixin application alias '%s' %s\n",
+              String::Handle(inserted_class.Name()).ToCString(),
+              TypeArguments::Handle(
+                  inserted_class.type_parameters()).ToCString(),
+              String::Handle(isolate, super_type.Name()).ToCString(),
+              num_super_type_params + num_aliased_mixin_type_params,
+              super_type.ToCString(),
+              String::Handle(mixin_app_class.Name()).ToCString(),
+              TypeArguments::Handle(
+                  mixin_app_class.type_parameters()).ToCString());
   }
 }
 
 
 void ClassFinalizer::ApplyMixinType(const Class& mixin_app_class,
                                     GrowableObjectArray* pending_types) {
   if (mixin_app_class.is_mixin_type_applied()) {
     return;
   }
   Type& mixin_type = Type::Handle(mixin_app_class.mixin());
   ASSERT(!mixin_type.IsNull());
   ASSERT(mixin_type.HasResolvedTypeClass());
   const Class& mixin_class = 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(),
               mixin_app_class.ToCString(),
               mixin_app_class.token_pos());
   }
 
-  // Check for illegal self references. This has to be done before checking
-  // that the super class of the mixin class is class Object.
+  // Check for illegal self references.
   GrowableArray<intptr_t> visited_mixins;
   if (!IsMixinCycleFree(mixin_class, &visited_mixins)) {
     const String& class_name = String::Handle(mixin_class.Name());
     ReportError(mixin_class, mixin_class.token_pos(),
                 "mixin class '%s' illegally refers to itself",
                 class_name.ToCString());
   }
 
-  // Check that the super class of the mixin class is class Object.
-  Class& mixin_super_class = Class::Handle(mixin_class.SuperClass());
-  // Skip over mixin application alias classes, which are implemented as
-  // subclasses of the mixin application classes they name.
-  if (!mixin_super_class.IsNull() && mixin_class.is_mixin_app_alias()) {
-    while (mixin_super_class.is_mixin_app_alias()) {
+  if (!FLAG_supermixin) {
+    // Check that the super class of the mixin class is class Object.
+    Class& mixin_super_class = Class::Handle(mixin_class.SuperClass());
+    // Skip over mixin application alias classes, which are implemented as
+    // subclasses of the mixin application classes they name.
+    if (!mixin_super_class.IsNull() && mixin_class.is_mixin_app_alias()) {
+      while (mixin_super_class.is_mixin_app_alias()) {
+        mixin_super_class = mixin_super_class.SuperClass();
+      }
       mixin_super_class = mixin_super_class.SuperClass();
     }
-    mixin_super_class = mixin_super_class.SuperClass();
-  }
-  if (mixin_super_class.IsNull() || !mixin_super_class.IsObjectClass()) {
-    const String& class_name = String::Handle(mixin_class.Name());
-    ReportError(mixin_app_class, mixin_app_class.token_pos(),
-                "mixin class '%s' must extend class 'Object'",
-                class_name.ToCString());
+    if (mixin_super_class.IsNull() || !mixin_super_class.IsObjectClass()) {
+      const String& class_name = String::Handle(mixin_class.Name());
+      ReportError(mixin_app_class, mixin_app_class.token_pos(),
+                  "mixin class '%s' must extend class 'Object'",
+                  class_name.ToCString());
+    }
   }
 
   // Copy type parameters to mixin application class.
   CloneMixinAppTypeParameters(mixin_app_class);
 
   // Verify that no restricted class is used as a mixin by checking the
   // interfaces of the mixin application class, which implements its mixin.
   GrowableArray<intptr_t> visited_interfaces;
   ResolveSuperTypeAndInterfaces(mixin_app_class, &visited_interfaces);
 
@@ skipping 245 matching lines @@
   AbstractType& interface_type = AbstractType::Handle();
   AbstractType& seen_interf = AbstractType::Handle();
   for (intptr_t i = 0; i < interface_types.Length(); i++) {
     interface_type ^= interface_types.At(i);
     interface_type = FinalizeType(cls, interface_type, kCanonicalizeWellFormed);
     interface_types.SetAt(i, interface_type);
 
     // Check whether the interface is duplicated. We need to wait with
     // this check until the super type and interface types are finalized,
     // so that we can use Type::Equals() for the test.
+    // TODO(regis): This restriction about duplicated interfaces may get lifted.
     ASSERT(interface_type.IsFinalized());
     ASSERT(super_type.IsNull() || super_type.IsFinalized());
     if (!super_type.IsNull() && interface_type.Equals(super_type)) {
       ReportError(cls, cls.token_pos(),
                   "super type '%s' may not be listed in "
                   "implements clause of class '%s'",
                   String::Handle(super_type.Name()).ToCString(),
                   String::Handle(cls.Name()).ToCString());
     }
     for (intptr_t j = 0; j < i; j++) {
@@ skipping 326 matching lines @@
   const GrowableObjectArray& type_args =
       GrowableObjectArray::Handle(isolate, GrowableObjectArray::New());
   AbstractType& mixin_super_type =
       AbstractType::Handle(isolate, mixin_app_type.super_type());
   ResolveType(cls, mixin_super_type);
   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(isolate);
-  Type& generic_mixin_type = Type::Handle(isolate);
   Class& mixin_type_class = Class::Handle(isolate);
   Class& mixin_app_class = Class::Handle(isolate);
   String& mixin_app_class_name = String::Handle(isolate);
   String& mixin_type_class_name = String::Handle(isolate);
   AbstractType& super_type_arg = AbstractType::Handle(isolate);
   AbstractType& mixin_type_arg = AbstractType::Handle(isolate);
   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());
@@ skipping 40 matching lines @@
     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_type_arguments(),
-                                     mixin_type.token_pos());
+      const Type& generic_mixin_type = Type::Handle(isolate,
+          Type::New(mixin_type_class,
+                    Object::null_type_arguments(),
+                    mixin_type.token_pos()));
       mixin_app_class.set_mixin(generic_mixin_type);
       // Add the mixin type to the list of interfaces that the mixin application
       // class implements. This is necessary so that cycle check work at
       // compile time (type arguments are ignored by that check).
       const Array& interfaces = Array::Handle(isolate, Array::New(1));
       interfaces.SetAt(0, generic_mixin_type);
       ASSERT(mixin_app_class.interfaces() == Object::empty_array().raw());
       mixin_app_class.set_interfaces(interfaces);
       mixin_app_class.set_is_synthesized_class();
       library.AddClass(mixin_app_class);
@@ skipping 480 matching lines @@
   ASSERT(fields_array.Length() == ByteBuffer::NumberOfFields());
   field ^= fields_array.At(0);
   ASSERT(field.Offset() == ByteBuffer::data_offset());
   name ^= field.name();
   expected_name ^= String::New("_data");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
 #endif
 }
 
 }  // namespace dart