[Kernel] Remove handling of mixin classes, since they are desugared in the frontend

runtime/vm/kernel_reader.cc

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/kernel_reader.h"
 
 #include <string.h>
 
 #include "vm/dart_api_impl.h"
 #include "vm/longjump.h"
@@ skipping 207 matching lines @@
 
   // Load all classes.
   for (intptr_t i = 0; i < kernel_library->classes().length(); i++) {
     Class* kernel_klass = kernel_library->classes()[i];
     ReadClass(library, kernel_klass);
   }
 }
 
 void KernelReader::ReadPreliminaryClass(dart::Class* klass,
                                         Class* kernel_klass) {
+  ASSERT(kernel_klass->IsNormalClass());
+  NormalClass* kernel_normal_class = NormalClass::Cast(kernel_klass);
+
   ActiveClassScope active_class_scope(&active_class_, kernel_klass, klass);
 
   // First setup the type parameters, so if any of the following code uses it
   // (in a recursive way) we're fine.
   TypeArguments& type_parameters =
       TypeArguments::Handle(Z, TypeArguments::null());
   intptr_t num_type_parameters = kernel_klass->type_parameters().length();
   if (num_type_parameters > 0) {
     dart::TypeParameter& parameter = dart::TypeParameter::Handle(Z);
     Type& null_bound = Type::Handle(Z, Type::null());
@@ skipping 23 matching lines @@
         if (bound.IsMalformedOrMalbounded()) {
           bound = I->object_store()->object_type();
         }
 
         parameter ^= type_parameters.TypeAt(i);
         parameter.set_bound(bound);
       }
     }
   }
 
-  if (kernel_klass->IsNormalClass()) {
-    NormalClass* kernel_normal_class = NormalClass::Cast(kernel_klass);
-
-    // Set super type.  Some classes (e.g., Object) do not have one.
-    if (kernel_normal_class->super_class() != NULL) {
-      AbstractType& super_type = T.TranslateTypeWithoutFinalization(
-          kernel_normal_class->super_class());
-      if (super_type.IsMalformed()) H.ReportError("Malformed super type");
-      klass->set_super_type(super_type);
-    }
-  } else {
-    MixinClass* kernel_mixin = MixinClass::Cast(kernel_klass);
-
-    // Set super type.
-    AbstractType& super_type =
-        T.TranslateTypeWithoutFinalization(kernel_mixin->first());
-    if (super_type.IsMalformed()) H.ReportError("Malformed super type.");
+  // Set super type.  Some classes (e.g., Object) do not have one.
+  if (kernel_normal_class->super_class() != NULL) {
+    AbstractType& super_type = T.TranslateTypeWithoutFinalization(
+        kernel_normal_class->super_class());
+    if (super_type.IsMalformed()) H.ReportError("Malformed super type");
     klass->set_super_type(super_type);
-
-    // Tell the rest of the system there is nothing to resolve.
-    super_type.SetIsResolved();
-
-    // Set mixin type.
-    AbstractType& mixin_type =
-        T.TranslateTypeWithoutFinalization(kernel_mixin->second());
-    if (mixin_type.IsMalformed()) H.ReportError("Malformed mixin type.");
-    klass->set_mixin(Type::Cast(mixin_type));
   }
 
   // Build implemented interface types
   intptr_t interface_count = kernel_klass->implemented_classes().length();
   const dart::Array& interfaces =
       dart::Array::Handle(Z, dart::Array::New(interface_count));
   dart::Class& interface_class = dart::Class::Handle(Z);
   for (intptr_t i = 0; i < interface_count; i++) {
     InterfaceType* kernel_interface_type =
         kernel_klass->implemented_classes()[i];
@@ skipping 399 matching lines @@
   if (kind == Procedure::kIncompleteProcedure) {
     return RawFunction::kSignatureFunction;
   } else {
     ASSERT(0 <= kind && kind <= Procedure::kFactory);
     return static_cast<RawFunction::Kind>(lookuptable[kind]);
   }
 }
 
 }  // namespace kernel
 }  // namespace dart