Don't serialize unnamed mixin applications.

pkg/compiler/lib/src/serialization/element_serialization.dart

 // Copyright (c) 2015, 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.
 
 library dart2js.serialization.elements;
 
 import '../common.dart';
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import 'constant_serialization.dart';
 import 'keys.dart';
 import 'modelz.dart';
 import 'serialization.dart';
 
 /// Enum kinds used for encoding [Element]s.
 enum SerializedElementKind {
   LIBRARY,
   COMPILATION_UNIT,
   CLASS,
   ENUM,
+  NAMED_MIXIN_APPLICATION,
   GENERATIVE_CONSTRUCTOR,
   FACTORY_CONSTRUCTOR,
   TOPLEVEL_FIELD,
   STATIC_FIELD,
   INSTANCE_FIELD,
   TOPLEVEL_FUNCTION,
   TOPLEVEL_GETTER,
   TOPLEVEL_SETTER,
   STATIC_FUNCTION,
   STATIC_GETTER,
@@ skipping 212 matching lines @@
 }
 
 class ClassSerializer implements ElementSerializer {
   const ClassSerializer();
 
   SerializedElementKind getSerializedKind(Element element) {
     if (element.isClass) {
       ClassElement cls = element;
       if (cls.isEnumClass) {
         return SerializedElementKind.ENUM;
+      } else if (cls.isMixinApplication) {
+        if (!cls.isUnnamedMixinApplication) {
+          return SerializedElementKind.NAMED_MIXIN_APPLICATION;
+        }
+      } else {
+        return SerializedElementKind.CLASS;
       }
-      return SerializedElementKind.CLASS;
     }
     return null;
   }
 
   static List<Element> getMembers(ClassElement element) {
     List<Element> members = <Element>[];
     element.forEachLocalMember(members.add);
     if (element.isPatched) {
       element.implementation.forEachLocalMember((Element member) {
         if (!member.isPatch) {
           members.add(member);
         }
       });
     }
     return members;
   }
 
   void serialize(ClassElement element,
                  ObjectEncoder encoder,
                  SerializedElementKind kind) {
     encoder.setElement(Key.LIBRARY, element.library);
     encoder.setElement(Key.COMPILATION_UNIT, element.compilationUnit);
     encoder.setString(Key.NAME, element.name);
     SerializerUtil.serializePosition(element, encoder);
     encoder.setTypes(Key.TYPE_VARIABLES, element.typeVariables);
     encoder.setBool(Key.IS_ABSTRACT, element.isAbstract);
-    if (element.isUnnamedMixinApplication) {
-      encoder.setBool(Key.IS_UNNAMED_MIXIN_APPLICATION, true);
-    }
-    if (element.supertype != null) {
-      encoder.setType(Key.SUPERTYPE, element.supertype);
-    }
-    // TODO(johnniwinther): Make [OrderedTypeSet] easier to (de)serialize.
-    ObjectEncoder supertypes = encoder.createObject(Key.SUPERTYPES);
-    supertypes.setTypes(Key.TYPES,
-        element.allSupertypesAndSelf.types.toList());
-    supertypes.setTypes(Key.SUPERTYPES,
-        element.allSupertypesAndSelf.supertypes.toList());
-    supertypes.setInts(Key.OFFSETS, element.allSupertypesAndSelf.levelOffsets);
-    encoder.setTypes(Key.INTERFACES, element.interfaces.toList());
     SerializerUtil.serializeMembers(getMembers(element), encoder);
     encoder.setBool(Key.IS_PROXY, element.isProxy);
     if (kind == SerializedElementKind.ENUM) {
       EnumClassElement enumClass = element;
       encoder.setElements(Key.FIELDS, enumClass.enumValues);
     }
+    if (element.isObject) return;
+
+    List<InterfaceType> mixins = <InterfaceType>[];
+    ClassElement superclass = element.superclass;
+    while (superclass.isUnnamedMixinApplication) {
+      MixinApplicationElement mixinElement = superclass;
+      mixins.add(element.thisType.asInstanceOf(mixinElement.mixin));
+      superclass = mixinElement.superclass;
+    }
+    mixins = mixins.reversed.toList();
+    InterfaceType supertype = element.thisType.asInstanceOf(superclass);
+
+
+    encoder.setType(Key.SUPERTYPE, supertype);
+    encoder.setTypes(Key.MIXINS, mixins);
+    encoder.setTypes(Key.INTERFACES, element.interfaces.toList());
+
+    if (element.isMixinApplication) {
+      MixinApplicationElement mixinElement = element;
+      encoder.setType(Key.MIXIN, mixinElement.mixinType);
+    }
   }
 }
 
 class ConstructorSerializer implements ElementSerializer {
   const ConstructorSerializer();
 
   SerializedElementKind getSerializedKind(Element element) {
     if (element.isGenerativeConstructor) {
       return SerializedElementKind.GENERATIVE_CONSTRUCTOR;
     } else if (element.isFactoryConstructor) {
       return SerializedElementKind.FACTORY_CONSTRUCTOR;
     }
     return null;
   }
 
   void serialize(ConstructorElement element,
                  ObjectEncoder encoder,
                  SerializedElementKind kind) {
     encoder.setElement(Key.CLASS, element.enclosingClass);
     encoder.setType(Key.TYPE, element.type);
     encoder.setString(Key.NAME, element.name);
     SerializerUtil.serializePosition(element, encoder);
     SerializerUtil.serializeParameters(element, encoder);
     encoder.setBool(Key.IS_CONST, element.isConst);
-    // TODO(johnniwinther): Handle external constructors.
     encoder.setBool(Key.IS_EXTERNAL, element.isExternal);
     if (element.isExternal) return;
     if (element.isConst && !element.isFromEnvironmentConstructor) {
       ConstantConstructor constantConstructor = element.constantConstructor;
       ObjectEncoder constantEncoder =
           encoder.createObject(Key.CONSTRUCTOR);
       const ConstantConstructorSerializer().visit(
           constantConstructor, constantEncoder);
     }
   }
@@ skipping 248 matching lines @@
         decoder.getEnum(Key.KIND, SerializedElementKind.values);
     switch (elementKind) {
       case SerializedElementKind.LIBRARY:
         return new LibraryElementZ(decoder);
       case SerializedElementKind.COMPILATION_UNIT:
         return new CompilationUnitElementZ(decoder);
       case SerializedElementKind.CLASS:
         return new ClassElementZ(decoder);
       case SerializedElementKind.ENUM:
         return new EnumClassElementZ(decoder);
+      case SerializedElementKind.NAMED_MIXIN_APPLICATION:
+        return new NamedMixinApplicationElementZ(decoder);
       case SerializedElementKind.TOPLEVEL_FIELD:
         return new TopLevelFieldElementZ(decoder);
       case SerializedElementKind.STATIC_FIELD:
         return new StaticFieldElementZ(decoder);
       case SerializedElementKind.INSTANCE_FIELD:
         return new InstanceFieldElementZ(decoder);
       case SerializedElementKind.GENERATIVE_CONSTRUCTOR:
         return new GenerativeConstructorElementZ(decoder);
       case SerializedElementKind.FACTORY_CONSTRUCTOR:
         return new FactoryConstructorElementZ(decoder);
@@ skipping 28 matching lines @@
       case SerializedElementKind.IMPORT:
         return new ImportElementZ(decoder);
       case SerializedElementKind.EXPORT:
         return new ExportElementZ(decoder);
       case SerializedElementKind.PREFIX:
         return new PrefixElementZ(decoder);
     }
     throw new UnsupportedError("Unexpected element kind '${elementKind}.");
   }
 }