Support per-library serialization.

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,
   STATIC_SETTER,
   INSTANCE_FUNCTION,
   INSTANCE_GETTER,
   INSTANCE_SETTER,
   LOCAL_FUNCTION,
   TYPEDEF,
   TYPEVARIABLE,
   PARAMETER,
   INITIALIZING_FORMAL,
   IMPORT,
   EXPORT,
   PREFIX,
+  EXTERNAL_LIBRARY,
+  EXTERNAL_LIBRARY_MEMBER,
+  EXTERNAL_STATIC_MEMBER,
+  EXTERNAL_CONSTRUCTOR,
 }
 
 /// Set of serializers used to serialize different kinds of elements by
 /// encoding into them into [ObjectEncoder]s.
 ///
 /// This class is called from the [Serializer] when an [Element] needs
 /// serialization. The [ObjectEncoder] ensures that any [Element], [DartType],
 /// and [ConstantExpression] that the serialized [Element] depends upon are also
 /// serialized.
 const List<ElementSerializer> ELEMENT_SERIALIZERS = const [
@@ skipping 190 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 236 matching lines @@
 ///
 /// This is used by the [Deserializer].
 class ElementDeserializer {
 
   /// Deserializes an [Element] from an [ObjectDecoder].
   ///
   /// The class is called from the [Deserializer] when an [Element]
   /// needs deserialization. The [ObjectDecoder] ensures that any [Element],
   /// [DartType], and [ConstantExpression] that the deserialized [Element]
   /// depends upon are available.
-  static Element deserialize(ObjectDecoder decoder) {
-    SerializedElementKind elementKind =
-        decoder.getEnum(Key.KIND, SerializedElementKind.values);
+  static Element deserialize(
+      ObjectDecoder decoder,
+      SerializedElementKind elementKind) {
     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 24 matching lines @@
       case SerializedElementKind.PARAMETER:
         return new ParameterElementZ(decoder);
       case SerializedElementKind.INITIALIZING_FORMAL:
         return new InitializingFormalElementZ(decoder);
       case SerializedElementKind.IMPORT:
         return new ImportElementZ(decoder);
       case SerializedElementKind.EXPORT:
         return new ExportElementZ(decoder);
       case SerializedElementKind.PREFIX:
         return new PrefixElementZ(decoder);
+      case SerializedElementKind.EXTERNAL_LIBRARY:
+      case SerializedElementKind.EXTERNAL_LIBRARY_MEMBER:
+      case SerializedElementKind.EXTERNAL_STATIC_MEMBER:
+      case SerializedElementKind.EXTERNAL_CONSTRUCTOR:
+        break;
     }
     throw new UnsupportedError("Unexpected element kind '${elementKind}.");
   }
 }