Support deserialization of ResolutionImpact for members of unnamed mixin applications

pkg/compiler/lib/src/serialization/impact_serialization.dart

 // Copyright (c) 2016, 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.impact;
 
+import '../common.dart';
 import '../common/resolution.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../universe/selector.dart';
 import '../universe/use.dart';
 import '../universe/world_impact.dart';
 import '../util/enumset.dart';
 import 'keys.dart';
 import 'serialization.dart';
 import 'serialization_util.dart';
 
 /// Visitor that serializes a [ResolutionImpact] object using an
 /// [ObjectEncoder].
 class ImpactSerializer implements WorldImpactVisitor {
+  final Element element;
   final ObjectEncoder objectEncoder;
   final ListEncoder staticUses;
   final ListEncoder dynamicUses;
   final ListEncoder typeUses;
 
-  ImpactSerializer(ObjectEncoder objectEncoder)
+  ImpactSerializer(this.element, ObjectEncoder objectEncoder)
       : this.objectEncoder = objectEncoder,
         staticUses = objectEncoder.createList(Key.STATIC_USES),
         dynamicUses = objectEncoder.createList(Key.DYNAMIC_USES),
         typeUses = objectEncoder.createList(Key.TYPE_USES);
 
   void serialize(ResolutionImpact resolutionImpact) {
     resolutionImpact.apply(this);
     objectEncoder.setStrings(Key.SYMBOLS, resolutionImpact.constSymbolNames);
     objectEncoder.setConstants(
         Key.CONSTANTS, resolutionImpact.constantLiterals);
@@ skipping 19 matching lines @@
   }
 
   @override
   void visitDynamicUse(DynamicUse dynamicUse) {
     ObjectEncoder object = dynamicUses.createObject();
     serializeSelector(dynamicUse.selector, object);
   }
 
   @override
   void visitStaticUse(StaticUse staticUse) {
-    if (staticUse.element.isGenerativeConstructor &&
-        staticUse.element.enclosingClass.isUnnamedMixinApplication) {
-      // TODO(johnniwinther): Handle static use of forwarding constructors.
-      return;
-    }
     ObjectEncoder object = staticUses.createObject();
     object.setEnum(Key.KIND, staticUse.kind);
-    object.setElement(Key.ELEMENT, staticUse.element);
+    serializeElementReference(
+        element, Key.ELEMENT, Key.NAME, object, staticUse.element);
   }
 
   @override
   void visitTypeUse(TypeUse typeUse) {
     ObjectEncoder object = typeUses.createObject();
     object.setEnum(Key.KIND, typeUse.kind);
     object.setType(Key.TYPE, typeUse.type);
   }
 }
 
 /// A deserialized [WorldImpact] object.
 class DeserializedResolutionImpact extends WorldImpact
     implements ResolutionImpact {
   final Iterable<String> constSymbolNames;
   final Iterable<ConstantExpression> constantLiterals;
   final Iterable<DynamicUse> dynamicUses;
   final EnumSet<Feature> _features;
   final Iterable<ListLiteralUse> listLiterals;
   final Iterable<MapLiteralUse> mapLiterals;
   final Iterable<StaticUse> staticUses;
   final Iterable<TypeUse> typeUses;
 
   DeserializedResolutionImpact(
-      {this.constSymbolNames,
-      this.constantLiterals,
-      this.dynamicUses,
+      {this.constSymbolNames: const <String>[],
+      this.constantLiterals: const <ConstantExpression>[],
+      this.dynamicUses: const <DynamicUse>[],
       EnumSet<Feature> features,
-      this.listLiterals,
-      this.mapLiterals,
-      this.staticUses,
-      this.typeUses})
+      this.listLiterals: const <ListLiteralUse>[],
+      this.mapLiterals: const <MapLiteralUse>[],
+      this.staticUses: const <StaticUse>[],
+      this.typeUses: const <TypeUse>[]})
       : this._features = features;
 
-  Iterable<Feature> get features => _features.iterable(Feature.values);
+  Iterable<Feature> get features {
+    return _features != null
+        ? _features.iterable(Feature.values)
+        : const <Feature>[];
+  }
 }
 
 class ImpactDeserializer {
   /// Deserializes a [WorldImpact] from [objectDecoder].
-  static ResolutionImpact deserializeImpact(ObjectDecoder objectDecoder) {
+  static ResolutionImpact deserializeImpact(
+      Element element, ObjectDecoder objectDecoder) {
     ListDecoder staticUseDecoder = objectDecoder.getList(Key.STATIC_USES);
     List<StaticUse> staticUses = <StaticUse>[];
     for (int index = 0; index < staticUseDecoder.length; index++) {
       ObjectDecoder object = staticUseDecoder.getObject(index);
       StaticUseKind kind = object.getEnum(Key.KIND, StaticUseKind.values);
-      Element element = object.getElement(Key.ELEMENT);
-      staticUses.add(new StaticUse.internal(element, kind));
+      Element usedElement =
+          deserializeElementReference(element, Key.ELEMENT, Key.NAME, object);
+      staticUses.add(new StaticUse.internal(usedElement, kind));
     }
 
     ListDecoder dynamicUseDecoder = objectDecoder.getList(Key.DYNAMIC_USES);
     List<DynamicUse> dynamicUses = <DynamicUse>[];
     for (int index = 0; index < dynamicUseDecoder.length; index++) {
       ObjectDecoder object = dynamicUseDecoder.getObject(index);
       Selector selector = deserializeSelector(object);
       dynamicUses.add(new DynamicUse(selector, null));
     }
 
@@ skipping 49 matching lines @@
         constSymbolNames: constSymbolNames,
         constantLiterals: constantLiterals,
         dynamicUses: dynamicUses,
         features: features,
         listLiterals: listLiterals,
         mapLiterals: mapLiterals,
         staticUses: staticUses,
         typeUses: typeUses);
   }
 }