Serialize ResolutionImpact instead of WorldImpact.

tests/compiler/dart2js/serialization_analysis_test.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_analysis_test;
 
 import 'dart:async';
 import 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
 import 'package:compiler/src/commandline_options.dart';
+import 'package:compiler/src/common/backend_api.dart';
 import 'package:compiler/src/common/names.dart';
 import 'package:compiler/src/common/resolution.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/filenames.dart';
 import 'package:compiler/src/serialization/element_serialization.dart';
 import 'package:compiler/src/serialization/impact_serialization.dart';
 import 'package:compiler/src/serialization/json_serializer.dart';
 import 'package:compiler/src/serialization/serialization.dart';
 import 'package:compiler/src/serialization/task.dart';
@@ skipping 219 matching lines @@
       memorySourceFiles: test != null ? test.sourceFiles : const {},
       options: [Flags.analyzeOnly],
       diagnosticHandler: diagnosticCollector,
       beforeRun: (Compiler compiler) {
         Deserializer deserializer = new Deserializer.fromText(
             new DeserializationContext(),
             serializedData,
             const JsonSerializationDecoder());
         deserializer.plugins.add(compiler.backend.serialization.deserializer);
         compiler.serialization.deserializer =
-            new _DeserializerSystem(deserializer);
+            new _DeserializerSystem(
+                deserializer,
+                compiler.backend.impactTransformer);
       });
   if (test != null) {
     Expect.equals(test.expectedErrorCount, diagnosticCollector.errors.length,
         "Unexpected error count.");
     Expect.equals(
         test.expectedWarningCount,
         diagnosticCollector.warnings.length,
         "Unexpected warning count.");
     Expect.equals(test.expectedHintCount, diagnosticCollector.hints.length,
         "Unexpected hint count.");
     Expect.equals(test.expectedInfoCount, diagnosticCollector.infos.length,
         "Unexpected info count.");
   }
 }
 
 Future<String> serializeDartCore() async {
   Compiler compiler = compilerFor(
       options: [Flags.analyzeAll]);
   compiler.serialization.supportSerialization = true;
   await compiler.run(Uris.dart_core);
   return serialize(compiler);
 }
 
 String serialize(Compiler compiler) {
   Serializer serializer = new Serializer();
   serializer.plugins.add(compiler.backend.serialization.serializer);
-  serializer.plugins.add(new WorldImpactSerializer(compiler.resolution));
+  serializer.plugins.add(new ResolutionImpactSerializer(compiler.resolution));
 
   for (LibraryElement library in compiler.libraryLoader.libraries) {
     serializer.serialize(library);
   }
   return serializer.toText(const JsonSerializationEncoder());
 }
 
 const String WORLD_IMPACT_TAG = 'worldImpact';
 
-class WorldImpactSerializer extends SerializerPlugin {
+class ResolutionImpactSerializer extends SerializerPlugin {
   final Resolution resolution;
 
-  WorldImpactSerializer(this.resolution);
+  ResolutionImpactSerializer(this.resolution);
 
   @override
   void onElement(Element element, ObjectEncoder createEncoder(String tag)) {
     if (resolution.hasBeenResolved(element)) {
-      WorldImpact impact = resolution.getWorldImpact(element);
+      ResolutionImpact impact = resolution.getResolutionImpact(element);
       ObjectEncoder encoder = createEncoder(WORLD_IMPACT_TAG);
-      impact.apply(new ImpactSerializer(encoder));
+      new ImpactSerializer(encoder).serialize(impact);
     }
   }
 }
 
-class WorldImpactDeserializer extends DeserializerPlugin {
-  Map<Element, WorldImpact> impactMap = <Element, WorldImpact>{};
+class ResolutionImpactDeserializer extends DeserializerPlugin {
+  Map<Element, ResolutionImpact> impactMap = <Element, ResolutionImpact>{};
 
   @override
   void onElement(Element element, ObjectDecoder getDecoder(String tag)) {
     ObjectDecoder decoder = getDecoder(WORLD_IMPACT_TAG);
     if (decoder != null) {
       impactMap[element] = ImpactDeserializer.deserializeImpact(decoder);
     }
   }
 }
 
 class _DeserializerSystem extends DeserializerSystem {
   final Deserializer _deserializer;
   final List<LibraryElement> deserializedLibraries = <LibraryElement>[];
-  final WorldImpactDeserializer _worldImpactDeserializer =
-      new WorldImpactDeserializer();
+  final ResolutionImpactDeserializer _resolutionImpactDeserializer =
+      new ResolutionImpactDeserializer();
+  final ImpactTransformer _impactTransformer;
 
-  _DeserializerSystem(this._deserializer) {
-    _deserializer.plugins.add(_worldImpactDeserializer);
+  _DeserializerSystem(this._deserializer, this._impactTransformer) {
+    _deserializer.plugins.add(_resolutionImpactDeserializer);
   }
 
   LibraryElement readLibrary(Uri resolvedUri) {
     LibraryElement library = _deserializer.lookupLibrary(resolvedUri);
     if (library != null) {
       deserializedLibraries.add(library);
     }
     return library;
   }
 
   @override
   WorldImpact computeWorldImpact(Element element) {
-    WorldImpact impact = _worldImpactDeserializer.impactMap[element];
-    if (impact == null) {
+    ResolutionImpact resolutionImpact =
+        _resolutionImpactDeserializer.impactMap[element];
+    if (resolutionImpact == null) {
       print('No impact found for $element (${element.library})');
-      impact = const WorldImpact();
+      return const WorldImpact();
+    } else {
+      return _impactTransformer.transformResolutionImpact(resolutionImpact);
     }
-    return impact;
   }
 
   @override
   bool isDeserialized(Element element) {
     return deserializedLibraries.contains(element.library);
   }
 }