Use JS backend in serialization_analysis_test

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,
   GENERATIVE_CONSTRUCTOR,
   FACTORY_CONSTRUCTOR,
   TOPLEVEL_FIELD,
   STATIC_FIELD,
   INSTANCE_FIELD,
   TOPLEVEL_FUNCTION,
   TOPLEVEL_GETTER,
   TOPLEVEL_SETTER,
   STATIC_FUNCTION,
   STATIC_GETTER,
@@ skipping 77 matching lines @@
 
   /// Serialize the parameters of [element] into [encoder].
   static void serializeParameters(FunctionElement element,
                                   ObjectEncoder encoder) {
     FunctionType type = element.type;
     encoder.setType(Key.RETURN_TYPE, type.returnType);
     encoder.setElements(Key.PARAMETERS, element.parameters);
   }
 
   /// Returns a function that adds the underlying declared elements for a
-  /// particular element into [list].
+  /// particular element into [set].
   ///
   /// For instance, for an [AbstractFieldElement] the getter and setter elements
   /// are added, if available.
-  static flattenElements(List<Element> list) {
+  static flattenElements(Set<Element> set) {
     return (Element element) {
+      if (element.isPatch) return;
       // TODO(johnniwinther): Handle ambiguous elements.
       if (element.isAmbiguous) return;
       if (element.isAbstractField) {
         AbstractFieldElement abstractField = element;
         if (abstractField.getter != null) {
-          list.add(abstractField.getter);
+          set.add(abstractField.getter);
         }
         if (abstractField.setter != null) {
-          list.add(abstractField.setter);
+          set.add(abstractField.setter);
         }
       } else {
-        list.add(element);
+        set.add(element);
       }
     };
   }
 }
 
 class LibrarySerializer implements ElementSerializer {
   const LibrarySerializer();
 
   SerializedElementKind getSerializedKind(Element element) {
     if (element.isLibrary) {
       return SerializedElementKind.LIBRARY;
     }
     return null;
   }
 
+  static List<CompilationUnitElement> getCompilationUnits(
+      LibraryElement element) {
+    List<CompilationUnitElement> compilationUnits = <CompilationUnitElement>[];
+    compilationUnits.addAll(element.compilationUnits.toList());
+    if (element.isPatched) {
+      compilationUnits.addAll(element.implementation.compilationUnits.toList());

[Siggi Cherem (dart-lang), 2016/03/16 17:27:22]

let's chat more on this - initially I was all in for unifying implementations
during serialization, but we may have reasons to move away from it.

I'd be OK submitting it now and adding a TODO about splitting this up though.

+    }
+    return compilationUnits;
+  }
+
+  static List<ImportElement> getImports(LibraryElement element) {
+    List<ImportElement> imports = <ImportElement>[];
+    imports.addAll(element.imports);
+    if (element.isPatched) {
+      imports.addAll(element.implementation.imports);
+    }
+    return imports;
+  }
+
+  static List<Element> getImportedElements(
+      LibraryElement element) {
+    Set<Element> importedElements = new Set<Element>();
+    element.forEachImport(SerializerUtil.flattenElements(importedElements));
+    if (element.isPatched) {
+      element.implementation.forEachImport(
+          SerializerUtil.flattenElements(importedElements));
+    }
+    return importedElements.toList();
+  }
+
+  static List<Element> getExportedElements(
+      LibraryElement element) {
+    Set<Element> exportedElements = new Set<Element>();
+    element.forEachExport(SerializerUtil.flattenElements(exportedElements));
+    return exportedElements.toList();
+  }
+
   void serialize(LibraryElement element,
                  ObjectEncoder encoder,
                  SerializedElementKind kind) {
     encoder.setUri(
         Key.CANONICAL_URI, element.canonicalUri, element.canonicalUri);
     encoder.setString(Key.LIBRARY_NAME, element.libraryName);
     SerializerUtil.serializeMembers(element, encoder);
     encoder.setElement(Key.COMPILATION_UNIT, element.entryCompilationUnit);
-    encoder.setElements(
-        Key.COMPILATION_UNITS, element.compilationUnits.toList());
-    encoder.setElements(Key.IMPORTS, element.imports);
+    encoder.setElements(Key.COMPILATION_UNITS, getCompilationUnits(element));
+    encoder.setElements(Key.IMPORTS, getImports(element));
     encoder.setElements(Key.EXPORTS, element.exports);
 
-    List<Element> importedElements = <Element>[];
-    element.forEachImport(SerializerUtil.flattenElements(importedElements));
-    encoder.setElements(Key.IMPORT_SCOPE, importedElements);
+    encoder.setElements(Key.IMPORT_SCOPE, getImportedElements(element));
 
-    List<Element> exportedElements = <Element>[];
-    element.forEachExport(SerializerUtil.flattenElements(exportedElements));
-    encoder.setElements(Key.EXPORT_SCOPE, exportedElements);
+    encoder.setElements(Key.EXPORT_SCOPE, getExportedElements(element));
 
   }
 }
 
 class CompilationUnitSerializer implements ElementSerializer {
   const CompilationUnitSerializer();
 
   SerializedElementKind getSerializedKind(Element element) {
     if (element.isCompilationUnit) {
       return SerializedElementKind.COMPILATION_UNIT;
     }
     return null;
   }
 
   void serialize(CompilationUnitElement element,
                  ObjectEncoder encoder,
                  SerializedElementKind kind) {
     encoder.setElement(Key.LIBRARY, element.library);
     encoder.setUri(
         Key.URI, element.library.canonicalUri, element.script.resourceUri);
     List<Element> elements = <Element>[];
-    element.forEachLocalMember((e) => elements.add(e));
+    element.forEachLocalMember((e) {
+      if (!element.isPatch) {
+        elements.add(e);
+      }
+    });
     encoder.setElements(Key.ELEMENTS, elements);
   }
 }
 
 class ClassSerializer implements ElementSerializer {
   const ClassSerializer();
 
   SerializedElementKind getSerializedKind(Element element) {
     if (element.isClass) {
+      ClassElement cls = element;
+      if (cls.isEnumClass) {
+        return SerializedElementKind.ENUM;
+      }
       return SerializedElementKind.CLASS;
     }
     return null;
   }
 
   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.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(element, encoder);
+    if (kind == SerializedElementKind.ENUM) {
+      EnumClassElement enumClass = element;
+      encoder.setElements(Key.FIELDS, enumClass.enumValues);
+    }
   }
 }
 
 class ConstructorSerializer implements ElementSerializer {
   const ConstructorSerializer();
 
   SerializedElementKind getSerializedKind(Element element) {
     if (element.isGenerativeConstructor) {
       return SerializedElementKind.GENERATIVE_CONSTRUCTOR;
     } else if (element.isFactoryConstructor) {
@@ skipping 94 matching lines @@
     encoder.setType(Key.TYPE, element.type);
     if (element.isFunction) {
       encoder.setBool(Key.IS_OPERATOR, element.isOperator);
     }
     if (element.enclosingClass != null) {
       encoder.setElement(Key.CLASS, element.enclosingClass);
     } else {
       encoder.setElement(Key.LIBRARY, element.library);
       encoder.setElement(Key.COMPILATION_UNIT, element.compilationUnit);
     }
+    encoder.setBool(Key.IS_EXTERNAL, element.isExternal);
   }
 }
 
 class TypedefSerializer implements ElementSerializer {
   const TypedefSerializer();
 
   SerializedElementKind getSerializedKind(Element element) {
     if (element.isTypedef) {
       return SerializedElementKind.TYPEDEF;
     }
@@ skipping 148 matching lines @@
   static Element deserialize(ObjectDecoder decoder) {
     SerializedElementKind elementKind =
         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.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 26 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}.");
   }
 }