diff --git a/pkg/front_end/testcases/legacy.status b/pkg/front_end/testcases/legacy.status
index aa3139e..4680b00 100644
--- a/pkg/front_end/testcases/legacy.status
+++ b/pkg/front_end/testcases/legacy.status
@@ -29,6 +29,7 @@
 inference/unsafe_block_closure_inference_function_call_explicit_type_param_via_expr2: RuntimeError
 instantiate_to_bound/body_typedef_super_bounded_type: Fail # Issue 33444
 instantiate_to_bound/non_simple_class_parametrized_typedef_cycle: RuntimeError # May be related to Issue 33479
+instantiate_to_bound/non_simple_generic_function_in_bound_regress: RuntimeError # Expected
 instantiate_to_bound/typedef_super_bounded_type: Fail # Issue 33444
 invocations: Fail
 micro: Fail # External method marked abstract.
@@ -113,6 +114,7 @@
 regress/issue_35259: RuntimeError # Expected
 regress/issue_35260: RuntimeError # Expected
 regress/issue_35266: RuntimeError # Expected
+reject_generic_function_types_in_bounds: RuntimeError # Expected
 runtime_checks/implicit_downcast_constructor_initializer: RuntimeError # Test exercises strong mode semantics
 runtime_checks/implicit_downcast_do: RuntimeError # Test exercises strong mode semantics
 runtime_checks/implicit_downcast_for_condition: RuntimeError # Test exercises strong mode semantics
diff --git a/pkg/front_end/testcases/strong.status b/pkg/front_end/testcases/strong.status
index 91dfdd9..11db99d 100644
--- a/pkg/front_end/testcases/strong.status
+++ b/pkg/front_end/testcases/strong.status
@@ -66,6 +66,8 @@
 inference_new/infer_field_getter_setter_mismatch: TypeCheckError
 inference_new/infer_field_override_getter_overrides_setter: TypeCheckError
 inference_new/invalid_assignment_during_toplevel_inference: TypeCheckError
+instantiate_to_bound/non_simple_generic_function_in_bound_regress: RuntimeError # Expected
+instantiate_to_bound/non_simple_class_parametrized_typedef_cycle: RuntimeError # Expected
 invalid_type: TypeCheckError
 invocations: RuntimeError
 issue34899: TypeCheckError
@@ -139,6 +141,7 @@
 regress/issue_35259: RuntimeError # Expected
 regress/issue_35260: RuntimeError # Expected
 regress/issue_35266: RuntimeError # Expected
+reject_generic_function_types_in_bounds: RuntimeError # Expected
 runtime_checks_new/contravariant_generic_return_with_compound_assign_implicit_downcast: RuntimeError
 runtime_checks_new/mixin_forwarding_stub_field: TypeCheckError
 runtime_checks_new/mixin_forwarding_stub_getter: TypeCheckError
diff --git a/runtime/lib/mirrors.cc b/runtime/lib/mirrors.cc
index 37756f2..d4916d0 100644
--- a/runtime/lib/mirrors.cc
+++ b/runtime/lib/mirrors.cc
@@ -316,24 +316,16 @@
     return CreateTypedefMirror(cls, type, is_declaration, owner_mirror);
   }
 
-  const Array& args = Array::Handle(Array::New(10));
+  const Array& args = Array::Handle(Array::New(9));
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(cls)));
   args.SetAt(1, type);
-  // Note that the VM does not consider mixin application aliases to be mixin
-  // applications, so this only covers anonymous mixin applications. We do not
-  // set the names of anonymous mixin applications here because the mirrors
-  // use a different naming convention than the VM (lib.S with lib.M and S&M
-  // respectively).
-  if (!cls.IsMixinApplication()) {
-    args.SetAt(2, String::Handle(cls.Name()));
-  }
+  args.SetAt(2, String::Handle(cls.Name()));
   args.SetAt(3, owner_mirror);
   args.SetAt(4, Bool::Get(cls.is_abstract()));
   args.SetAt(5, Bool::Get(cls.IsGeneric()));
-  args.SetAt(6, Bool::Get(cls.is_mixin_app_alias()));
-  args.SetAt(7, Bool::Get(cls.is_transformed_mixin_application()));
-  args.SetAt(8, cls.NumTypeParameters() == 0 ? Bool::False() : is_declaration);
-  args.SetAt(9, Bool::Get(cls.is_enum_class()));
+  args.SetAt(6, Bool::Get(cls.is_transformed_mixin_application()));
+  args.SetAt(7, cls.NumTypeParameters() == 0 ? Bool::False() : is_declaration);
+  args.SetAt(8, Bool::Get(cls.is_enum_class()));
   return CreateMirror(Symbols::_LocalClassMirror(), args);
 }
 
@@ -930,8 +922,6 @@
   if (cls.is_transformed_mixin_application()) {
     const Array& interfaces = Array::Handle(cls.interfaces());
     mixin_type ^= interfaces.At(interfaces.Length() - 1);
-  } else {
-    mixin_type = cls.mixin();
   }
   ASSERT(mixin_type.IsNull() || mixin_type.IsFinalized());
   return mixin_type.raw();
