Support serialization of WorldImpact

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';
@@ skipping 16 matching lines @@
   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,
 }
 
 /// Set of serializers used to serialize different kinds of elements by
@@ skipping 26 matching lines @@
 
   /// Serializes [element] into the [encoder] using the [kind] computed
   /// by [getSerializedKind].
   void serialize(Element element,
                  ObjectEncoder encoder,
                  SerializedElementKind kind);
 }
 
 class SerializerUtil {
   /// Serialize the declared members of [element] into [encoder].
-  static void serializeMembers(ScopeContainerElement element,
+  static void serializeMembers(Iterable<Element> members,
                                ObjectEncoder encoder) {
     MapEncoder mapEncoder = encoder.createMap(Key.MEMBERS);
-    element.forEachLocalMember((Element member) {
+    for (Element member in members) {
       String name = member.name;
       if (member.isSetter) {
         name = '$name,=';
       }
       mapEncoder.setElement(name, member);
-    });
+    }
   }
 
   /// Serialize the source position of [element] into [encoder].
   static void serializePosition(Element element, ObjectEncoder encoder) {
     if (element.sourcePosition != null) {
       SourceSpan position = element.sourcePosition;
       encoder.setInt(Key.OFFSET, position.begin);
       if (position.uri != element.compilationUnit.script.resourceUri) {
         // TODO(johnniwinther): What is the base URI in the case?
         encoder.setUri(Key.URI, element.library.canonicalUri, position.uri);
@@ skipping 41 matching lines @@
 class LibrarySerializer implements ElementSerializer {
   const LibrarySerializer();
 
   SerializedElementKind getSerializedKind(Element element) {
     if (element.isLibrary) {
       return SerializedElementKind.LIBRARY;
     }
     return null;
   }
 
+  static List<Element> getMembers(LibraryElement element) {
+    List<Element> members = <Element>[];
+    element.implementation.forEachLocalMember((Element member) {
+      if (!member.isPatch) {
+        members.add(member);
+      }
+    });
+    return members;
+  }
+
   static List<CompilationUnitElement> getCompilationUnits(
       LibraryElement element) {
     List<CompilationUnitElement> compilationUnits = <CompilationUnitElement>[];
     compilationUnits.addAll(element.compilationUnits.toList());
     if (element.isPatched) {
       compilationUnits.addAll(element.implementation.compilationUnits.toList());
     }
     return compilationUnits;
   }
 
@@ skipping 23 matching lines @@
     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);
+    SerializerUtil.serializeMembers(getMembers(element), encoder);
     encoder.setElement(Key.COMPILATION_UNIT, element.entryCompilationUnit);
     encoder.setElements(Key.COMPILATION_UNITS, getCompilationUnits(element));
     encoder.setElements(Key.IMPORTS, getImports(element));
     encoder.setElements(Key.EXPORTS, element.exports);
 
     encoder.setElements(Key.IMPORT_SCOPE, getImportedElements(element));
 
     encoder.setElements(Key.EXPORT_SCOPE, getExportedElements(element));
 
   }
@@ skipping 32 matching lines @@
     if (element.isClass) {
       ClassElement cls = element;
       if (cls.isEnumClass) {
         return SerializedElementKind.ENUM;
       }
       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.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);
+    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);
     }
+
   }
 }
 
 class ConstructorSerializer implements ElementSerializer {
   const ConstructorSerializer();
 
   SerializedElementKind getSerializedKind(Element element) {
     if (element.isGenerativeConstructor) {
       return SerializedElementKind.GENERATIVE_CONSTRUCTOR;
     } else if (element.isFactoryConstructor) {
@@ skipping 60 matching lines @@
 class FunctionSerializer implements ElementSerializer {
   const FunctionSerializer();
 
   SerializedElementKind getSerializedKind(Element element) {
     if (element.isFunction) {
       if (element.isTopLevel) return SerializedElementKind.TOPLEVEL_FUNCTION;
       if (element.isStatic) return SerializedElementKind.STATIC_FUNCTION;
       if (element.isInstanceMember) {
         return SerializedElementKind.INSTANCE_FUNCTION;
       }
+      if (element.isLocal) {
+        return SerializedElementKind.LOCAL_FUNCTION;
+      }
     }
     if (element.isGetter) {
       if (element.isTopLevel) return SerializedElementKind.TOPLEVEL_GETTER;
       if (element.isStatic) return SerializedElementKind.STATIC_GETTER;
       if (element.isInstanceMember) {
         return SerializedElementKind.INSTANCE_GETTER;
       }
     }
     if (element.isSetter) {
       if (element.isTopLevel) return SerializedElementKind.TOPLEVEL_SETTER;
@@ skipping 15 matching lines @@
     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);
+    if (element.isLocal) {
+      LocalFunctionElement localFunction = element;
+      encoder.setElement(
+          Key.EXECUTABLE_CONTEXT, localFunction.executableContext);
+    }
   }
 }
 
 class TypedefSerializer implements ElementSerializer {
   const TypedefSerializer();
 
   SerializedElementKind getSerializedKind(Element element) {
     if (element.isTypedef) {
       return SerializedElementKind.TYPEDEF;
     }
@@ skipping 166 matching lines @@
       case SerializedElementKind.GENERATIVE_CONSTRUCTOR:
         return new GenerativeConstructorElementZ(decoder);
       case SerializedElementKind.FACTORY_CONSTRUCTOR:
         return new FactoryConstructorElementZ(decoder);
       case SerializedElementKind.TOPLEVEL_FUNCTION:
         return new TopLevelFunctionElementZ(decoder);
       case SerializedElementKind.STATIC_FUNCTION:
         return new StaticFunctionElementZ(decoder);
       case SerializedElementKind.INSTANCE_FUNCTION:
         return new InstanceFunctionElementZ(decoder);
+      case SerializedElementKind.LOCAL_FUNCTION:
+        return new LocalFunctionElementZ(decoder);
       case SerializedElementKind.TOPLEVEL_GETTER:
         return new TopLevelGetterElementZ(decoder);
       case SerializedElementKind.STATIC_GETTER:
         return new StaticGetterElementZ(decoder);
       case SerializedElementKind.INSTANCE_GETTER:
         return new InstanceGetterElementZ(decoder);
       case SerializedElementKind.TOPLEVEL_SETTER:
         return new TopLevelSetterElementZ(decoder);
       case SerializedElementKind.STATIC_SETTER:
         return new StaticSetterElementZ(decoder);
@@ skipping 10 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}.");
   }
 }