Support serialization of WorldImpact

pkg/compiler/lib/src/serialization/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;
 
+import '../common/backend_api.dart';
 import '../elements/elements.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
+import '../universe/world_impact.dart';
 
+import 'constant_serialization.dart';
 import 'element_serialization.dart';
-import 'constant_serialization.dart';
+import 'impact_serialization.dart';
+import 'json_serializer.dart';
+import 'keys.dart';
 import 'type_serialization.dart';
-import 'keys.dart';
-import 'json_serializer.dart';
 import 'values.dart';
 
 /// An object that supports the encoding an [ObjectValue] for serialization.
 ///
 /// The [ObjectEncoder] ensures that nominality and circularities of
 /// non-primitive values like [Element], [DartType] and [ConstantExpression] are
 /// handled.
 class ObjectEncoder extends AbstractEncoder<Key> {
   /// Creates an [ObjectEncoder] in the scope of [serializer] that uses [map]
   /// as its internal storage.
@@ skipping 575 matching lines @@
 ///         {...}, // [ObjectValue] of the 0th [ConstantExpression].
 ///         ...
 ///         {...}, // [ObjectValue] of the n-th [ConstantExpression].
 ///       ],
 ///     }
 ///
 // TODO(johnniwinther): Support per-library serialization and dependencies
 // between serialized subcomponent.
 class Serializer {
   final SerializationEncoder _encoder;
+  List<SerializerPlugin> plugins = <SerializerPlugin>[];
 
   Map<Element, DataObject> _elementMap = <Element, DataObject>{};
   Map<ConstantExpression, DataObject> _constantMap =
       <ConstantExpression, DataObject>{};
   Map<DartType, DataObject> _typeMap = <DartType, DataObject>{};
   List _pendingList = [];
 
   Serializer(this._encoder);
 
   /// Add the transitive closure of [library] to this serializer.
   void serialize(LibraryElement library) {
     // Call [_getElementDataObject] for its side-effect: To create a
     // [DataObject] for [library]. If not already created, this will
     // put the serialization of [library] in the work queue.
     _getElementDataObject(library);
-    _emptyWorklist();
   }
 
   void _emptyWorklist() {
     while (_pendingList.isNotEmpty) {
       _pendingList.removeLast()();
     }
   }
 
   /// Returns the [DataObject] for [element].
   ///
   /// If [constant] has no [DataObject], a new [DataObject] is created and
   /// encoding the [ObjectValue] for [constant] is put into the work queue of
   /// this serializer.
   DataObject _getElementDataObject(Element element) {
     if (element == null) {
       throw new ArgumentError('Serializer._getElementDataObject(null)');
     }
-    return _elementMap.putIfAbsent(element, () {
+    DataObject dataObject = _elementMap[element];
+    if (dataObject == null) {
       // Run through [ELEMENT_SERIALIZERS] sequentially to find the one that
       // deals with [element].
       for (ElementSerializer serializer in ELEMENT_SERIALIZERS) {
         SerializedElementKind kind = serializer.getSerializedKind(element);
         if (kind != null) {
-          DataObject dataObject = new DataObject(
+          dataObject = new DataObject(
               new IntValue(_elementMap.length), new EnumValue(kind));
+          _elementMap[element] = dataObject;
           // Delay the serialization of the element itself to avoid loops, and
           // to keep the call stack small.
           _pendingList.add(() {
-            serializer.serialize(
-                element, new ObjectEncoder(this, dataObject.map), kind);
+            ObjectEncoder encoder = new ObjectEncoder(this, dataObject.map);
+            serializer.serialize(element, encoder, kind);
+
+            MapEncoder pluginData;
+            for (SerializerPlugin plugin in plugins) {
+              plugin.onElement(element, (String tag) {
+                if (pluginData == null) {
+                  pluginData = encoder.createMap(Key.DATA);
+                }
+                return pluginData.createObject(tag);
+              });
+            }
           });
-          return dataObject;
         }
       }
+    }
+    if (dataObject == null) {
       throw new UnsupportedError(
           'Unsupported element: $element (${element.kind})');
-    });
+    }
+    return dataObject;
   }
 
   /// Creates the [ElementValue] for [element].
   ///
   /// If [element] has not already been serialized, it is added to the work
   /// queue of this serializer.
   ElementValue createElementValue(Element element) {
     return new ElementValue(element, _getElementDataObject(element).id);
   }
 
@@ skipping 50 matching lines @@
 
   /// Creates the [TypeValue] for [type].
   ///
   /// If [type] has not already been serialized, it is added to the work
   /// queue of this serializer.
   TypeValue createTypeValue(DartType type) {
     return new TypeValue(type, _getTypeDataObject(type).id);
   }
 
   ObjectValue get objectValue {
+    _emptyWorklist();
+
     Map<Key, Value> map = <Key, Value>{};
     map[Key.ELEMENTS] =
         new ListValue(_elementMap.values.map((l) => l.objectValue).toList());
     if (_typeMap.isNotEmpty) {
       map[Key.TYPES] =
           new ListValue(_typeMap.values.map((l) => l.objectValue).toList());
     }
     if (_constantMap.isNotEmpty) {
       map[Key.CONSTANTS] =
           new ListValue(_constantMap.values.map((l) => l.objectValue).toList());
     }
     return new ObjectValue(map);
   }
 
   String toText() {
     return _encoder.encode(objectValue);
   }
 
   String prettyPrint() {
     PrettyPrintEncoder encoder = new PrettyPrintEncoder();
     return encoder.toText(objectValue);
   }
 }
 
+/// Plugin for serializing additional data for an [Element].
+class SerializerPlugin {
+  const SerializerPlugin();
+
+  /// Called upon the serialization of [element].
+  ///
+  /// Use [creatorEncoder] to create a data object with id [tag] for storing
+  /// additional data for [element].
+  void onElement(Element element, ObjectEncoder createEncoder(String tag)) {}
+}
+
+/// Plugin for deserializing additional data for an [Element].
+class DeserializerPlugin {
+  const DeserializerPlugin();
+
+  /// Called upon the deserialization of [element].
+  ///
+  /// Use [getDecoder] to retrieve the data object with id [tag] stored for
+  /// [element]. If not object is stored for [tag], [getDecoder] returns `null`.
+  void onElement(Element element, ObjectDecoder getDecoder(String tag)) {}
+}
+
 /// Deserializer for a closed collection of libraries.
 // TODO(johnniwinther): Support per-library deserialization and dependencies
 // between deserialized subcomponent.
 class Deserializer {
   final SerializationDecoder decoder;
+  List<DeserializerPlugin> plugins = <DeserializerPlugin>[];
   ObjectDecoder _headerObject;
   ListDecoder _elementList;
   ListDecoder _typeList;
   ListDecoder _constantList;
   Map<int, Element> _elementMap = {};
   Map<int, DartType> _typeMap = {};
   Map<int, ConstantExpression> _constantMap = {};
 
   Deserializer.fromText(String text, this.decoder) {
     _headerObject = new ObjectDecoder(this, decoder.decode(text));
@@ skipping 38 matching lines @@
           return deserializeElement(object.getInt(Key.ID));
         }
       }
     }
     return null;
   }
 
   /// Returns the deserialized [Element] for [id].
   Element deserializeElement(int id) {
     if (id == null) throw new ArgumentError('Deserializer.getElement(null)');
-    return _elementMap.putIfAbsent(id, () {
-      return ElementDeserializer.deserialize(elements.getObject(id));
-    });
+    Element element = _elementMap[id];
+    if (element == null) {
+      ObjectDecoder decoder = elements.getObject(id);
+      element = ElementDeserializer.deserialize(decoder);
+      _elementMap[id] = element;
+
+      MapDecoder pluginData = decoder.getMap(Key.DATA, isOptional: true);
+      // Call plugins even when there is no data, so they can take action in
+      // this case.
+      for (DeserializerPlugin plugin in plugins) {
+        plugin.onElement(element,
+          (String tag) => pluginData?.getObject(tag, isOptional: true));
+      }
+    }
+    return element;
   }
 
   /// Returns the deserialized [DartType] for [id].
   DartType deserializeType(int id) {
     if (id == null) throw new ArgumentError('Deserializer.getType(null)');
     return _typeMap.putIfAbsent(id, () {
       return TypeDeserializer.deserialize(types.getObject(id));
     });
   }
 
@@ skipping 21 matching lines @@
 
   /// Returns the value used to store [key] as a property in the encoding an
   /// [ObjectValue].
   ///
   /// Different encodings have different restrictions and capabilities as how
   /// to store a [Key] value. For instance: A JSON encoding needs to convert
   /// [Key] to a [String] to store it in a JSON object; a Dart encoding can
   /// choose to store a [Key] as an [int] or as the [Key] itself.
   getObjectPropertyValue(Key key);
 }