@@ -947,8 +937,6 @@
   if (cls.is_transformed_mixin_application()) {
     const Array& interfaces = Array::Handle(cls.interfaces());
     mixin_type ^= interfaces.At(interfaces.Length() - 1);
-  } else {
-    mixin_type = cls.mixin();
   }
   if (mixin_type.IsNull()) {
     return mixin_type.raw();
@@ -1057,11 +1045,9 @@
     entry = entries.GetNext();
     if (entry.IsClass()) {
       const Class& klass = Class::Cast(entry);
-      // We filter out mixin application classes and dynamic.
+      // We filter out dynamic.
       // TODO(12478): Should not need to filter out dynamic.
-      // Note that the VM does not consider mixin application aliases to be
-      // mixin applications.
-      if (!klass.IsDynamicClass() && !klass.IsMixinApplication()) {
+      if (!klass.IsDynamicClass()) {
         type = klass.DeclarationType();
         member_mirror = CreateClassMirror(klass, type,
                                           Bool::True(),  // is_declaration
@@ -1347,7 +1333,8 @@
   Class& redirected_klass = Class::Handle(klass.raw());
   Function& redirected_constructor = Function::Handle(lookup_constructor.raw());
   if (lookup_constructor.IsRedirectingFactory()) {
-    ClassFinalizer::ResolveRedirectingFactory(klass, lookup_constructor);
+    // Redirecting factory must be resolved.
+    ASSERT(lookup_constructor.RedirectionTarget() != Function::null());
     Type& redirect_type = Type::Handle(lookup_constructor.RedirectionType());
 
     if (!redirect_type.IsInstantiated()) {
@@ -1548,8 +1535,7 @@
   } else if (decl.IsClass()) {
     const Class& cls = Class::Cast(decl);
     const bool is_typedef = cls.IsTypedefClass();
-    if (cls.is_synthesized_class() && !is_typedef &&
-        !cls.is_mixin_app_alias() && !cls.is_enum_class()) {
+    if (cls.is_synthesized_class() && !is_typedef && !cls.is_enum_class()) {
       return Instance::null();  // Synthetic.
     }
     script = cls.script();
diff --git a/runtime/lib/mirrors_impl.dart b/runtime/lib/mirrors_impl.dart
index 902e7ff..b11223b 100644
--- a/runtime/lib/mirrors_impl.dart
+++ b/runtime/lib/mirrors_impl.dart
@@ -368,10 +368,6 @@
   final bool isAbstract;
   final bool _isGeneric;
 
-  // Only used for Dart 1 named mixin applications.
-  // TODO(alexmarkov): Clean up after Dart 1 is gone.
-  final bool _isMixinAlias;
-
   // Since Dart 2, mixins are erased by kernel transformation.
   // Resulting classes have this flag set, and mixed-in type is pulled into
   // the end of interfaces list.
@@ -388,7 +384,6 @@
       this._owner,
       this.isAbstract,
       this._isGeneric,
-      this._isMixinAlias,
       this._isTransformedMixinApplication,
       this._isGenericDeclaration,
       this.isEnum)
@@ -455,7 +450,7 @@
   }
 
   ClassMirror get superclass {
-    return _isMixinAlias ? _trueSuperclass._trueSuperclass : _trueSuperclass;
+    return _trueSuperclass;
   }
 
   var _superinterfaces;
@@ -492,19 +487,13 @@
   var _mixin;
   ClassMirror get mixin {
     if (_mixin == null) {
-      if (_isMixinAlias) {
-        Type mixinType = _nativeMixinInstantiated(
-            _trueSuperclass._reflectedType, _instantiator);
-        _mixin = reflectType(mixinType);
+      Type mixinType =
+          _nativeMixinInstantiated(_reflectedType, _instantiator);
+      if (mixinType == null) {
+        // The reflectee is not a mixin application.
+        _mixin = this;
       } else {
-        Type mixinType =
-            _nativeMixinInstantiated(_reflectedType, _instantiator);
-        if (mixinType == null) {
-          // The reflectee is not a mixin application.
-          _mixin = this;
-        } else {
-          _mixin = reflectType(mixinType);
-        }
+        _mixin = reflectType(mixinType);
       }
     }
     return _mixin;
@@ -572,9 +561,8 @@
 
     var decls = new Map<Symbol, DeclarationMirror>();
 
-    var whoseMembers = _isMixinAlias ? _trueSuperclass : this;
     var members = (mixin as _LocalClassMirror)._computeMembers(
-        _instantiator, (whoseMembers.mixin as _LocalClassMirror)._reflectee);
+        _instantiator, (mixin as _LocalClassMirror)._reflectee);
     for (var member in members) {
       decls[member.simpleName] = member;
     }
@@ -596,7 +584,6 @@
 
   // Note: returns correct result only for Dart 1 anonymous mixin applications.
   bool get _isAnonymousMixinApplication {
-    if (_isMixinAlias) return false; // Named mixin application.
     if (mixin == this) return false; // Not a mixin application.
     return true;
   }
@@ -760,7 +747,7 @@
   final _functionReflectee;
   _LocalFunctionTypeMirror(reflectee, this._functionReflectee, reflectedType)
       : super(reflectee, reflectedType, null, null, false, false, false, false,
-            false, false);
+            false);
 
   bool get _isAnonymousMixinApplication => false;
 
diff --git a/runtime/lib/type_patch.dart b/runtime/lib/type_patch.dart
index 21fac26..a05ce70 100644
--- a/runtime/lib/type_patch.dart
+++ b/runtime/lib/type_patch.dart
@@ -25,7 +25,3 @@
 // Equivalent of RawTypeParameter.
 @pragma("vm:entry-point")
 class _TypeParameter extends _AbstractType {}
-
-// Equivalent of RawMixinAppType.
-@pragma("vm:entry-point")
-class _MixinAppType extends _AbstractType {}
diff --git a/runtime/observatory/tests/service/get_version_rpc_test.dart b/runtime/observatory/tests/service/get_version_rpc_test.dart
index dc2c129..9b1fb1a 100644
--- a/runtime/observatory/tests/service/get_version_rpc_test.dart
+++ b/runtime/observatory/tests/service/get_version_rpc_test.dart
@@ -12,7 +12,7 @@
     var result = await vm.invokeRpcNoUpgrade('getVersion', {});
     expect(result['type'], equals('Version'));
     expect(result['major'], equals(3));
-    expect(result['minor'], equals(12));
+    expect(result['minor'], equals(13));
     expect(result['_privateMajor'], equals(0));
     expect(result['_privateMinor'], equals(0));
   },
diff --git a/runtime/vm/class_finalizer.cc b/runtime/vm/class_finalizer.cc
index 8d9ea57..fd69a3d 100644
--- a/runtime/vm/class_finalizer.cc
+++ b/runtime/vm/class_finalizer.cc
@@ -192,11 +192,11 @@
     class_array = object_store->pending_classes();
     ASSERT(!class_array.IsNull());
     Class& cls = Class::Handle();
-    // First resolve all superclasses.
+    // First check all superclasses.
     for (intptr_t i = 0; i < class_array.Length(); i++) {
       cls ^= class_array.At(i);
       GrowableArray<intptr_t> visited_interfaces;
-      ResolveSuperTypeAndInterfaces(cls, &visited_interfaces);
+      CheckSuperTypeAndInterfaces(cls, &visited_interfaces);
     }
     // Finalize all classes.
     for (intptr_t i = 0; i < class_array.Length(); i++) {
@@ -223,22 +223,6 @@
   return true;
 }
 
-// Adds all interfaces of cls into 'collected'. Duplicate entries may occur.
-// No cycles are allowed.
-void ClassFinalizer::CollectInterfaces(const Class& cls,
-                                       GrowableArray<const Class*>* collected) {
-  Zone* zone = Thread::Current()->zone();
-  const Array& interface_array = Array::Handle(zone, cls.interfaces());
-  AbstractType& interface = AbstractType::Handle(zone);
-  Class& interface_class = Class::Handle(zone);
-  for (intptr_t i = 0; i < interface_array.Length(); i++) {
-    interface ^= interface_array.At(i);
-    interface_class = interface.type_class();
-    collected->Add(&Class::ZoneHandle(zone, interface_class.raw()));
-    CollectInterfaces(interface_class, collected);
-  }
-}
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 void ClassFinalizer::VerifyBootstrapClasses() {
   if (FLAG_trace_class_finalization) {
@@ -307,220 +291,12 @@
 }
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 
-void ClassFinalizer::ResolveRedirectingFactory(const Class& cls,
-                                               const Function& factory) {
-  const Function& target = Function::Handle(factory.RedirectionTarget());
-  if (target.IsNull()) {
-    Type& type = Type::Handle(factory.RedirectionType());
-    const GrowableObjectArray& visited_factories =
-        GrowableObjectArray::Handle(GrowableObjectArray::New());
-    ResolveRedirectingFactoryTarget(cls, factory, visited_factories);
-    if (factory.is_const()) {
-      type = factory.RedirectionType();
-    }
-  }
-}
-
-void ClassFinalizer::ResolveRedirectingFactoryTarget(
-    const Class& cls,
-    const Function& factory,
-    const GrowableObjectArray& visited_factories) {
-  ASSERT(factory.IsRedirectingFactory());
-
-  // Check for redirection cycle.
-  for (intptr_t i = 0; i < visited_factories.Length(); i++) {
-    if (visited_factories.At(i) == factory.raw()) {
-      // A redirection cycle is reported as a compile-time error.
-      ReportError(cls, factory.token_pos(),
-                  "factory '%s' illegally redirects to itself",
-                  String::Handle(factory.name()).ToCString());
-    }
-  }
-  visited_factories.Add(factory);
-
-  // Check if target is already resolved.
-  Type& type = Type::Handle(factory.RedirectionType());
-  Function& target = Function::Handle(factory.RedirectionTarget());
-  if (!target.IsNull()) {
-    // Already resolved.
-    return;
-  }
-
-  // Target is not resolved yet.
-  if (FLAG_trace_class_finalization) {
-    THR_Print("Resolving redirecting factory: %s\n",
-              String::Handle(factory.name()).ToCString());
-  }
-  type ^= FinalizeType(cls, type);
-  factory.SetRedirectionType(type);
-  ASSERT(!type.IsTypeParameter());  // Resolved in parser.
-  ASSERT(!type.IsDynamicType());
-  const Class& target_class = Class::Handle(type.type_class());
-  String& target_class_name = String::Handle(target_class.Name());
-  String& target_name =
-      String::Handle(String::Concat(target_class_name, Symbols::Dot()));
-  const String& identifier = String::Handle(factory.RedirectionIdentifier());
-  if (!identifier.IsNull()) {
-    target_name = String::Concat(target_name, identifier);
-  }
-
-  // Verify that the target constructor of the redirection exists.
-  target = target_class.LookupConstructor(target_name);
-  if (target.IsNull()) {
-    target = target_class.LookupFactory(target_name);
-  }
-  ASSERT(!target.IsNull());
-  // Verify that the target is const if the redirecting factory is const.
-  if (factory.is_const() && !target.is_const()) {
-    ReportError(target_class, target.token_pos(),
-                "constructor '%s' must be const as required by "
-                "redirecting const factory '%s'",
-                String::Handle(target.name()).ToCString(),
-                String::Handle(factory.name()).ToCString());
-  }
-
-  // Update redirection data with resolved target.
-  factory.SetRedirectionTarget(target);
-  // Not needed anymore.
-  factory.SetRedirectionIdentifier(Object::null_string());
-  if (!target.IsRedirectingFactory()) {
-    return;
-  }
-
-  // The target is itself a redirecting factory. Recursively resolve its own
-  // target and update the current redirection data to point to the end target
-  // of the redirection chain.
-  ResolveRedirectingFactoryTarget(target_class, target, visited_factories);
-  Type& target_type = Type::Handle(target.RedirectionType());
-  Function& target_target = Function::Handle(target.RedirectionTarget());
-  ASSERT(!target_target.IsNull());
-  // If the target type refers to type parameters, substitute them with the
-  // type arguments of the redirection type.
-  if (!target_type.IsInstantiated()) {
-    // We do not support generic constructors.
-    ASSERT(target_type.IsInstantiated(kFunctions));
-    const TypeArguments& type_args = TypeArguments::Handle(type.arguments());
-    target_type ^= target_type.InstantiateFrom(
-        type_args, Object::null_type_arguments(), kNoneFree, NULL, Heap::kOld);
-  }
-  factory.SetRedirectionType(target_type);
-  factory.SetRedirectionTarget(target_target);
-}
-
-void ClassFinalizer::ResolveTypeClass(const Class& cls, const Type& type) {
-  if (type.IsFinalized()) {
-    return;
-  }
-  if (FLAG_trace_type_finalization) {
-    THR_Print("Resolve type class of '%s'\n",
-              String::Handle(type.Name()).ToCString());
-  }
-
-  // Type parameters are always resolved in the parser in the correct
-  // non-static scope or factory scope. That resolution scope is unknown here.
-  // Being able to resolve a type parameter from class cls here would indicate
-  // that the type parameter appeared in a static scope. Leaving the type as
-  // unresolved is the correct thing to do.
-
-  // Lookup the type class if necessary.
-  Class& type_class = Class::Handle(type.type_class());
-  // Promote the type to a function type in case its type class is a typedef.
-  // Note that the type may already be a function type if it was parsed as a
-  // formal parameter function type.
-  if (!type.IsFunctionType() && type_class.IsTypedefClass()) {
-    type.set_signature(Function::Handle(type_class.signature_function()));
-  }
-  ASSERT(!type_class.IsTypedefClass() ||
-         (type.signature() != Function::null()));
-}
-
-void ClassFinalizer::ResolveType(const Class& cls, const AbstractType& type) {
-  if (type.IsResolved()) {
-    return;
-  }
-  if (FLAG_trace_type_finalization) {
-    THR_Print("Resolve type '%s'\n", String::Handle(type.Name()).ToCString());
-  }
-  if (type.IsType()) {
-    ResolveTypeClass(cls, Type::Cast(type));
-  }
-  // Mark type as resolved before resolving its type arguments and, in case of a
-  // function type, its signature, in order to avoid cycles.
-  type.SetIsResolved();
-  // Resolve type arguments, if any.
-  const TypeArguments& arguments = TypeArguments::Handle(type.arguments());
-  if (!arguments.IsNull()) {
-    const intptr_t num_arguments = arguments.Length();
-    AbstractType& type_argument = AbstractType::Handle();
-    for (intptr_t i = 0; i < num_arguments; i++) {
-      type_argument = arguments.TypeAt(i);
-      ResolveType(cls, type_argument);
-    }
-  }
-  // Resolve signature if function type.
-  if (type.IsFunctionType()) {
-    const Function& signature = Function::Handle(Type::Cast(type).signature());
-    Type& signature_type = Type::Handle(signature.SignatureType());
-    if (signature_type.raw() != type.raw()) {
-      // This type was promoted to a function type because its type class is a
-      // typedef class. The promotion is achieved by assigning the signature
-      // function of the typedef class to this type. This function is pointing
-      // to the original typedef function type, which is not this type.
-      // By resolving the typedef function type (which may already be resolved,
-      // hence saving work), we will resolve the shared signature function.
-      ASSERT(Class::Handle(type.type_class()).IsTypedefClass());
-      ResolveType(cls, signature_type);
-    } else {
-      const Class& scope_class = Class::Handle(type.type_class());
-      if (scope_class.IsTypedefClass()) {
-        // This type is the original function type of the typedef class.
-        ResolveSignature(scope_class, signature);
-      } else {
-        ASSERT(scope_class.IsClosureClass());
-        ResolveSignature(cls, signature);
-        ASSERT(type.arguments() == TypeArguments::null());
-        if (signature.IsSignatureFunction()) {
-          // Drop fields that are not necessary anymore after resolution.
-          // The parent function, owner, and token position of a shared
-          // canonical function type are meaningless, since the canonical
-          // representent is picked arbitrarily.
-          // The parent function is however still required to finalize function
-          // type parameters when the function has a generic parent.
-          if (!signature.HasGenericParent()) {
-            signature.set_parent_function(Function::Handle());
-          }
-          // TODO(regis): As long as we support metadata in typedef signatures,
-          // we cannot reset these fields used to reparse a typedef.
-          // Note that the scope class of a typedef function type is always
-          // preserved as the typedef class (not reset to _Closure class),
-          // thereby preventing sharing of canonical function types between
-          // typedefs. Not being shared, these fields are therefore always
-          // meaningful for typedefs.
-          if (!scope_class.IsTypedefClass()) {
-            signature.set_owner(Object::Handle());
-            signature.set_token_pos(TokenPosition::kNoSource);
-          }
-        }
-      }
-    }
-  }
-
-  // After resolving, we re-initialize the type testing stub.
-  type.SetTypeTestingStub(
-      Instructions::Handle(TypeTestingStubGenerator::DefaultCodeForType(type)));
-}
-
 void ClassFinalizer::FinalizeTypeParameters(const Class& cls,
                                             PendingTypes* pending_types) {
   if (FLAG_trace_type_finalization) {
     THR_Print("Finalizing type parameters of '%s'\n",
               String::Handle(cls.Name()).ToCString());
   }
-  if (cls.IsMixinApplication()) {
-    // Setup the type parameters of the mixin application and finalize the
-    // mixin type.
-    ApplyMixinType(cls, pending_types);
-  }
   // The type parameter bounds are not finalized here.
   const TypeArguments& type_parameters =
       TypeArguments::Handle(cls.type_parameters());
@@ -627,15 +403,11 @@
     const AbstractType& type,
     PendingTypes* pending_types) {
   Zone* zone = Thread::Current()->zone();
-  // The type class does not need to be finalized in order to finalize the type,
-  // however, it must at least be resolved (this was done as part of resolving
-  // the type itself, a precondition to calling FinalizeType).
-  // Also, the interfaces of the type class must be resolved and the type
-  // parameters of the type class must be finalized.
+  // The type class does not need to be finalized in order to finalize the type.
+  // Also, the type parameters of the type class must be finalized.
   Class& type_class = Class::Handle(zone, type.type_class());
   if (!type_class.is_type_finalized()) {
     FinalizeTypeParameters(type_class, pending_types);
-    ResolveUpperBounds(type_class);
   }
 
   // The finalized type argument vector needs num_type_arguments types.
@@ -778,7 +550,6 @@
   ASSERT(arguments.Length() >= cls.NumTypeArguments());
   if (!cls.is_type_finalized()) {
     FinalizeTypeParameters(cls, pending_types);
-    ResolveUpperBounds(cls);
   }
   AbstractType& super_type = AbstractType::Handle(cls.super_type());
   if (!super_type.IsNull()) {
@@ -917,7 +688,6 @@
   ASSERT(!type.IsBeingFinalized());
 
   Zone* zone = Thread::Current()->zone();
-  ResolveType(cls, type);
 
   if (FLAG_trace_type_finalization) {
     THR_Print("Finalizing type '%s' for class '%s'\n",
@@ -944,14 +714,8 @@
       ASSERT(!function.IsNull());
       offset = function.NumParentTypeParameters();
     }
-    // Calling NumTypeParameters() may finalize this type parameter if it
-    // belongs to a mixin application class.
-    if (!type_parameter.IsFinalized()) {
-      type_parameter.set_index(type_parameter.index() + offset);
-      type_parameter.SetIsFinalized();
-    } else {
-      ASSERT(cls.IsMixinApplication());
-    }
+    type_parameter.set_index(type_parameter.index() + offset);
+    type_parameter.SetIsFinalized();
 
     if (FLAG_trace_type_finalization) {
       THR_Print("Done finalizing type parameter '%s' with index %" Pd "\n",
@@ -1056,46 +820,6 @@
   }
 }
 
-void ClassFinalizer::ResolveSignature(const Class& cls,
-                                      const Function& function) {
-  AbstractType& type = AbstractType::Handle();
-  // Resolve upper bounds of function type parameters.
-  const intptr_t num_type_params = function.NumTypeParameters();
-  if (num_type_params > 0) {
-    TypeParameter& type_param = TypeParameter::Handle();
-    const TypeArguments& type_params =
-        TypeArguments::Handle(function.type_parameters());
-    for (intptr_t i = 0; i < num_type_params; i++) {
-      type_param ^= type_params.TypeAt(i);
-      type = type_param.bound();
-      ResolveType(cls, type);
-      if (type.IsFunctionType()) {
-        const Function& signature_function =
-            Function::Handle(Type::Cast(type).signature());
-        if (signature_function.IsGeneric()) {
-          const String& type_name = String::Handle(type.UserVisibleName());
-          const String& type_param_name = String::Handle(type_param.name());
-          ReportError(cls, type.token_pos(),
-                      "generic function type '%s' not allowed as bound of "
-                      "function type parameter '%s'",
-                      type_name.ToCString(), type_param_name.ToCString());
-        }
-      }
-    }
-  }
-  // Resolve result type.
-  type = function.result_type();
-  // It is not a compile time error if this name does not resolve to a class or
-  // interface.
-  ResolveType(cls, type);
-  // Resolve formal parameter types.
-  const intptr_t num_parameters = function.NumParameters();
-  for (intptr_t i = 0; i < num_parameters; i++) {
-    type = function.ParameterTypeAt(i);
-    ResolveType(cls, type);
-  }
-}
-
 void ClassFinalizer::FinalizeSignature(const Class& cls,
                                        const Function& function,
                                        FinalizationKind finalization) {
@@ -1140,36 +864,6 @@
   }
 }
 
-// Resolve the upper bounds of the type parameters of class cls.
-void ClassFinalizer::ResolveUpperBounds(const Class& cls) {
-  const intptr_t num_type_params = cls.NumTypeParameters();
-  TypeParameter& type_param = TypeParameter::Handle();
-  AbstractType& bound = AbstractType::Handle();
-  const TypeArguments& type_params =
-      TypeArguments::Handle(cls.type_parameters());
-  ASSERT((type_params.IsNull() && (num_type_params == 0)) ||
-         (type_params.Length() == num_type_params));
-  // In a first pass, resolve all bounds. This guarantees that finalization
-  // of mutually referencing bounds will not encounter an unresolved bound.
-  for (intptr_t i = 0; i < num_type_params; i++) {
-    type_param ^= type_params.TypeAt(i);
-    bound = type_param.bound();
-    ResolveType(cls, bound);
-    if (bound.IsFunctionType()) {
-      const Function& signature_function =
-          Function::Handle(Type::Cast(bound).signature());
-      if (signature_function.IsGeneric()) {
-        const String& bound_name = String::Handle(bound.UserVisibleName());
-        const String& type_param_name = String::Handle(type_param.name());
-        ReportError(cls, bound.token_pos(),
-                    "generic function type '%s' not allowed as bound of "
-                    "class type parameter '%s'",
-                    bound_name.ToCString(), type_param_name.ToCString());
-      }
-    }
-  }
-}
-
 // Finalize the upper bounds of the type parameters of class cls.
 void ClassFinalizer::FinalizeUpperBounds(const Class& cls,
                                          FinalizationKind finalization) {
@@ -1183,6 +877,18 @@
   for (intptr_t i = 0; i < num_type_params; i++) {
     type_param ^= type_params.TypeAt(i);
     bound = type_param.bound();
+    if (bound.IsFunctionType()) {
+      const Function& signature_function =
+          Function::Handle(Type::Cast(bound).signature());
+      if (signature_function.IsGeneric()) {
+        const String& bound_name = String::Handle(bound.UserVisibleName());
+        const String& type_param_name = String::Handle(type_param.name());
+        ReportError(cls, bound.token_pos(),
+                    "generic function type '%s' not allowed as bound of "
+                    "class type parameter '%s'",
+                    bound_name.ToCString(), type_param_name.ToCString());
+      }
+    }
     // Bound may be finalized, but not canonical yet.
     if (bound.IsCanonical() || bound.IsBeingFinalized()) {
       // A bound involved in F-bounded quantification may form a cycle.
@@ -1212,7 +918,7 @@
 }
 #endif
 
-void ClassFinalizer::ResolveAndFinalizeMemberTypes(const Class& cls) {
+void ClassFinalizer::FinalizeMemberTypes(const Class& cls) {
   // Note that getters and setters are explicitly listed as such in the list of
   // functions of a class, so we do not need to consider fields as implicitly
   // generating getters and setters.
@@ -1232,7 +938,7 @@
   // - an instance field or instance getter conflicting with an inherited
   //   instance method.
 
-  // Resolve type of fields and check for conflicts in super classes.
+  // Finalize type of fields and check for conflicts in super classes.
   Isolate* isolate = Isolate::Current();
   Zone* zone = Thread::Current()->zone();
   Array& array = Array::Handle(zone, cls.fields());
@@ -1250,7 +956,7 @@
           StaticTypeExactnessState::Unitialized());
     }
   }
-  // Resolve function signatures and check for conflicts in super classes and
+  // Finalize function signatures and check for conflicts in super classes and
   // interfaces.
   array = cls.functions();
   Function& function = Function::Handle(zone);
@@ -1263,11 +969,6 @@
     }
     if (function.is_static()) {
       if (function.IsRedirectingFactory()) {
-        // The function may be a still unresolved redirecting factory. Do not
-        // yet try to resolve it in order to avoid cycles in class finalization.
-        // However, the redirection type should be finalized.
-        // If the redirection type is from a deferred library and is not
-        // yet loaded, do not attempt to resolve.
         Type& type = Type::Handle(zone, function.RedirectionType());
         type ^= FinalizeType(cls, type);
         function.SetRedirectionType(type);
@@ -1276,654 +977,6 @@
   }
 }
 
-// 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 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 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());
-  Thread* thread = Thread::Current();
-  Zone* zone = thread->zone();
-  const AbstractType& super_type =
-      AbstractType::Handle(zone, mixin_app_class.super_type());
-  ASSERT(super_type.IsResolved());
-  const Class& super_class = Class::Handle(zone, super_type.type_class());
-  const intptr_t num_super_type_params = super_class.NumTypeParameters();
-  const Type& mixin_type = Type::Handle(zone, mixin_app_class.mixin());
-  const Class& mixin_class = Class::Handle(zone, mixin_type.type_class());
-  const intptr_t num_mixin_type_params = mixin_class.NumTypeParameters();
-
-  // 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.
-  TypeArguments& instantiator = TypeArguments::Handle(zone);
-  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(zone, mixin_app_class.Name());
-      for (intptr_t i = name.Length() - 1; i > 0; --i) {
-        if (name.CharAt(i) == '&') {
-          if (name.CharAt(i - 1) == '&') {
-            share_type_params = true;
-          }
-          break;
-        }
-      }
-    }
-
-    const TypeArguments& cloned_type_params = TypeArguments::Handle(
-        zone,
-        TypeArguments::New((share_type_params ? 0 : num_super_type_params) +
-                           num_mixin_type_params));
-    TypeParameter& param = TypeParameter::Handle(zone);
-    TypeParameter& cloned_param = TypeParameter::Handle(zone);
-    String& param_name = String::Handle(zone);
-    AbstractType& param_bound = AbstractType::Handle(zone);
-    Function& null_function = Function::Handle(zone);
-    intptr_t cloned_index = 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(zone, super_class.type_parameters());
-      const TypeArguments& super_type_args = TypeArguments::Handle(
-          zone, 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. 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 = thread->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 =
-            Symbols::FromConcat(thread, param_name, Symbols::Backtick());
-        cloned_param =
-            TypeParameter::New(mixin_app_class, null_function, 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++;
-      }
-      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. We also retain the type parameter bounds.
-    if (num_mixin_type_params > 0) {
-      const TypeArguments& mixin_params =
-          TypeArguments::Handle(zone, mixin_class.type_parameters());
-      const intptr_t offset =
-          mixin_class.NumTypeArguments() - mixin_class.NumTypeParameters();
-      const TypeArguments& mixin_type_args = TypeArguments::Handle(
-          zone, 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, null_function,
-                               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);  // 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 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) {
-        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);
-              param.set_bound(param_bound);  // In case part of recursive type.
-            }
-            param_bound = param_bound.InstantiateFrom(
-                instantiator, Object::null_type_arguments(), kNoneFree, NULL,
-                Heap::kOld);
-            // The instantiator contains only TypeParameter objects.
-            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, instantiator);
-  }
-}
-
-/* Support for mixin alias.
-Consider the following example:
-
-class I<T> { }
-class J<T> { }
-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 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 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.
-
-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 List> extends S<T`> implements A<U, V> { }
-
-We now have:
-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 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 is done in CloneMixinAppTypeParameters above, and the
-already built instantiator is passed here.
-
-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,
-                                        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.
-  Thread* thread = Thread::Current();
-  Zone* zone = thread->zone();
-  AbstractType& super_type =
-      AbstractType::Handle(zone, mixin_app_class.super_type());
-  const Type& mixin_type = Type::Handle(zone, mixin_app_class.mixin());
-  const Class& mixin_class = Class::Handle(zone, mixin_type.type_class());
-  ASSERT(mixin_class.is_mixin_app_alias());
-  const Class& aliased_mixin_app_class =
-      Class::Handle(zone, 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(zone, 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(zone, mixin_app_class.Name());
-  inserted_class_name =
-      String::Concat(inserted_class_name, Symbols::Backtick());
-  const Library& library = Library::Handle(zone, mixin_app_class.library());
-  Class& inserted_class =
-      Class::Handle(zone, library.LookupLocalClass(inserted_class_name));
-  if (inserted_class.IsNull()) {
-    inserted_class_name = Symbols::New(thread, inserted_class_name);
-    const Script& script = Script::Handle(zone, mixin_app_class.script());
-    inserted_class = Class::New(library, inserted_class_name, script,
-                                mixin_app_class.token_pos());
-    inserted_class.set_is_synthesized_class();
-    library.AddClass(inserted_class);
-
-    if (FLAG_trace_class_finalization) {
-      THR_Print("Creating mixin application alias %s\n",
-                inserted_class.ToCString());
-    }
-
-    // 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, 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(
-        zone, Type::New(Class::Handle(zone, aliased_mixin_type.type_class()),
-                        Object::null_type_arguments(),
-                        aliased_mixin_type.token_pos()));
-    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, 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.
-  const Class& super_class = Class::Handle(zone, super_type.type_class());
-  ASSERT(mixin_app_class.SuperClass() == super_class.raw());  // Will change.
-  const intptr_t num_super_type_params = super_class.NumTypeParameters();
-  AbstractType& type = AbstractType::Handle(zone);
-  // The instantiator is mapping finalized type parameters of mixin_class to
-  // unfinalized type parameters of mixin_app_class. Therefore, the type
-  // arguments of mixin_class_super_type must be finalized, since they get
-  // instantiated by this instantiator. Finalizing the types in mixin_class
-  // will finalize mixin_class_super_type.
-  // The aliased_mixin_type does not need to be finalized, but only resolved.
-  ASSERT(aliased_mixin_type.IsResolved());
-  const Class& aliased_mixin_type_class =
-      Class::Handle(zone, aliased_mixin_type.type_class());
-  FinalizeTypesInClass(mixin_class);
-  const intptr_t num_aliased_mixin_type_params =
-      aliased_mixin_type_class.NumTypeParameters();
-  ASSERT(inserted_class.NumTypeParameters() ==
-         (num_super_type_params + num_aliased_mixin_type_params));
-  const AbstractType& mixin_class_super_type =
-      AbstractType::Handle(zone, 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(zone, mixin_class_super_type.arguments());
-  TypeArguments& new_mixin_type_args = TypeArguments::Handle(zone);
-  if ((num_aliased_mixin_type_params > 0) &&
-      !mixin_class_super_type_args.IsNull()) {
-    new_mixin_type_args = TypeArguments::New(num_aliased_mixin_type_params);
-    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()) {
-        type = type.InstantiateFrom(instantiator, Object::null_type_arguments(),
-                                    kNoneFree, NULL, Heap::kOld);
-      }
-      new_mixin_type_args.SetTypeAt(i, type);
-    }
-  }
-  TypeArguments& new_super_type_args = TypeArguments::Handle(zone);
-  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(zone, 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);
-
-  // 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) {
-    THR_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(zone, 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,
-                                    PendingTypes* 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.HasTypeClass());
-  const Class& mixin_class = Class::Handle(mixin_type.type_class());
-
-  if (FLAG_trace_class_finalization) {
-    THR_Print("Applying mixin type '%s' to %s at pos %s\n",
-              String::Handle(mixin_type.Name()).ToCString(),
-              mixin_app_class.ToCString(),
-              mixin_app_class.token_pos().ToCString());
-  }
-
-  // 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());
-  }
-
-  // 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);
-
-  if (FLAG_trace_class_finalization) {
-    THR_Print(
-        "Done applying mixin type '%s' to class '%s' %s extending '%s'\n",
-        String::Handle(mixin_type.Name()).ToCString(),
-        String::Handle(mixin_app_class.Name()).ToCString(),
-        TypeArguments::Handle(mixin_app_class.type_parameters()).ToCString(),
-        AbstractType::Handle(mixin_app_class.super_type()).ToCString());
-  }
-  // 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 an alias.
-  mixin_type = mixin_app_class.mixin();
-  ASSERT(!mixin_type.IsBeingFinalized());
-  mixin_type ^=
-      FinalizeType(mixin_app_class, mixin_type, kFinalize, pending_types);
-  mixin_app_class.set_mixin(mixin_type);
-}
-
-void ClassFinalizer::CreateForwardingConstructors(
-    const Class& mixin_app,
-    const Class& mixin_cls,
-    const GrowableObjectArray& cloned_funcs) {
-  Thread* T = Thread::Current();
-  Zone* Z = T->zone();
-  const String& mixin_name = String::Handle(Z, mixin_app.Name());
-  const Class& super_class = Class::Handle(Z, mixin_app.SuperClass());
-  const String& super_name = String::Handle(Z, super_class.Name());
-  const Array& functions = Array::Handle(Z, super_class.functions());
-  const intptr_t num_functions = functions.Length();
-  Function& func = Function::Handle(Z);
-  for (intptr_t i = 0; i < num_functions; i++) {
-    func ^= functions.At(i);
-    if (func.IsGenerativeConstructor()) {
-      // Build constructor name from mixin application class name
-      // and name of cloned super class constructor.
-      const String& ctor_name = String::Handle(Z, func.name());
-      String& clone_name =
-          String::Handle(Z, String::SubString(ctor_name, super_name.Length()));
-      clone_name = Symbols::FromConcat(T, mixin_name, clone_name);
-
-      if (FLAG_trace_class_finalization) {
-        THR_Print("Cloning constructor '%s' as '%s'\n", ctor_name.ToCString(),
-                  clone_name.ToCString());
-      }
-
-      // The owner of the forwarding constructor is the mixin application
-      // class. The source is the mixin class. The source may be needed
-      // to parse field initializer expressions in the mixin class.
-      const PatchClass& owner =
-          PatchClass::Handle(Z, PatchClass::New(mixin_app, mixin_cls));
-
-      const Function& clone = Function::Handle(
-          Z, Function::New(clone_name, func.kind(), func.is_static(),
-                           false,  // Not const.
-                           false,  // Not abstract.
-                           false,  // Not external.
-                           false,  // Not native.
-                           owner, mixin_cls.token_pos()));
-      clone.set_num_fixed_parameters(func.num_fixed_parameters());
-      clone.SetNumOptionalParameters(func.NumOptionalParameters(),
-                                     func.HasOptionalPositionalParameters());
-      clone.set_result_type(Object::dynamic_type());
-      clone.set_is_debuggable(false);
-
-      const intptr_t num_parameters = func.NumParameters();
-      // The cloned ctor shares the parameter names array with the
-      // original.
-      const Array& parameter_names = Array::Handle(Z, func.parameter_names());
-      ASSERT(parameter_names.Length() == num_parameters);
-      clone.set_parameter_names(parameter_names);
-      // The parameter types of the cloned constructor are 'dynamic'.
-      clone.set_parameter_types(Array::Handle(Z, Array::New(num_parameters)));
-      for (intptr_t n = 0; n < num_parameters; n++) {
-        clone.SetParameterTypeAt(n, Object::dynamic_type());
-      }
-      cloned_funcs.Add(clone);
-    }
-  }
-}
-
-void ClassFinalizer::ApplyMixinMembers(const Class& cls) {
-  Zone* zone = Thread::Current()->zone();
-  const Type& mixin_type = Type::Handle(zone, cls.mixin());
-  ASSERT(!mixin_type.IsNull());
-  ASSERT(mixin_type.HasTypeClass());
-  const Class& mixin_cls = Class::Handle(zone, mixin_type.type_class());
-  FinalizeClass(mixin_cls);
-  // If the mixin is a mixin application alias class, there are no members to
-  // apply here. A new synthesized class representing the aliased mixin
-  // application class was inserted in the super chain of this mixin application
-  // class. Members of the actual mixin class will be applied when visiting
-  // the mixin application class referring to the actual mixin.
-  ASSERT(!mixin_cls.is_mixin_app_alias() ||
-         Class::Handle(zone, cls.SuperClass()).IsMixinApplication());
-  // A default constructor will be created for the mixin app alias class.
-
-  if (FLAG_trace_class_finalization) {
-    THR_Print("Applying mixin members of %s to %s at pos %s\n",
-              mixin_cls.ToCString(), cls.ToCString(),
-              cls.token_pos().ToCString());
-  }
-
-  const GrowableObjectArray& cloned_funcs =
-      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
-
-  Array& functions = Array::Handle(zone);
-  Function& func = Function::Handle(zone);
-
-  // The parser creates the mixin application class with no functions.
-  // But the Kernel frontend will generate mixin classes with only
-  // constructors inside them, which forward to the base class constructors.
-  //
-  // => We generate the constructors if they are not already there.
-  functions = cls.functions();
-  if (functions.Length() == 0) {
-    CreateForwardingConstructors(cls, mixin_cls, cloned_funcs);
-  } else {
-    for (intptr_t i = 0; i < functions.Length(); i++) {
-      func ^= functions.At(i);
-      ASSERT(func.kernel_offset() > 0);
-      cloned_funcs.Add(func);
-    }
-  }
-
-  // Now clone the functions from the mixin class.
-  const Library& from_library = Library::Handle(zone, mixin_cls.library());
-  const Library& to_library = Library::Handle(zone, cls.library());
-  Function& from_func = Function::Handle(zone);
-
-  functions = mixin_cls.functions();
-  const intptr_t num_functions = functions.Length();
-  for (intptr_t i = 0; i < num_functions; i++) {
-    from_func ^= functions.At(i);
-    if (from_func.IsGenerativeConstructor()) {
-      // A mixin class must not have explicit constructors.
-      if (!from_func.IsImplicitConstructor()) {
-        const Script& script = Script::Handle(cls.script());
-        const Error& error = Error::Handle(LanguageError::NewFormatted(
-            Error::Handle(), script, from_func.token_pos(), Report::AtLocation,
-            Report::kError, Heap::kNew,
-            "constructor '%s' is illegal in mixin class %s",
-            String::Handle(from_func.UserVisibleName()).ToCString(),
-            String::Handle(zone, mixin_cls.Name()).ToCString()));
-
-        ReportErrors(error, cls, cls.token_pos(),
-                     "mixin class '%s' must not have constructors",
-                     String::Handle(zone, mixin_cls.Name()).ToCString());
-      }
-      continue;  // Skip the implicit constructor.
-    }
-    if (!from_func.is_static() && !from_func.IsMethodExtractor() &&
-        !from_func.IsNoSuchMethodDispatcher() &&
-        !from_func.IsInvokeFieldDispatcher()) {
-      func = from_func.Clone(cls);
-      to_library.CloneMetadataFrom(from_library, from_func, func);
-      cloned_funcs.Add(func);
-    }
-  }
-  functions = Array::MakeFixedLength(cloned_funcs);
-  cls.SetFunctions(functions);
-
-  // Now clone the fields from the mixin class. There should be no
-  // existing fields in the mixin application class.
-  ASSERT(Array::Handle(cls.fields()).Length() == 0);
-  const Array& fields = Array::Handle(zone, mixin_cls.fields());
-  const intptr_t num_fields = fields.Length();
-  Field& field = Field::Handle(zone);
-  GrowableArray<const Field*> cloned_fields(num_fields);
-  for (intptr_t i = 0; i < num_fields; i++) {
-    field ^= fields.At(i);
-    // Static fields are shared between the mixin class and the mixin
-    // application class.
-    if (!field.is_static()) {
-      const Field& cloned = Field::ZoneHandle(zone, field.Clone(cls));
-      cloned_fields.Add(&cloned);
-    }
-  }
-  cls.AddFields(cloned_fields);
-
-  if (FLAG_trace_class_finalization) {
-    THR_Print("Done applying mixin members of %s to %s\n",
-              mixin_cls.ToCString(), cls.ToCString());
-  }
-}
-
 void ClassFinalizer::FinalizeTypesInClass(const Class& cls) {
   Thread* thread = Thread::Current();
   HANDLESCOPE(thread);
@@ -1948,11 +1001,6 @@
   FinalizeTypeParameters(cls);  // May change super type while applying mixin.
   super_class = cls.SuperClass();  // Get again possibly changed super class.
   ASSERT(super_class.IsNull() || super_class.is_type_finalized());
-  // Only resolving rather than finalizing the upper bounds here would result in
-  // instantiated type parameters of the super type to temporarily have
-  // unfinalized bounds. It is more efficient to finalize them early.
-  // Finalize bounds even if running in production mode, so that a snapshot
-  // contains them.
   FinalizeUpperBounds(cls);
   // Finalize super type.
   AbstractType& super_type = AbstractType::Handle(cls.super_type());
@@ -1960,12 +1008,6 @@
     super_type = FinalizeType(cls, super_type);
     cls.set_super_type(super_type);
   }
-  // Finalize mixin type.
-  Type& mixin_type = Type::Handle(cls.mixin());
-  if (!mixin_type.IsNull()) {
-    mixin_type ^= FinalizeType(cls, mixin_type);
-    cls.set_mixin(mixin_type);
-  }
   if (cls.IsTypedefClass()) {
     Function& signature = Function::Handle(cls.signature_function());
     Type& type = Type::Handle(signature.SignatureType());
@@ -1981,12 +1023,12 @@
     }
     cls.set_is_type_finalized();
 
-    // Resolve and finalize the result and parameter types of the signature
+    // Finalize the result and parameter types of the signature
     // function of this typedef class.
     FinalizeSignature(cls, signature);  // Does not modify signature type.
     ASSERT(signature.SignatureType() == type.raw());
 
-    // Resolve and finalize the signature type of this typedef.
+    // Finalize the signature type of this typedef.
     type ^= FinalizeType(cls, type);
     ASSERT(type.type_class() == cls.raw());
 
@@ -2036,8 +1078,6 @@
       }
     }
   }
-  // Mark as type finalized before resolving type parameter upper bounds
-  // in order to break cycles.
   cls.set_is_type_finalized();
 
   // Add this class to the direct subclasses of the superclass, unless the
@@ -2077,7 +1117,7 @@
     // This class should not contain any functions or user-defined fields yet,
     // because it has not been compiled yet. There may however be metadata
     // fields because type parameters are parsed before the class body. Since
-    // 'ResolveAndFinalizeMemberTypes(cls)' has not been called yet, unfinalized
+    // 'FinalizeMemberTypes(cls)' has not been called yet, unfinalized
     // member types could choke the snapshotter.
     // Or
     // if the class is being refinalized because a patch is being applied
@@ -2140,37 +1180,15 @@
   if (!super.IsNull()) {
     FinalizeClass(super);
   }
-  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.
-    ApplyMixinMembers(cls);
-  }
   // Mark as parsed and finalized.
   cls.Finalize();
-  // Mixin app alias classes may still lack their forwarding constructor.
-  if (cls.is_mixin_app_alias() &&
-      (cls.functions() == Object::empty_array().raw())) {
-    const GrowableObjectArray& cloned_funcs =
-        GrowableObjectArray::Handle(GrowableObjectArray::New());
-
-    const Class& mixin_app_class = Class::Handle(cls.SuperClass());
-    const Type& mixin_type = Type::Handle(mixin_app_class.mixin());
-    const Class& mixin_cls = Class::Handle(mixin_type.type_class());
-
-    CreateForwardingConstructors(cls, mixin_cls, cloned_funcs);
-    const Array& functions =
-        Array::Handle(Array::MakeFixedLength(cloned_funcs));
-    cls.SetFunctions(functions);
-  }
   // Every class should have at least a constructor, unless it is a top level
   // class or a typedef class. The Kernel frontend does not create an implicit
   // constructor for abstract classes.
   // Moreover, Dart 2 precompiler (TFA) can tree shake all members if unused.
   ASSERT(FLAG_precompiled_mode || cls.IsTopLevel() || cls.IsTypedefClass() ||
          cls.is_abstract() || (Array::Handle(cls.functions()).Length() > 0));
-  // Resolve and finalize all member types.
-  ResolveAndFinalizeMemberTypes(cls);
+  FinalizeMemberTypes(cls);
   // Run additional checks after all types are finalized.
   if (cls.is_const()) {
     CheckForLegalConstClass(cls);
@@ -2318,7 +1336,6 @@
                                         const AbstractType& type,
                                         GrowableArray<intptr_t>* visited) {
   ASSERT(visited != NULL);
-  ResolveType(cls, type);
   bool checking_typedef = false;
   if (type.IsType()) {
     AbstractType& other_type = AbstractType::Handle();
@@ -2387,226 +1404,6 @@
   return true;
 }
 
-// Returns false if the mixin illegally refers to itself.
-bool ClassFinalizer::IsMixinCycleFree(const Class& cls,
-                                      GrowableArray<intptr_t>* visited) {
-  ASSERT(visited != NULL);
-  const intptr_t cls_index = cls.id();
-  for (intptr_t i = 0; i < visited->length(); i++) {
-    if ((*visited)[i] == cls_index) {
-      // We have already visited mixin 'cls'. We found a cycle.
-      return false;
-    }
-  }
-
-  // Visit the super chain of cls.
-  visited->Add(cls.id());
-  Class& super_class = Class::Handle(cls.raw());
-  do {
-    if (super_class.IsMixinApplication()) {
-      const Type& mixin_type = Type::Handle(super_class.mixin());
-      ASSERT(!mixin_type.IsNull());
-      ASSERT(mixin_type.HasTypeClass());
-      const Class& mixin_class = Class::Handle(mixin_type.type_class());
-      if (!IsMixinCycleFree(mixin_class, visited)) {
-        return false;
-      }
-    }
-    super_class = super_class.SuperClass();
-  } while (!super_class.IsNull());
-  visited->RemoveLast();
-  return true;
-}
-
-void ClassFinalizer::CollectTypeArguments(
-    const Class& cls,
-    const Type& type,
-    const GrowableObjectArray& collected_args) {
-  ASSERT(type.HasTypeClass());
-  Class& type_class = Class::Handle(type.type_class());
-  TypeArguments& type_args = TypeArguments::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) {
-      for (intptr_t i = 0; i < num_type_arguments; i++) {
-        arg = type_args.TypeAt(i);
-        arg = arg.CloneUnfinalized();
-        ASSERT(!arg.IsBeingFinalized());
-        collected_args.Add(arg);
-      }
-      return;
-    }
-    // TODO(regis): Check if this is dead code.
-    // 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_type) {
-  // Lookup or create mixin application classes in the library of cls
-  // and resolve super type and mixin types.
-  Thread* thread = Thread::Current();
-  Zone* zone = thread->zone();
-  const Library& library = Library::Handle(zone, cls.library());
-  ASSERT(!library.IsNull());
-  const Script& script = Script::Handle(zone, cls.script());
-  ASSERT(!script.IsNull());
-  const GrowableObjectArray& type_args =
-      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
-  AbstractType& mixin_super_type =
-      AbstractType::Handle(zone, mixin_app_type.super_type());
-  ResolveType(cls, mixin_super_type);
-  ASSERT(mixin_super_type.HasTypeClass());  // Even if malformed.
-  if (mixin_super_type.IsDynamicType()) {
-    ReportError(cls, cls.token_pos(), "class '%s' may not extend 'dynamic'",
-                String::Handle(zone, cls.Name()).ToCString());
-  }
-  CollectTypeArguments(cls, Type::Cast(mixin_super_type), type_args);
-  AbstractType& mixin_type = AbstractType::Handle(zone);
-  Class& mixin_app_class = Class::Handle(zone);
-  Class& mixin_super_type_class = Class::Handle(zone);
-  Class& mixin_type_class = Class::Handle(zone);
-  Library& mixin_super_type_library = Library::Handle(zone);
-  Library& mixin_type_library = Library::Handle(zone);
-  String& mixin_app_class_name = String::Handle(zone);
-  String& mixin_type_class_name = String::Handle(zone);
-  AbstractType& super_type_arg = AbstractType::Handle(zone);
-  AbstractType& mixin_type_arg = AbstractType::Handle(zone);
-  Type& generic_mixin_type = Type::Handle(zone);
-  Array& interfaces = Array::Handle(zone);
-  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.HasTypeClass());  // Even if malformed.
-    ASSERT(mixin_type.IsType());
-    if (mixin_type.IsDynamicType()) {
-      ReportError(cls, cls.token_pos(), "class '%s' may not mixin 'dynamic'",
-                  String::Handle(zone, cls.Name()).ToCString());
-    }
-    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, as well as their respective
-    // library private keys if their library is different than the library of
-    // the mixin application class.
-    // Note that appending the library url would break naming conventions (e.g.
-    // no period in the class name).
-    mixin_app_class_name = mixin_super_type.ClassName();
-    mixin_super_type_class = mixin_super_type.type_class();
-    mixin_super_type_library = mixin_super_type_class.library();
-    if (mixin_super_type_library.raw() != library.raw()) {
-      mixin_app_class_name = String::Concat(
-          mixin_app_class_name,
-          String::Handle(zone, mixin_super_type_library.private_key()));
-    }
-    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_type_class = mixin_type.type_class();
-    mixin_type_library = mixin_type_class.library();
-    if (mixin_type_library.raw() != library.raw()) {
-      mixin_type_class_name = String::Concat(
-          mixin_type_class_name,
-          String::Handle(zone, mixin_type_library.private_key()));
-    }
-    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(thread, mixin_app_class_name);
-      mixin_app_class = Class::New(library, mixin_app_class_name, script,
-                                   mixin_type.token_pos());
-      mixin_app_class.set_super_type(mixin_super_type);
-      generic_mixin_type =
-          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).
-      interfaces = 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);
-
-      // 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) {
-        THR_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_type_arguments(),
-                                 mixin_type.token_pos());
-  }
-  TypeArguments& mixin_app_args = TypeArguments::Handle(zone);
-  if (type_args.Length() > 0) {
-    mixin_app_args = TypeArguments::New(type_args.Length());
-    AbstractType& type_arg = AbstractType::Handle(zone);
-    for (intptr_t i = 0; i < type_args.Length(); i++) {
-      type_arg ^= type_args.At(i);
-      mixin_app_args.SetTypeAt(i, type_arg);
-    }
-  }
-  if (FLAG_trace_class_finalization) {
-    THR_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_type.token_pos());
-}
-
 // For a class used as an interface marks this class and all its superclasses
 // implemented.
 //
@@ -2627,19 +1424,17 @@
     if (type.IsNull() || type.IsObjectType()) {
       break;
     }
-    ASSERT(type.IsResolved());
     cls = type.type_class();
   }
 }
 
 // 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
+// interfaces.
+// Reports an error 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.
-void ClassFinalizer::ResolveSuperTypeAndInterfaces(
+void ClassFinalizer::CheckSuperTypeAndInterfaces(
     const Class& cls,
     GrowableArray<intptr_t>* visited) {
   if (cls.is_cycle_free()) {
@@ -2647,7 +1442,7 @@
   }
   ASSERT(visited != NULL);
   if (FLAG_trace_class_finalization) {
-    THR_Print("Resolving super and interfaces: %s\n", cls.ToCString());
+    THR_Print("Checking super and interfaces: %s\n", cls.ToCString());
   }
   Zone* zone = Thread::Current()->zone();
   const intptr_t cls_index = cls.id();
@@ -2660,8 +1455,7 @@
     }
   }
 
-  // If the class/interface has no explicit super class/interfaces
-  // and is not a mixin application, we are done.
+  // If the class/interface has no explicit super class/interfaces, we are done.
   AbstractType& super_type = AbstractType::Handle(zone, cls.super_type());
   Array& super_interfaces = Array::Handle(zone, cls.interfaces());
   if ((super_type.IsNull() || super_type.IsObjectType()) &&
@@ -2670,29 +1464,18 @@
     return;
   }
 
-  if (super_type.IsMixinAppType()) {
-    // For the cycle check below to work, ResolveMixinAppType needs to set
-    // the mixin interfaces in the super classes, even if only in raw form.
-    // It is indeed too early to set the correct type arguments, which is not
-    // a problem since they are ignored in the cycle check.
-    const MixinAppType& mixin_app_type = MixinAppType::Cast(super_type);
-    super_type = ResolveMixinAppType(cls, mixin_app_type);
-    cls.set_super_type(super_type);
-  }
-
   // If cls belongs to core lib or is a synthetic class which could belong to
   // the core library, the restrictions about allowed interfaces are lifted.
   const bool exempt_from_hierarchy_restrictions =
       cls.library() == Library::CoreLibrary() ||
       String::Handle(cls.Name()).Equals(Symbols::DebugClassName());
 
-  // Resolve and check the super type and interfaces of cls.
+  // Check the super type and interfaces of cls.
   visited->Add(cls_index);
   AbstractType& interface = AbstractType::Handle(zone);
   Class& interface_class = Class::Handle(zone);
 
-  // Resolve super type. Failures lead to a longjmp.
-  ResolveType(cls, super_type);
+  // Check super type. Failures lead to a longjmp.
   if (super_type.IsDynamicType()) {
     ReportError(cls, cls.token_pos(), "class '%s' may not extend 'dynamic'",
                 String::Handle(zone, cls.Name()).ToCString());
@@ -2757,13 +1540,12 @@
                   interface_name.ToCString());
     }
   }
-  // Now resolve the super interfaces of the super type.
-  ResolveSuperTypeAndInterfaces(interface_class, visited);
+  // Now check the super interfaces of the super type.
+  CheckSuperTypeAndInterfaces(interface_class, visited);
 
-  // Resolve interfaces. Failures lead to a longjmp.
+  // Check interfaces. Failures lead to a longjmp.
   for (intptr_t i = 0; i < super_interfaces.Length(); i++) {
     interface ^= super_interfaces.At(i);
-    ResolveType(cls, interface);
     ASSERT(!interface.IsTypeParameter());  // Should be detected by parser.
     if (interface.IsDynamicType()) {
       ReportError(cls, cls.token_pos(),
@@ -2793,20 +1575,15 @@
           interface.IsDynamicType()) {
         const String& interface_name =
             String::Handle(zone, interface_class.Name());
-        if (cls.IsMixinApplication()) {
-          ReportError(cls, cls.token_pos(), "illegal mixin of '%s'",
-                      interface_name.ToCString());
-        } else {
-          ReportError(cls, cls.token_pos(),
-                      "'%s' is not allowed to extend or implement '%s'",
-                      String::Handle(zone, cls.Name()).ToCString(),
-                      interface_name.ToCString());
-        }
+        ReportError(cls, cls.token_pos(),
+                    "'%s' is not allowed to extend or implement '%s'",
+                    String::Handle(zone, cls.Name()).ToCString(),
+                    interface_name.ToCString());
       }
     }
 
-    // Now resolve the super interfaces.
-    ResolveSuperTypeAndInterfaces(interface_class, visited);
+    // Now check the super interfaces.
+    CheckSuperTypeAndInterfaces(interface_class, visited);
     MarkImplemented(zone, interface_class);
   }
   visited->RemoveLast();
diff --git a/runtime/vm/class_finalizer.h b/runtime/vm/class_finalizer.h
index cd51414..565e452 100644
--- a/runtime/vm/class_finalizer.h
+++ b/runtime/vm/class_finalizer.h
@@ -17,13 +17,10 @@
  public:
   typedef ZoneGrowableHandlePtrArray<const AbstractType> PendingTypes;
 
-  // Modes for type resolution and finalization. The ordering is relevant.
+  // Modes for finalization. The ordering is relevant.
   enum FinalizationKind {
-    kIgnore,                 // Type is ignored and replaced by dynamic.
-    kDoNotResolve,           // Type resolution is postponed.
-    kResolveTypeParameters,  // Resolve type parameters only.
-    kFinalize,               // Resolve and finalize type and type arguments.
-    kCanonicalize            // Finalize, check bounds, and canonicalize.
+    kFinalize,     // Finalize type and type arguments.
+    kCanonicalize  // Finalize and canonicalize.
   };
 
   // Finalize given type while parsing class cls.
@@ -69,47 +66,15 @@
   static void VerifyBootstrapClasses();
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 
-  // Resolve the class of the type, but not the type's type arguments.
-  // May promote the type to function type by setting its signature field.
-  static void ResolveTypeClass(const Class& cls, const Type& type);
-
-  // Resolve the type and target of the redirecting factory.
-  static void ResolveRedirectingFactory(const Class& cls,
-                                        const Function& factory);
-
-  // Apply the mixin type to the mixin application class.
-  static void ApplyMixinType(const Class& mixin_app_class,
-                             PendingTypes* pending_types = NULL);
-
  private:
   static void AllocateEnumValues(const Class& enum_cls);
   static bool IsSuperCycleFree(const Class& cls);
   static bool IsTypedefCycleFree(const Class& cls,
                                  const AbstractType& type,
                                  GrowableArray<intptr_t>* visited);
-  static bool IsMixinCycleFree(const Class& cls,
-                               GrowableArray<intptr_t>* visited);
   static void CheckForLegalConstClass(const Class& cls);
-  static void ResolveType(const Class& cls, const AbstractType& type);
-  static void ResolveRedirectingFactoryTarget(
-      const Class& cls,
-      const Function& factory,
-      const GrowableObjectArray& visited_factories);
-  static void CloneMixinAppTypeParameters(const Class& mixin_app_class);
-  static void ApplyMixinAppAlias(const Class& mixin_app_class,
-                                 const TypeArguments& instantiator);
-  static void ApplyMixinMembers(const Class& cls);
-  static void CreateForwardingConstructors(
-      const Class& mixin_app,
-      const Class& mixin_cls,
-      const GrowableObjectArray& cloned_funcs);
-  static void CollectTypeArguments(const Class& cls,
-                                   const Type& type,
-                                   const GrowableObjectArray& collected_args);
-  static RawType* ResolveMixinAppType(const Class& cls,
-                                      const MixinAppType& mixin_app_type);
-  static void ResolveSuperTypeAndInterfaces(const Class& cls,
-                                            GrowableArray<intptr_t>* visited);
+  static void CheckSuperTypeAndInterfaces(const Class& cls,
+                                          GrowableArray<intptr_t>* visited);
   static void FinalizeTypeParameters(const Class& cls,
                                      PendingTypes* pending_types = NULL);
   static intptr_t ExpandAndFinalizeTypeArguments(const Class& cls,
@@ -123,15 +88,11 @@
   static void CheckRecursiveType(const Class& cls,
                                  const AbstractType& type,
                                  PendingTypes* pending_types);
-  static void ResolveUpperBounds(const Class& cls);
   static void FinalizeUpperBounds(
       const Class& cls,
       FinalizationKind finalization = kCanonicalize);
-  static void ResolveSignature(const Class& cls, const Function& function);
-  static void ResolveAndFinalizeMemberTypes(const Class& cls);
+  static void FinalizeMemberTypes(const Class& cls);
   static void PrintClassInformation(const Class& cls);
-  static void CollectInterfaces(const Class& cls,
-                                GrowableArray<const Class*>* collected);
 
   static void ReportError(const Error& error);
   static void ReportError(const Class& cls,
diff --git a/runtime/vm/compiler/aot/precompiler.cc b/runtime/vm/compiler/aot/precompiler.cc
index ae5d05d..08c3d82 100644
--- a/runtime/vm/compiler/aot/precompiler.cc
+++ b/runtime/vm/compiler/aot/precompiler.cc
@@ -575,9 +575,6 @@
   type = cls.super_type();
   AddType(type);
 
-  type = cls.mixin();
-  AddType(type);
-
   if (cls.IsTypedefClass()) {
     AddTypesOf(Function::Handle(Z, cls.signature_function()));
   }
@@ -1421,24 +1418,18 @@
   for (intptr_t i = 0; i < types.length(); i++) {
     const AbstractType& type = types.At(i);
 
-    if (!type.IsResolved()) {
-      continue;
-    }
-
     if (type.InVMHeap()) {
       // The only important types in the vm isolate are "dynamic"/"void", which
       // will get their optimized top-type testing stub installed at creation.
       continue;
     }
 
-    if (type.IsResolved()) {
-      if (type_usage_info->IsUsedInTypeTest(type)) {
-        instr = type_testing_stubs.OptimizedCodeForType(type);
-        type.SetTypeTestingStub(instr);
+    if (type_usage_info->IsUsedInTypeTest(type)) {
+      instr = type_testing_stubs.OptimizedCodeForType(type);
+      type.SetTypeTestingStub(instr);
 
-        // Ensure we retain the type.
-        AddType(type);
-      }
+      // Ensure we retain the type.
+      AddType(type);
     }
   }
 
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc b/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc
index 98e05b6..58b6008 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc
@@ -343,7 +343,7 @@
   }
   const Register kClassIdReg = R2;
   __ LoadClassId(kClassIdReg, kInstanceReg);
-  // See ClassFinalizer::ResolveSuperTypeAndInterfaces for list of restricted
+  // See ClassFinalizer::CheckSuperTypeAndInterfaces for list of restricted
   // interfaces.
   // Bool interface can be implemented only by core class Bool.
   if (type.IsBoolType()) {
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc b/runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc
index f3b8d7c..e3d2594 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc
@@ -332,7 +332,7 @@
   }
   const Register kClassIdReg = R2;
   __ LoadClassId(kClassIdReg, kInstanceReg);
-  // See ClassFinalizer::ResolveSuperTypeAndInterfaces for list of restricted
+  // See ClassFinalizer::CheckSuperTypeAndInterfaces for list of restricted
   // interfaces.
   // Bool interface can be implemented only by core class Bool.
   if (type.IsBoolType()) {
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_ia32.cc b/runtime/vm/compiler/backend/flow_graph_compiler_ia32.cc
index ef7aa39..1fa3e5d 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler_ia32.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler_ia32.cc
@@ -348,7 +348,7 @@
   }
   const Register kClassIdReg = ECX;
   __ LoadClassId(kClassIdReg, kInstanceReg);
-  // See ClassFinalizer::ResolveSuperTypeAndInterfaces for list of restricted
+  // See ClassFinalizer::CheckSuperTypeAndInterfaces for list of restricted
   // interfaces.
   // Bool interface can be implemented only by core class Bool.
   if (type.IsBoolType()) {
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc b/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc
index 2aff5e4..4a3574e 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc
@@ -347,7 +347,7 @@
   }
   const Register kClassIdReg = R10;
   __ LoadClassId(kClassIdReg, kInstanceReg);
-  // See ClassFinalizer::ResolveSuperTypeAndInterfaces for list of restricted
+  // See ClassFinalizer::CheckSuperTypeAndInterfaces for list of restricted
   // interfaces.
   // Bool interface can be implemented only by core class Bool.
   if (type.IsBoolType()) {
diff --git a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
index e26c526..e9435cf 100644
--- a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
+++ b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
@@ -839,14 +839,7 @@
       AbstractType& type = AbstractType::ZoneHandle(Z);
       type ^= Type::New(owner, TypeArguments::Handle(Z), owner.token_pos(),
                         Heap::kOld);
-      // If the current class is the result of a mixin application, we must
-      // use the class scope of the class from which the function originates.
-      if (owner.IsMixinApplication()) {
-        ClassFinalizer::FinalizeType(
-            Class::Handle(Z, parsed_function()->function().origin()), type);
-      } else {
-        type ^= ClassFinalizer::FinalizeType(owner, type);
-      }
+      type ^= ClassFinalizer::FinalizeType(owner, type);
       body += Constant(type);
     } else {
       body += LoadLocal(parsed_function()->current_context_var());
diff --git a/runtime/vm/compiler/frontend/kernel_fingerprints.cc b/runtime/vm/compiler/frontend/kernel_fingerprints.cc
index 7306848..ca2969c 100644
--- a/runtime/vm/compiler/frontend/kernel_fingerprints.cc
+++ b/runtime/vm/compiler/frontend/kernel_fingerprints.cc
@@ -777,12 +777,6 @@
     hash = KernelFingerprintHelper::CalculateHash(hash, name.Hash());
   }
 
-  type ^= klass.mixin();
-  if (!type.IsNull()) {
-    name ^= type.Name();
-    hash = KernelFingerprintHelper::CalculateHash(hash, name.Hash());
-  }
-
   Field& field = Field::Handle(zone);
   // Calculate fingerprint for the class fields.
   for (intptr_t i = 0; i < fields.Length(); ++i) {
diff --git a/runtime/vm/compiler/frontend/kernel_translation_helper.cc b/runtime/vm/compiler/frontend/kernel_translation_helper.cc
index 646f457..319ef4a 100644
--- a/runtime/vm/compiler/frontend/kernel_translation_helper.cc
+++ b/runtime/vm/compiler/frontend/kernel_translation_helper.cc
@@ -568,13 +568,9 @@
     Function& function = Function::ZoneHandle(
         Z, klass.LookupFunctionAllowPrivate(procedure_name));
     ASSERT(!function.IsNull());
-
-    // TODO(27590): We can probably get rid of this after no longer using
-    // core libraries from the source.
-    if (function.IsRedirectingFactory()) {
-      ClassFinalizer::ResolveRedirectingFactory(klass, function);
-      function = function.RedirectionTarget();
-    }
+    // Redirecting factory must be resolved.
+    ASSERT(!function.IsRedirectingFactory() ||
+           function.RedirectionTarget() != Function::null());
     return function.raw();
   }
 }
diff --git a/runtime/vm/compiler/jit/compiler.cc b/runtime/vm/compiler/jit/compiler.cc
index b730884..19787c5 100644
--- a/runtime/vm/compiler/jit/compiler.cc
+++ b/runtime/vm/compiler/jit/compiler.cc
@@ -1292,11 +1292,6 @@
     ASSERT(!func.IsNull());
     if (!func.HasCode() &&
         !func.is_abstract() && !func.IsRedirectingFactory()) {
-      if ((cls.is_mixin_app_alias() || cls.IsMixinApplication()) &&
-          func.HasOptionalParameters()) {
-        // Skipping optional parameters in mixin application.
-        continue;
-      }
       result = CompileFunction(thread, func);
       if (result.IsError()) {
         return Error::Cast(result).raw();
diff --git a/runtime/vm/dart_api_impl.cc b/runtime/vm/dart_api_impl.cc
index b873689..d880055 100644
--- a/runtime/vm/dart_api_impl.cc
+++ b/runtime/vm/dart_api_impl.cc
@@ -3801,7 +3801,6 @@
 
   Instance& new_object = Instance::Handle(Z);
   if (constructor.IsRedirectingFactory()) {
-    ClassFinalizer::ResolveRedirectingFactory(cls, constructor);
     Type& redirect_type = Type::Handle(constructor.RedirectionType());
     constructor = constructor.RedirectionTarget();
     ASSERT(!constructor.IsNull());
diff --git a/runtime/vm/isolate_reload.cc b/runtime/vm/isolate_reload.cc
index 3a3e6ab..4314d5c 100644
--- a/runtime/vm/isolate_reload.cc
+++ b/runtime/vm/isolate_reload.cc
@@ -1324,13 +1324,6 @@
     return;
   }
 
-  // Don't report synthetic classes like the superclass of
-  // `class MA extends S with M {}` or `class MA = S with M'. The relevant
-  // changes with be reported as changes in M.
-  if (new_cls.IsMixinApplication() || new_cls.is_mixin_app_alias()) {
-    return;
-  }
-
   // Don't report `typedef bool Predicate(Object o)` as unused. There is nothing
   // to execute.
   if (new_cls.IsTypedefClass()) {
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index b85023b..676ca4e 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -1360,8 +1360,6 @@
     const Class& type_ref_cls = Class::Handle(zone, Class::New<TypeRef>());
     const Class& type_parameter_cls =
         Class::Handle(zone, Class::New<TypeParameter>());
-    const Class& mixin_app_type_cls =
-        Class::Handle(zone, Class::New<MixinAppType>());
     const Class& library_prefix_cls =
         Class::Handle(zone, Class::New<LibraryPrefix>());
 
@@ -1521,10 +1519,6 @@
                          core_lib);
     pending_classes.Add(type_parameter_cls);
 
-    RegisterPrivateClass(mixin_app_type_cls, Symbols::_MixinAppType(),
-                         core_lib);
-    pending_classes.Add(mixin_app_type_cls);
-
     cls = Class::New<Integer>();
     object_store->set_integer_implementation_class(cls);
     RegisterPrivateClass(cls, Symbols::_IntegerImplementation(), core_lib);
@@ -1860,7 +1854,6 @@
     cls = Class::New<Type>();
     cls = Class::New<TypeRef>();
     cls = Class::New<TypeParameter>();
-    cls = Class::New<MixinAppType>();
 
     cls = Class::New<Array>();
     object_store->set_array_class(cls);
@@ -2509,9 +2502,6 @@
 }
 
 intptr_t Class::NumTypeParameters(Thread* thread) const {
-  if (IsMixinApplication() && !is_mixin_type_applied()) {
-    ClassFinalizer::ApplyMixinType(*this);
-  }
   if (type_parameters() == TypeArguments::null()) {
     const intptr_t cid = id();
     if ((cid == kArrayCid) || (cid == kImmutableArrayCid) ||
@@ -2540,7 +2530,6 @@
     set_num_own_type_arguments(num_type_params);
     return num_type_params;
   }
-  ASSERT(!IsMixinApplication() || is_mixin_type_applied());
   const AbstractType& sup_type = AbstractType::Handle(zone, super_type());
   const TypeArguments& sup_type_args =
       TypeArguments::Handle(zone, sup_type.arguments());
@@ -2599,7 +2588,6 @@
   }
   // To work properly, this call requires the super class of this class to be
   // resolved, which is checked by the type_class() call on the super type.
-  // Note that calling type_class() on a MixinAppType fails.
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
@@ -2608,8 +2596,6 @@
   cls = raw();
   intptr_t num_type_args = 0;
   do {
-    // Calling NumOwnTypeArguments() on a mixin application class will setup the
-    // type parameters if not already done.
     num_type_args += cls.NumOwnTypeArguments();
     // Super type of Object class is null.
     if ((cls.super_type() == AbstractType::null()) ||
@@ -2620,7 +2606,6 @@
     // A TypeRef or function type can appear as type argument of
     // sup_type, but not as sup_type itself.
     ASSERT(sup_type.IsType());
-    ClassFinalizer::ResolveTypeClass(cls, Type::Cast(sup_type));
     cls = sup_type.type_class();
     ASSERT(!cls.IsTypedefClass());
   } while (true);
@@ -2649,8 +2634,7 @@
 }
 
 void Class::set_super_type(const AbstractType& value) const {
-  ASSERT(value.IsNull() || (value.IsType() && !value.IsDynamicType()) ||
-         value.IsMixinAppType());
+  ASSERT(value.IsNull() || (value.IsType() && !value.IsDynamicType()));
   StorePointer(&raw_ptr()->super_type_, value.raw());
 }
 
@@ -4011,7 +3995,7 @@
   return TokenPosition::kNoSource;
 #else
   // Return the begin token for synthetic classes.
-  if (is_synthesized_class() || IsMixinApplication() || IsTopLevel()) {
+  if (is_synthesized_class() || IsTopLevel()) {
     return token_pos();
   }
 
@@ -4099,14 +4083,6 @@
   set_state_bits(ConstBit::update(true, raw_ptr()->state_bits_));
 }
 
-void Class::set_is_mixin_app_alias() const {
-  set_state_bits(MixinAppAliasBit::update(true, raw_ptr()->state_bits_));
-}
-
-void Class::set_is_mixin_type_applied() const {
-  set_state_bits(MixinTypeAppliedBit::update(true, raw_ptr()->state_bits_));
-}
-
 void Class::set_is_transformed_mixin_application() const {
   set_state_bits(
       TransformedMixinApplicationBit::update(true, raw_ptr()->state_bits_));
@@ -4164,15 +4140,6 @@
   StorePointer(&raw_ptr()->interfaces_, value.raw());
 }
 
-void Class::set_mixin(const Type& value) const {
-  ASSERT(!value.IsNull());
-  StorePointer(&raw_ptr()->mixin_, value.raw());
-}
-
-bool Class::IsMixinApplication() const {
-  return mixin() != Type::null();
-}
-
 RawClass* Class::GetPatchClass() const {
   const Library& lib = Library::Handle(library());
   return lib.GetPatchClass(String::Handle(Name()));
@@ -5144,18 +5111,6 @@
   return false;
 }
 
-void TypeArguments::SetScopeFunction(const Function& function) const {
-  if (IsNull()) return;
-  const intptr_t num_types = Length();
-  AbstractType& type = AbstractType::Handle();
-  for (intptr_t i = 0; i < num_types; i++) {
-    type = TypeAt(i);
-    if (!type.IsNull()) {
-      type.SetScopeFunction(function);
-    }
-  }
-}
-
 bool TypeArguments::IsDynamicTypes(bool raw_instantiated,
                                    intptr_t from_index,
                                    intptr_t len) const {
@@ -5258,21 +5213,6 @@
   StorePointer(TypeAddr(index), value.raw());
 }
 
-bool TypeArguments::IsResolved() const {
-  if (IsCanonical()) {
-    return true;
-  }
-  AbstractType& type = AbstractType::Handle();
-  const intptr_t num_types = Length();
-  for (intptr_t i = 0; i < num_types; i++) {
-    type = TypeAt(i);
-    if (!type.IsResolved()) {
-      return false;
-    }
-  }
-  return true;
-}
-
 bool TypeArguments::IsSubvectorInstantiated(intptr_t from_index,
                                             intptr_t len,
                                             Genericity genericity,
@@ -5317,7 +5257,6 @@
     // substituted by the instantiator's type argument vector without checking
     // the upper bound.
     const AbstractType& bound = AbstractType::Handle(type_param.bound());
-    ASSERT(bound.IsResolved());
     if (!bound.IsObjectType() && !bound.IsDynamicType()) {
       return false;
     }
@@ -5565,44 +5504,6 @@
   StoreSmi(&raw_ptr()->length_, Smi::New(value));
 }
 
-RawTypeArguments* TypeArguments::CloneUnfinalized() const {
-  if (IsNull() || IsFinalized()) {
-    return raw();
-  }
-  ASSERT(IsResolved());
-  AbstractType& type = AbstractType::Handle();
-  const intptr_t num_types = Length();
-  const TypeArguments& clone =
-      TypeArguments::Handle(TypeArguments::New(num_types));
-  for (intptr_t i = 0; i < num_types; i++) {
-    type = TypeAt(i);
-    type = type.CloneUnfinalized();
-    clone.SetTypeAt(i, type);
-  }
-  ASSERT(clone.IsResolved());
-  return clone.raw();
-}
-
-RawTypeArguments* TypeArguments::CloneUninstantiated(const Class& new_owner,
-                                                     TrailPtr trail) const {
-  ASSERT(!IsNull());
-  ASSERT(IsFinalized());
-  ASSERT(!IsInstantiated());
-  AbstractType& type = AbstractType::Handle();
-  const intptr_t num_types = Length();
-  const TypeArguments& clone =
-      TypeArguments::Handle(TypeArguments::New(num_types));
-  for (intptr_t i = 0; i < num_types; i++) {
-    type = TypeAt(i);
-    if (!type.IsInstantiated()) {
-      type = type.CloneUninstantiated(new_owner, trail);
-    }
-    clone.SetTypeAt(i, type);
-  }
-  ASSERT(clone.IsFinalized());
-  return clone.raw();
-}
-
 RawTypeArguments* TypeArguments::Canonicalize(TrailPtr trail) const {
   if (IsNull() || IsCanonical()) {
     ASSERT(IsOld());
@@ -7366,57 +7267,6 @@
   return result.raw();
 }
 
-RawFunction* Function::Clone(const Class& new_owner) const {
-  ASSERT(!IsGenerativeConstructor());
-  Thread* thread = Thread::Current();
-  Zone* zone = thread->zone();
-  Function& clone = Function::Handle(zone);
-  clone ^= Object::Clone(*this, Heap::kOld);
-  const Class& origin = Class::Handle(zone, this->origin());
-  const PatchClass& clone_owner =
-      PatchClass::Handle(zone, PatchClass::New(new_owner, origin));
-  clone.set_owner(clone_owner);
-  clone.ClearICDataArray();
-  clone.ClearCode();
-  clone.set_data(Object::null_object());
-  clone.set_usage_counter(0);
-  clone.set_deoptimization_counter(0);
-  clone.set_optimized_instruction_count(0);
-  clone.set_inlining_depth(0);
-  clone.set_optimized_call_site_count(0);
-
-  if (new_owner.NumTypeParameters() > 0) {
-    // Adjust uninstantiated types to refer to type parameters of the new owner.
-    const TypeArguments& type_params =
-        TypeArguments::Handle(zone, type_parameters());
-    if (!type_params.IsNull()) {
-      const intptr_t num_type_params = type_params.Length();
-      const TypeArguments& type_params_clone =
-          TypeArguments::Handle(zone, TypeArguments::New(num_type_params));
-      TypeParameter& type_param = TypeParameter::Handle(zone);
-      for (intptr_t i = 0; i < num_type_params; i++) {
-        type_param ^= type_params.TypeAt(i);
-        type_param ^= type_param.CloneUninstantiated(new_owner);
-        type_params_clone.SetTypeAt(i, type_param);
-      }
-      clone.set_type_parameters(type_params_clone);
-    }
-    AbstractType& type = AbstractType::Handle(zone, clone.result_type());
-    type ^= type.CloneUninstantiated(new_owner);
-    clone.set_result_type(type);
-    const intptr_t num_params = clone.NumParameters();
-    Array& array = Array::Handle(zone, clone.parameter_types());
-    array ^= Object::Clone(array, Heap::kOld);
-    clone.set_parameter_types(array);
-    for (intptr_t i = 0; i < num_params; i++) {
-      type = clone.ParameterTypeAt(i);
-      type ^= type.CloneUninstantiated(new_owner);
-      clone.SetParameterTypeAt(i, type);
-    }
-  }
-  return clone.raw();
-}
-
 RawFunction* Function::NewClosureFunctionWithKind(RawFunction::Kind kind,
                                                   const String& name,
                                                   const Function& parent,
@@ -8607,25 +8457,6 @@
   return result.raw();
 }
 
-RawField* Field::Clone(const Class& new_owner) const {
-  Field& clone = Field::Handle();
-  clone ^= Object::Clone(*this, Heap::kOld);
-  const Class& owner = Class::Handle(this->Owner());
-  const PatchClass& clone_owner =
-      PatchClass::Handle(PatchClass::New(new_owner, owner));
-  clone.set_owner(clone_owner);
-  if (!clone.is_static()) {
-    clone.SetOffset(0);
-  }
-  if (new_owner.NumTypeParameters() > 0) {
-    // Adjust the field type to refer to type parameters of the new owner.
-    AbstractType& type = AbstractType::Handle(clone.type());
-    type ^= type.CloneUninstantiated(new_owner);
-    clone.SetFieldType(type);
-  }
-  return clone.raw();
-}
-
 RawField* Field::Clone(const Field& original) const {
   if (original.IsNull()) {
     return Field::null();
@@ -16488,17 +16319,6 @@
   }
 }
 
-bool AbstractType::IsResolved() const {
-  // AbstractType is an abstract class.
-  UNREACHABLE();
-  return false;
-}
-
-void AbstractType::SetIsResolved() const {
-  // AbstractType is an abstract class.
-  UNREACHABLE();
-}
-
 classid_t AbstractType::type_class_id() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
@@ -16570,11 +16390,6 @@
   return false;
 }
 
-void AbstractType::SetScopeFunction(const Function& function) const {
-  // AbstractType is an abstract class.
-  UNREACHABLE();
-}
-
 RawAbstractType* AbstractType::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
     const TypeArguments& function_type_arguments,
@@ -16586,19 +16401,6 @@
   return NULL;
 }
 
-RawAbstractType* AbstractType::CloneUnfinalized() const {
-  // AbstractType is an abstract class.
-  UNREACHABLE();
-  return NULL;
-}
-
-RawAbstractType* AbstractType::CloneUninstantiated(const Class& new_owner,
-                                                   TrailPtr trail) const {
-  // AbstractType is an abstract class.
-  UNREACHABLE();
-  return NULL;
-}
-
 RawAbstractType* AbstractType::Canonicalize(TrailPtr trail) const {
   // AbstractType is an abstract class.
   UNREACHABLE();
@@ -16753,37 +16555,31 @@
     }
     // Print the name of a typedef as a regular, possibly parameterized, class.
   }
-    if (IsResolved() || !cls.IsMixinApplication()) {
-      // Do not print the full vector, but only the declared type parameters.
-      num_type_params = cls.NumTypeParameters();
+  // Do not print the full vector, but only the declared type parameters.
+  num_type_params = cls.NumTypeParameters();
+  if (name_visibility == kInternalName) {
+    class_name = cls.Name();
+  } else {
+    ASSERT(name_visibility == kUserVisibleName);
+    // Map internal types to their corresponding public interfaces.
+    class_name = cls.UserVisibleName();
+  }
+  if (num_type_params > num_args) {
+    first_type_param_index = 0;
+    if (!IsFinalized() || IsBeingFinalized()) {
+      // TODO(regis): Check if this is dead code.
+      num_type_params = num_args;
     } else {
-      // Do not print the type parameters of an unresolved mixin application,
-      // since it would prematurely trigger the application of the mixin type.
-      num_type_params = 0;
+      ASSERT(num_args == 0);  // Type is raw.
     }
-    if (name_visibility == kInternalName) {
-      class_name = cls.Name();
+  } else {
+    // The actual type argument vector can be longer than necessary, because
+    // of type optimizations.
+    if (IsFinalized() && cls.is_type_finalized()) {
+      first_type_param_index = cls.NumTypeArguments() - num_type_params;
     } else {
-      ASSERT(name_visibility == kUserVisibleName);
-      // Map internal types to their corresponding public interfaces.
-      class_name = cls.UserVisibleName();
+      first_type_param_index = num_args - num_type_params;
     }
-    if (num_type_params > num_args) {
-      first_type_param_index = 0;
-      if (!IsFinalized() || IsBeingFinalized()) {
-        // TODO(regis): Check if this is dead code.
-        num_type_params = num_args;
-      } else {
-        ASSERT(num_args == 0);  // Type is raw.
-      }
-    } else {
-      // The actual type argument vector can be longer than necessary, because
-      // of type optimizations.
-      if (IsFinalized() && cls.is_type_finalized()) {
-        first_type_param_index = cls.NumTypeArguments() - num_type_params;
-      } else {
-        first_type_param_index = num_args - num_type_params;
-      }
   }
   GrowableHandlePtrArray<const String> pieces(zone, 4);
   pieces.Add(class_name);
@@ -17184,7 +16980,7 @@
 }
 
 void Type::SetIsBeingFinalized() const {
-  ASSERT(IsResolved() && !IsFinalized() && !IsBeingFinalized());
+  ASSERT(!IsFinalized() && !IsBeingFinalized());
   set_type_state(RawType::kBeingFinalized);
 }
 
@@ -17201,11 +16997,6 @@
   StorePointer(&raw_ptr()->signature_, value.raw());
 }
 
-void Type::SetIsResolved() const {
-  ASSERT(!IsResolved());
-  set_type_state(RawType::kResolved);
-}
-
 classid_t Type::type_class_id() const {
   return Smi::Value(raw_ptr()->type_class_id_);
 }
@@ -17307,7 +17098,6 @@
   if (IsFinalized()) {
     instantiated_type.SetIsFinalized();
   } else {
-    instantiated_type.SetIsResolved();
     if (IsBeingFinalized()) {
       instantiated_type.SetIsBeingFinalized();
     }
@@ -17335,7 +17125,6 @@
   if (IsFunctionType() != other_type.IsFunctionType()) {
     return false;
   }
-  ASSERT(IsResolved() && other_type.IsResolved());
   if (type_class_id() != other_type.type_class_id()) {
     return false;
   }
@@ -17468,148 +17257,6 @@
   return TypeArguments::Handle(arguments()).IsRecursive();
 }
 
-void Type::SetScopeFunction(const Function& function) const {
-  TypeArguments::Handle(arguments()).SetScopeFunction(function);
-  if (IsFunctionType()) {
-    const Function& sig_fun = Function::Handle(signature());
-    sig_fun.set_parent_function(function);
-    // No need to traverse result type and parameter types (and bounds, in case
-    // sig_fun is generic), since they have sig_fun as scope function.
-  }
-}
-
-RawAbstractType* Type::CloneUnfinalized() const {
-  ASSERT(IsResolved());
-  if (IsFinalized()) {
-    return raw();
-  }
-  ASSERT(!IsBeingFinalized());  // Cloning must occur prior to finalization.
-  Zone* zone = Thread::Current()->zone();
-  const TypeArguments& type_args = TypeArguments::Handle(zone, arguments());
-  const TypeArguments& type_args_clone =
-      TypeArguments::Handle(zone, type_args.CloneUnfinalized());
-  if (type_args_clone.raw() == type_args.raw()) {
-    return raw();
-  }
-  const Type& clone = Type::Handle(
-      zone,
-      Type::New(Class::Handle(zone, type_class()), type_args, token_pos()));
-  // Clone the signature if this type represents a function type.
-  Function& fun = Function::Handle(zone, signature());
-  if (!fun.IsNull()) {
-    const Class& owner = Class::Handle(zone, fun.Owner());
-    const Function& parent = Function::Handle(zone, fun.parent_function());
-    Function& fun_clone =
-        Function::Handle(zone, Function::NewSignatureFunction(
-                                   owner, parent, TokenPosition::kNoSource));
-    const TypeArguments& type_params =
-        TypeArguments::Handle(zone, fun.type_parameters());
-    if (!type_params.IsNull()) {
-      const intptr_t num_type_params = type_params.Length();
-      const TypeArguments& type_params_clone =
-          TypeArguments::Handle(zone, TypeArguments::New(num_type_params));
-      TypeParameter& type_param = TypeParameter::Handle(zone);
-      for (intptr_t i = 0; i < num_type_params; i++) {
-        type_param ^= type_params.TypeAt(i);
-        type_param ^= type_param.CloneUnfinalized();
-        type_params_clone.SetTypeAt(i, type_param);
-      }
-      fun_clone.set_type_parameters(type_params_clone);
-    }
-    AbstractType& type = AbstractType::Handle(zone, fun.result_type());
-    type = type.CloneUnfinalized();
-    fun_clone.set_result_type(type);
-    const intptr_t num_params = fun.NumParameters();
-    fun_clone.set_num_fixed_parameters(fun.num_fixed_parameters());
-    fun_clone.SetNumOptionalParameters(fun.NumOptionalParameters(),
-                                       fun.HasOptionalPositionalParameters());
-    fun_clone.set_parameter_types(
-        Array::Handle(Array::New(num_params, Heap::kOld)));
-    for (intptr_t i = 0; i < num_params; i++) {
-      type = fun.ParameterTypeAt(i);
-      type = type.CloneUnfinalized();
-      fun_clone.SetParameterTypeAt(i, type);
-    }
-    fun_clone.set_parameter_names(Array::Handle(zone, fun.parameter_names()));
-    clone.set_signature(fun_clone);
-    fun_clone.SetSignatureType(clone);
-  }
-  clone.SetIsResolved();
-  return clone.raw();
-}
-
-RawAbstractType* Type::CloneUninstantiated(const Class& new_owner,
-                                           TrailPtr trail) const {
-  ASSERT(IsFinalized());
-  if (IsInstantiated()) {
-    return raw();
-  }
-  // We may recursively encounter a type already being cloned, because we clone
-  // the upper bounds of its uninstantiated type arguments in the same pass.
-  Zone* zone = Thread::Current()->zone();
-  Type& clone = Type::Handle(zone);
-  clone ^= OnlyBuddyInTrail(trail);
-  if (!clone.IsNull()) {
-    return clone.raw();
-  }
-  const Class& type_cls = Class::Handle(zone, type_class());
-  clone = Type::New(type_cls, TypeArguments::Handle(zone), token_pos());
-  // Clone the signature if this type represents a function type.
-  const Function& fun = Function::Handle(zone, signature());
-  if (!fun.IsNull()) {
-    ASSERT(type_cls.IsTypedefClass() || type_cls.IsClosureClass());
-    // If the scope class is not a typedef and if it is generic, it must be the
-    // mixin class, set it to the new owner.
-    const Function& parent = Function::Handle(zone, fun.parent_function());
-    // TODO(regis): Is it safe to reuse the parent function with the old owner?
-    Function& fun_clone = Function::Handle(
-        zone, Function::NewSignatureFunction(new_owner, parent,
-                                             TokenPosition::kNoSource));
-    const TypeArguments& type_params =
-        TypeArguments::Handle(zone, fun.type_parameters());
-    if (!type_params.IsNull()) {
-      const intptr_t num_type_params = type_params.Length();
-      const TypeArguments& type_params_clone =
-          TypeArguments::Handle(zone, TypeArguments::New(num_type_params));
-      TypeParameter& type_param = TypeParameter::Handle(zone);
-      for (intptr_t i = 0; i < num_type_params; i++) {
-        type_param ^= type_params.TypeAt(i);
-        type_param ^= type_param.CloneUninstantiated(new_owner, trail);
-        type_params_clone.SetTypeAt(i, type_param);
-      }
-      fun_clone.set_type_parameters(type_params_clone);
-    }
-    AbstractType& type = AbstractType::Handle(zone, fun.result_type());
-    type = type.CloneUninstantiated(new_owner, trail);
-    fun_clone.set_result_type(type);
-    const intptr_t num_params = fun.NumParameters();
-    fun_clone.set_num_fixed_parameters(fun.num_fixed_parameters());
-    fun_clone.SetNumOptionalParameters(fun.NumOptionalParameters(),
-                                       fun.HasOptionalPositionalParameters());
-    fun_clone.set_parameter_types(
-        Array::Handle(Array::New(num_params, Heap::kOld)));
-    for (intptr_t i = 0; i < num_params; i++) {
-      type = fun.ParameterTypeAt(i);
-      type = type.CloneUninstantiated(new_owner, trail);
-      fun_clone.SetParameterTypeAt(i, type);
-    }
-    fun_clone.set_parameter_names(Array::Handle(zone, fun.parameter_names()));
-    clone.set_signature(fun_clone);
-  }
-  TypeArguments& type_args = TypeArguments::Handle(zone, arguments());
-  if (!type_args.IsNull()) {
-    // Upper bounds of uninstantiated type arguments may form a cycle.
-    if (type_args.IsRecursive() || !type_args.IsInstantiated()) {
-      AddOnlyBuddyToTrail(&trail, clone);
-    }
-    type_args = type_args.CloneUninstantiated(new_owner, trail);
-    clone.set_arguments(type_args);
-  }
-  clone.SetIsFinalized();
-  clone ^= clone.Canonicalize();
-  return clone.raw();
-}
-
 RawAbstractType* Type::Canonicalize(TrailPtr trail) const {
   ASSERT(IsFinalized());
   if (IsCanonical()) {
@@ -17935,12 +17582,6 @@
   return !ref_type.IsNull() && ref_type.IsEquivalent(other, trail);
 }
 
-void TypeRef::SetScopeFunction(const Function& function) const {
-  // TypeRefs are created during finalization, when scope functions have
-  // already been adjusted.
-  UNREACHABLE();
-}
-
 RawTypeRef* TypeRef::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
     const TypeArguments& function_type_arguments,
@@ -17969,26 +17610,6 @@
   return instantiated_type_ref.raw();
 }
 
-RawTypeRef* TypeRef::CloneUninstantiated(const Class& new_owner,
-                                         TrailPtr trail) const {
-  TypeRef& cloned_type_ref = TypeRef::Handle();
-  cloned_type_ref ^= OnlyBuddyInTrail(trail);
-  if (!cloned_type_ref.IsNull()) {
-    return cloned_type_ref.raw();
-  }
-  cloned_type_ref = TypeRef::New();
-  AddOnlyBuddyToTrail(&trail, cloned_type_ref);
-  AbstractType& ref_type = AbstractType::Handle(type());
-  ASSERT(!ref_type.IsNull() && !ref_type.IsTypeRef());
-  AbstractType& cloned_ref_type = AbstractType::Handle();
-  cloned_ref_type = ref_type.CloneUninstantiated(new_owner, trail);
-  ASSERT(!cloned_ref_type.IsTypeRef());
-  cloned_type_ref.set_type(cloned_ref_type);
-  cloned_type_ref.SetTypeTestingStub(Instructions::Handle(
-      TypeTestingStubGenerator::DefaultCodeForType(cloned_type_ref)));
-  return cloned_type_ref.raw();
-}
-
 void TypeRef::set_type(const AbstractType& value) const {
   ASSERT(value.IsFunctionType() || value.HasTypeClass());
   ASSERT(!value.IsTypeRef());
@@ -18193,49 +17814,6 @@
   // not only happens at run time, but also during type finalization.
 }
 
-RawAbstractType* TypeParameter::CloneUnfinalized() const {
-  if (IsFinalized()) {
-    return raw();
-  }
-  // No need to clone bound, as it is not part of the finalization state.
-  return TypeParameter::New(Class::Handle(parameterized_class()),
-                            Function::Handle(parameterized_function()), index(),
-                            String::Handle(name()),
-                            AbstractType::Handle(bound()), token_pos());
-}
-
-RawAbstractType* TypeParameter::CloneUninstantiated(const Class& new_owner,
-                                                    TrailPtr trail) const {
-  ASSERT(IsFinalized());
-  Thread* thread = Thread::Current();
-  Zone* zone = thread->zone();
-  TypeParameter& clone = TypeParameter::Handle(zone);
-  clone ^= OnlyBuddyInTrail(trail);
-  if (!clone.IsNull()) {
-    return clone.raw();
-  }
-  intptr_t new_index = index();
-  AbstractType& upper_bound = AbstractType::Handle(zone, bound());
-  const Function& fun = Function::Handle(zone, parameterized_function());
-  Class& cls = Class::Handle(zone, parameterized_class());
-  if (!cls.IsNull()) {
-    ASSERT(fun.IsNull());
-    new_index += new_owner.NumTypeArguments() - cls.NumTypeArguments();
-    cls = new_owner.raw();
-  } else {
-    ASSERT(IsFunctionTypeParameter());
-    // Only the bounds of function type parameters need cloning.
-  }
-  clone = TypeParameter::New(cls, fun, new_index, String::Handle(zone, name()),
-                             upper_bound,  // Not cloned yet.
-                             token_pos());
-  clone.SetIsFinalized();
-  AddOnlyBuddyToTrail(&trail, clone);
-  upper_bound = upper_bound.CloneUninstantiated(new_owner, trail);
-  clone.set_bound(upper_bound);
-  return clone.raw();
-}
-
 void TypeParameter::EnumerateURIs(URIs* uris) const {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
@@ -18352,64 +17930,6 @@
   }
 }
 
-TokenPosition MixinAppType::token_pos() const {
-  return AbstractType::Handle(MixinTypeAt(0)).token_pos();
-}
-
-intptr_t MixinAppType::Depth() const {
-  return Array::Handle(mixin_types()).Length();
-}
-
-RawString* MixinAppType::Name() const {
-  return String::New("MixinAppType");
-}
-
-const char* MixinAppType::ToCString() const {
-  const char* format = "MixinAppType: super type: %s; first mixin type: %s";
-  const char* super_type_cstr =
-      String::Handle(AbstractType::Handle(super_type()).Name()).ToCString();
-  const char* first_mixin_type_cstr =
-      String::Handle(AbstractType::Handle(MixinTypeAt(0)).Name()).ToCString();
-  intptr_t len =
-      Utils::SNPrint(NULL, 0, format, super_type_cstr, first_mixin_type_cstr) +
-      1;
-  char* chars = Thread::Current()->zone()->Alloc<char>(len);
-  Utils::SNPrint(chars, len, format, super_type_cstr, first_mixin_type_cstr);
-  return chars;
-}
-
-RawAbstractType* MixinAppType::MixinTypeAt(intptr_t depth) const {
-  return AbstractType::RawCast(Array::Handle(mixin_types()).At(depth));
-}
-
-void MixinAppType::set_super_type(const AbstractType& value) const {
-  StorePointer(&raw_ptr()->super_type_, value.raw());
-}
-
-void MixinAppType::set_mixin_types(const Array& value) const {
-  StorePointer(&raw_ptr()->mixin_types_, value.raw());
-}
-
-RawMixinAppType* MixinAppType::New() {
-  // MixinAppType objects do not survive finalization, so allocate
-  // on new heap.
-  RawObject* raw = Object::Allocate(MixinAppType::kClassId,
-                                    MixinAppType::InstanceSize(), Heap::kOld);
-  return reinterpret_cast<RawMixinAppType*>(raw);
-}
-
-RawMixinAppType* MixinAppType::New(const AbstractType& super_type,
-                                   const Array& mixin_types) {
-  Zone* Z = Thread::Current()->zone();
-  const MixinAppType& result = MixinAppType::Handle(Z, MixinAppType::New());
-  result.set_super_type(super_type);
-  result.set_mixin_types(mixin_types);
-
-  result.SetTypeTestingStub(Instructions::Handle(
-      Z, TypeTestingStubGenerator::DefaultCodeForType(result)));
-  return result.raw();
-}
-
 RawInstance* Number::CheckAndCanonicalize(Thread* thread,
                                           const char** error_str) const {
   intptr_t cid = GetClassId();
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
index e4d0987..13d9057 100644
--- a/runtime/vm/object.h
+++ b/runtime/vm/object.h
@@ -953,12 +953,6 @@
   // classes.
   RawClass* SuperClass(bool original_classes = false) const;
 
-  RawType* mixin() const { return raw_ptr()->mixin_; }
-  void set_mixin(const Type& value) const;
-
-  // Note this returns false for mixin application aliases.
-  bool IsMixinApplication() const;
-
   RawClass* GetPatchClass() const;
 
   // Interfaces is an array of Types.
@@ -1164,16 +1158,6 @@
   bool is_const() const { return ConstBit::decode(raw_ptr()->state_bits_); }
   void set_is_const() const;
 
-  bool is_mixin_app_alias() const {
-    return MixinAppAliasBit::decode(raw_ptr()->state_bits_);
-  }
-  void set_is_mixin_app_alias() const;
-
-  bool is_mixin_type_applied() const {
-    return MixinTypeAppliedBit::decode(raw_ptr()->state_bits_);
-  }
-  void set_is_mixin_type_applied() const;
-
   // Tests if this is a mixin application class which was desugared
   // to a normal class by kernel mixin transformation
   // (pkg/kernel/lib/transformations/mixin_full_resolution.dart).
@@ -1377,10 +1361,6 @@
       : public BitField<uint16_t, bool, kSynthesizedClassBit, 1> {};
   class MarkedForParsingBit
       : public BitField<uint16_t, bool, kMarkedForParsingBit, 1> {};
-  class MixinAppAliasBit
-      : public BitField<uint16_t, bool, kMixinAppAliasBit, 1> {};
-  class MixinTypeAppliedBit
-      : public BitField<uint16_t, bool, kMixinTypeAppliedBit, 1> {};
   class FieldsMarkedNullableBit
       : public BitField<uint16_t, bool, kFieldsMarkedNullableBit, 1> {};
   class CycleFreeBit : public BitField<uint16_t, bool, kCycleFreeBit, 1> {};
@@ -2847,10 +2827,6 @@
                                              bool allow_add = true) const;
 #endif
 
-  // Allocate new function object, clone values from this function. The
-  // owner of the clone is new_owner.
-  RawFunction* Clone(const Class& new_owner) const;
-
   // Slow function, use in asserts to track changes in important library
   // functions.
   int32_t SourceFingerprint() const;
@@ -3267,9 +3243,6 @@
                                TokenPosition end_token_pos);
 
   // Allocate new field object, clone values from this field. The
-  // owner of the clone is new_owner.
-  RawField* Clone(const Class& new_owner) const;
-  // Allocate new field object, clone values from this field. The
   // original is specified.
   RawField* Clone(const Field& original) const;
 
@@ -6121,27 +6094,12 @@
   bool CanShareInstantiatorTypeArguments(const Class& instantiator_class) const;
   bool CanShareFunctionTypeArguments(const Function& function) const;
 
-  // Return true if all types of this vector are respectively, resolved,
-  // finalized, or bounded.
-  bool IsResolved() const;
+  // Return true if all types of this vector are finalized.
   bool IsFinalized() const;
 
   // Return true if this vector contains a recursive type argument.
   bool IsRecursive() const;
 
-  // Set the scope of this type argument vector to the given function.
-  void SetScopeFunction(const Function& function) const;
-
-  // Clone this type argument vector and clone all unfinalized type arguments.
-  // Finalized type arguments are shared.
-  RawTypeArguments* CloneUnfinalized() const;
-
-  // Clone this type argument vector and clone all uninstantiated type
-  // arguments, changing the class owner of type parameters.
-  // Instantiated type arguments are shared.
-  RawTypeArguments* CloneUninstantiated(const Class& new_owner,
-                                        TrailPtr trail = NULL) const;
-
   // Canonicalize only if instantiated, otherwise returns 'this'.
   RawTypeArguments* Canonicalize(TrailPtr trail = NULL) const;
 
@@ -6257,8 +6215,6 @@
   virtual void SetIsFinalized() const;
   virtual bool IsBeingFinalized() const;
   virtual void SetIsBeingFinalized() const;
-  virtual bool IsResolved() const;
-  virtual void SetIsResolved() const;
   virtual bool HasTypeClass() const { return type_class_id() != kIllegalCid; }
   virtual classid_t type_class_id() const;
   virtual RawClass* type_class() const;
@@ -6278,9 +6234,6 @@
   virtual bool IsEquivalent(const Instance& other, TrailPtr trail = NULL) const;
   virtual bool IsRecursive() const;
 
-  // Set the scope of this type to the given function.
-  virtual void SetScopeFunction(const Function& function) const;
-
   // Check if this type represents a function type.
   virtual bool IsFunctionType() const { return false; }
 
@@ -6302,19 +6255,6 @@
       TrailPtr instantiation_trail,
       Heap::Space space) const;
 
-  // Return a clone of this unfinalized type or the type itself if it is
-  // already finalized. Apply recursively to type arguments, i.e. finalized
-  // type arguments of an unfinalized type are not cloned, but shared.
-  virtual RawAbstractType* CloneUnfinalized() const;
-
-  // Return a clone of this uninstantiated type where all references to type
-  // parameters are replaced with references to type parameters of the same name
-  // but belonging to the new owner class.
-  // Apply recursively to type arguments, i.e. instantiated type arguments of
-  // an uninstantiated type are not cloned, but shared.
-  virtual RawAbstractType* CloneUninstantiated(const Class& new_owner,
-                                               TrailPtr trail = NULL) const;
-
   virtual RawInstance* CheckAndCanonicalize(Thread* thread,
                                             const char** error_str) const {
     return Canonicalize();
@@ -6504,10 +6444,6 @@
     return raw_ptr()->type_state_ == RawType::kBeingFinalized;
   }
   virtual void SetIsBeingFinalized() const;
-  virtual bool IsResolved() const {
-    return raw_ptr()->type_state_ >= RawType::kResolved;
-  }
-  virtual void SetIsResolved() const;
   virtual bool HasTypeClass() const {
     ASSERT(type_class_id() != kIllegalCid);
     return true;
@@ -6523,7 +6459,6 @@
                               TrailPtr trail = NULL) const;
   virtual bool IsEquivalent(const Instance& other, TrailPtr trail = NULL) const;
   virtual bool IsRecursive() const;
-  virtual void SetScopeFunction(const Function& function) const;
   // If signature is not null, this type represents a function type. Note that
   // the signature fully represents the type and type arguments can be ignored.
   // However, in case of a generic typedef, they document how the typedef class
@@ -6541,9 +6476,6 @@
       intptr_t num_free_fun_type_params,
       TrailPtr instantiation_trail,
       Heap::Space space) const;
-  virtual RawAbstractType* CloneUnfinalized() const;
-  virtual RawAbstractType* CloneUninstantiated(const Class& new_owner,
-                                               TrailPtr trail = NULL) const;
   virtual RawAbstractType* Canonicalize(TrailPtr trail = NULL) const;
 #if defined(DEBUG)
   // Check if type is canonical.
@@ -6647,7 +6579,6 @@
     const AbstractType& ref_type = AbstractType::Handle(type());
     return ref_type.IsNull() || ref_type.IsBeingFinalized();
   }
-  virtual bool IsResolved() const { return true; }
   virtual bool HasTypeClass() const {
     return (type() != AbstractType::null()) &&
            AbstractType::Handle(type()).HasTypeClass();
@@ -6671,15 +6602,12 @@
                               TrailPtr trail = NULL) const;
   virtual bool IsEquivalent(const Instance& other, TrailPtr trail = NULL) const;
   virtual bool IsRecursive() const { return true; }
-  virtual void SetScopeFunction(const Function& function) const;
   virtual RawTypeRef* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
       const TypeArguments& function_type_arguments,
       intptr_t num_free_fun_type_params,
       TrailPtr instantiation_trail,
       Heap::Space space) const;
-  virtual RawTypeRef* CloneUninstantiated(const Class& new_owner,
-                                          TrailPtr trail = NULL) const;
   virtual RawAbstractType* Canonicalize(TrailPtr trail = NULL) const;
 #if defined(DEBUG)
   // Check if typeref is canonical.
@@ -6720,7 +6648,6 @@
   }
   virtual void SetIsFinalized() const;
   virtual bool IsBeingFinalized() const { return false; }
-  virtual bool IsResolved() const { return true; }
   virtual bool HasTypeClass() const { return false; }
   virtual classid_t type_class_id() const { return kIllegalCid; }
   classid_t parameterized_class_id() const;
@@ -6745,16 +6672,12 @@
                               TrailPtr trail = NULL) const;
   virtual bool IsEquivalent(const Instance& other, TrailPtr trail = NULL) const;
   virtual bool IsRecursive() const { return false; }
-  virtual void SetScopeFunction(const Function& function) const {}
   virtual RawAbstractType* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
       const TypeArguments& function_type_arguments,
       intptr_t num_free_fun_type_params,
       TrailPtr instantiation_trail,
       Heap::Space space) const;
-  virtual RawAbstractType* CloneUnfinalized() const;
-  virtual RawAbstractType* CloneUninstantiated(const Class& new_owner,
-                                               TrailPtr trail = NULL) const;
   virtual RawAbstractType* Canonicalize(TrailPtr trail = NULL) const {
     return raw();
   }
@@ -6795,53 +6718,6 @@
   friend class ClearTypeHashVisitor;
 };
 
-// A MixinAppType represents a parsed mixin application clause, e.g.
-// "S<T> with M<U>, N<V>".
-// MixinAppType objects do not survive finalization, so they do not
-// need to be written to and read from snapshots.
-// The class finalizer creates synthesized classes S&M and S&M&N if they do not
-// yet exist in the library declaring the mixin application clause.
-class MixinAppType : public AbstractType {
- public:
-  // A MixinAppType object is unfinalized by definition, since it is replaced at
-  // class finalization time with a finalized Type object.
-  virtual bool IsFinalized() const { return false; }
-  virtual bool IsResolved() const { return false; }
-  virtual bool HasTypeClass() const { return false; }
-  virtual RawString* Name() const;
-  virtual TokenPosition token_pos() const;
-
-  // Returns the mixin composition depth of this mixin application type.
-  intptr_t Depth() const;
-
-  // Returns the declared super type of the mixin application, which will also
-  // be the super type of the first synthesized class, e.g. class "S&M" will
-  // refer to super type "S<T>".
-  RawAbstractType* super_type() const { return raw_ptr()->super_type_; }
-
-  // Returns the mixin type at the given mixin composition depth, e.g. N<V> at
-  // depth 0 and M<U> at depth 1.
-  RawAbstractType* MixinTypeAt(intptr_t depth) const;
-
-  static intptr_t InstanceSize() {
-    return RoundedAllocationSize(sizeof(RawMixinAppType));
-  }
-
-  static RawMixinAppType* New(const AbstractType& super_type,
-                              const Array& mixin_types);
-
- private:
-  void set_super_type(const AbstractType& value) const;
-
-  RawArray* mixin_types() const { return raw_ptr()->mixin_types_; }
-  void set_mixin_types(const Array& value) const;
-
-  static RawMixinAppType* New();
-
-  FINAL_HEAP_OBJECT_IMPLEMENTATION(MixinAppType, AbstractType);
-  friend class Class;
-};
-
 class Number : public Instance {
  public:
   // TODO(iposva): Add more useful Number methods.
diff --git a/runtime/vm/object_service.cc b/runtime/vm/object_service.cc
index 4071bf0..fa7f4b8 100644
--- a/runtime/vm/object_service.cc
+++ b/runtime/vm/object_service.cc
@@ -107,8 +107,10 @@
   if (!superType.IsNull()) {
     jsobj.AddProperty("superType", superType);
   }
-  const Type& mix = Type::Handle(mixin());
-  if (!mix.IsNull()) {
+  const Array& interface_array = Array::Handle(interfaces());
+  if (is_transformed_mixin_application()) {
+    Type& mix = Type::Handle();
+    mix ^= interface_array.At(interface_array.Length() - 1);
     jsobj.AddProperty("mixin", mix);
   }
   jsobj.AddProperty("library", Object::Handle(library()));
@@ -118,7 +120,6 @@
   }
   {
     JSONArray interfaces_array(&jsobj, "interfaces");
-    const Array& interface_array = Array::Handle(interfaces());
     Type& interface_type = Type::Handle();
     if (!interface_array.IsNull()) {
       for (intptr_t i = 0; i < interface_array.Length(); ++i) {
@@ -485,9 +486,7 @@
     Class& klass = Class::Handle();
     while (class_iter.HasNext()) {
       klass = class_iter.GetNextClass();
-      if (!klass.IsMixinApplication()) {
-        jsarr.AddValue(klass);
-      }
+      jsarr.AddValue(klass);
     }
   }
   {
@@ -1154,10 +1153,6 @@
   jsobj.AddProperty("bound", upper_bound);
 }
 
-void MixinAppType::PrintJSONImpl(JSONStream* stream, bool ref) const {
-  UNREACHABLE();
-}
-
 void Number::PrintJSONImpl(JSONStream* stream, bool ref) const {
   UNREACHABLE();
 }
diff --git a/runtime/vm/raw_object.cc b/runtime/vm/raw_object.cc
index cc8e6d6..e0d7945 100644
--- a/runtime/vm/raw_object.cc
+++ b/runtime/vm/raw_object.cc
@@ -386,7 +386,6 @@
 REGULAR_VISITOR(Type)
 REGULAR_VISITOR(TypeRef)
 REGULAR_VISITOR(TypeParameter)
-REGULAR_VISITOR(MixinAppType)
 REGULAR_VISITOR(PatchClass)
 COMPRESSED_VISITOR(Closure)
 REGULAR_VISITOR(ClosureData)
diff --git a/runtime/vm/raw_object.h b/runtime/vm/raw_object.h
index a383cca..93cde94 100644
--- a/runtime/vm/raw_object.h
+++ b/runtime/vm/raw_object.h
@@ -60,7 +60,6 @@
   V(Type)                                                                      \
   V(TypeRef)                                                                   \
   V(TypeParameter)                                                             \
-  V(MixinAppType)                                                              \
   V(Closure)                                                                   \
   V(Number)                                                                    \
   V(Integer)                                                                   \
@@ -908,7 +907,6 @@
   RawLibrary* library_;
   RawTypeArguments* type_parameters_;  // Array of TypeParameter.
   RawAbstractType* super_type_;
-  RawType* mixin_;  // Generic mixin type, e.g. M<T>, not M<int>.
   RawFunction* signature_function_;  // Associated function for typedef class.
   RawArray* constants_;      // Canonicalized const instances of this class.
   RawType* canonical_type_;  // Canonical type for this class.
@@ -2004,7 +2002,6 @@
  protected:
   enum TypeState {
     kAllocated,                // Initial state.
-    kResolved,                 // Type class and type arguments resolved.
     kBeingFinalized,           // In the process of being finalized.
     kFinalizedInstantiated,    // Instantiated type ready for use.
     kFinalizedUninstantiated,  // Uninstantiated type ready for use.
@@ -2076,16 +2073,6 @@
   friend class CidRewriteVisitor;
 };
 
-class RawMixinAppType : public RawAbstractType {
- private:
-  RAW_HEAP_OBJECT_IMPLEMENTATION(MixinAppType);
-
-  VISIT_FROM(RawObject*, super_type_);
-  RawAbstractType* super_type_;
-  RawArray* mixin_types_;  // Array of AbstractType.
-  VISIT_TO(RawObject*, mixin_types_);
-};
-
 class RawClosure : public RawInstance {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(Closure);
diff --git a/runtime/vm/raw_object_fields.cc b/runtime/vm/raw_object_fields.cc
index 1802505..ed51255 100644
--- a/runtime/vm/raw_object_fields.cc
+++ b/runtime/vm/raw_object_fields.cc
@@ -20,7 +20,6 @@
   F(Class, library_)                                                           \
   F(Class, type_parameters_)                                                   \
   F(Class, super_type_)                                                        \
-  F(Class, mixin_)                                                             \
   F(Class, signature_function_)                                                \
   F(Class, constants_)                                                         \
   F(Class, canonical_type_)                                                    \
@@ -147,8 +146,6 @@
   F(TypeParameter, hash_)                                                      \
   F(TypeParameter, bound_)                                                     \
   F(TypeParameter, parameterized_function_)                                    \
-  F(MixinAppType, super_type_)                                                 \
-  F(MixinAppType, mixin_types_)                                                \
   F(Closure, instantiator_type_arguments_)                                     \
   F(Closure, function_type_arguments_)                                         \
   F(Closure, delayed_type_arguments_)                                          \
diff --git a/runtime/vm/raw_object_snapshot.cc b/runtime/vm/raw_object_snapshot.cc
index a67660e..286beb6 100644
--- a/runtime/vm/raw_object_snapshot.cc
+++ b/runtime/vm/raw_object_snapshot.cc
@@ -297,22 +297,6 @@
   writer->WriteObjectImpl(param_class, kAsReference);
 }
 
-RawMixinAppType* MixinAppType::ReadFrom(SnapshotReader* reader,
-                                        intptr_t object_id,
-                                        intptr_t tags,
-                                        Snapshot::Kind kind,
-                                        bool as_reference) {
-  UNREACHABLE();  // MixinAppType objects do not survive finalization.
-  return MixinAppType::null();
-}
-
-void RawMixinAppType::WriteTo(SnapshotWriter* writer,
-                              intptr_t object_id,
-                              Snapshot::Kind kind,
-                              bool as_reference) {
-  UNREACHABLE();  // MixinAppType objects do not survive finalization.
-}
-
 RawTypeArguments* TypeArguments::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
diff --git a/runtime/vm/service.cc b/runtime/vm/service.cc
index c9f7323..acf8b6f 100644
--- a/runtime/vm/service.cc
+++ b/runtime/vm/service.cc
@@ -4666,7 +4666,7 @@
   }
   {
     JSONArray internals(&map, "Type");
-    for (intptr_t id = kAbstractTypeCid; id <= kMixinAppTypeCid; ++id) {
+    for (intptr_t id = kAbstractTypeCid; id <= kTypeParameterCid; ++id) {
       DEFINE_ADD_VALUE_F(id);
     }
   }
diff --git a/runtime/vm/service.h b/runtime/vm/service.h
index ca29775..ace6da3 100644
--- a/runtime/vm/service.h
+++ b/runtime/vm/service.h
@@ -15,7 +15,7 @@
 namespace dart {
 
 #define SERVICE_PROTOCOL_MAJOR_VERSION 3
-#define SERVICE_PROTOCOL_MINOR_VERSION 12
+#define SERVICE_PROTOCOL_MINOR_VERSION 13
 
 class Array;
 class EmbedderServiceHandler;
diff --git a/runtime/vm/service/service.md b/runtime/vm/service/service.md
index 50b2691c..00f1b66 100644
--- a/runtime/vm/service/service.md
+++ b/runtime/vm/service/service.md
@@ -1,8 +1,8 @@
-# Dart VM Service Protocol 3.12
+# Dart VM Service Protocol 3.13
 
 > Please post feedback to the [observatory-discuss group][discuss-list]
 
-This document describes of _version 3.12_ of the Dart VM Service Protocol. This
+This document describes of _version 3.13_ of the Dart VM Service Protocol. This
 protocol is used to communicate with a running Dart Virtual Machine.
 
 To use the Service Protocol, start the VM with the *--observe* flag.
@@ -2731,5 +2731,6 @@
 3.10 | Add 'invoke'.
 3.11 | Rename 'invoke' parameter 'receiverId' to 'targetId.
 3.12 | Add 'getScripts' RPC and `ScriptList` object.
+3.13 | Class 'mixin' field now properly set for kernel transformed mixin applications.
 
 [discuss-list]: https://groups.google.com/a/dartlang.org/forum/#!forum/observatory-discuss
diff --git a/runtime/vm/service/service_dev.md b/runtime/vm/service/service_dev.md
index afb751c..869811e 100644
--- a/runtime/vm/service/service_dev.md
+++ b/runtime/vm/service/service_dev.md
@@ -1,8 +1,8 @@
-# Dart VM Service Protocol 3.13-dev
+# Dart VM Service Protocol 3.14-dev
 
 > Please post feedback to the [observatory-discuss group][discuss-list]
 
-This document describes of _version 3.13-dev_ of the Dart VM Service Protocol. This
+This document describes of _version 3.14-dev_ of the Dart VM Service Protocol. This
 protocol is used to communicate with a running Dart Virtual Machine.
 
 To use the Service Protocol, start the VM with the *--observe* flag.
@@ -2731,5 +2731,6 @@
 3.10 | Add 'invoke'.
 3.11 | Rename 'invoke' parameter 'receiverId' to 'targetId.
 3.12 | Add 'getScripts' RPC and `ScriptList` object.
+3.13 | Class 'mixin' field now properly set for kernel transformed mixin applications.
 
 [discuss-list]: https://groups.google.com/a/dartlang.org/forum/#!forum/observatory-discuss
diff --git a/runtime/vm/snapshot.h b/runtime/vm/snapshot.h
index 14eeb06..1432259 100644
--- a/runtime/vm/snapshot.h
+++ b/runtime/vm/snapshot.h
@@ -65,7 +65,6 @@
 class RawLocalVarDescriptors;
 class RawMegamorphicCache;
 class RawMint;
-class RawMixinAppType;
 class RawNamespace;
 class RawObject;
 class RawObjectPool;
@@ -463,7 +462,6 @@
   friend class LibraryPrefix;
   friend class LinkedHashMap;
   friend class MirrorReference;
-  friend class MixinAppType;
   friend class Namespace;
   friend class PatchClass;
   friend class RedirectionData;
diff --git a/runtime/vm/symbols.h b/runtime/vm/symbols.h
index 933b83f5..536ad2b 100644
--- a/runtime/vm/symbols.h
+++ b/runtime/vm/symbols.h
@@ -167,7 +167,6 @@
   V(_Type, "_Type")                                                            \
   V(_TypeRef, "_TypeRef")                                                      \
   V(_TypeParameter, "_TypeParameter")                                          \
-  V(_MixinAppType, "_MixinAppType")                                            \
   V(TypeArguments, "TypeArguments")                                            \
   V(Patch, "patch")                                                            \
   V(Pragma, "pragma")                                                          \
diff --git a/runtime/vm/type_testing_stubs.cc b/runtime/vm/type_testing_stubs.cc
index 933742d..864d893 100644
--- a/runtime/vm/type_testing_stubs.cc
+++ b/runtime/vm/type_testing_stubs.cc
@@ -117,7 +117,6 @@
     return should_specialize ? StubCode::LazySpecializeTypeTest().instructions()
                              : StubCode::DefaultTypeTest().instructions();
   } else {
-    ASSERT(type.IsMixinAppType());
     return StubCode::UnreachableTypeTest().instructions();
   }
 }