Add model test of CodegenWorldBuilder to compile_from_dill_test

pkg/compiler/lib/src/universe/member_usage.dart

 // Copyright (c) 2017, 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.
 
 part of world_builder;
 
-abstract class _AbstractUsage<T> {
+abstract class AbstractUsage<T> {
   final EnumSet<T> _pendingUse = new EnumSet<T>();
 
-  _AbstractUsage() {
+  AbstractUsage() {
     _pendingUse.addAll(_originalUse);
   }
 
   /// Returns the possible uses of [entity] that have not yet been registered.
   EnumSet<T> get pendingUse => _pendingUse;
 
   /// Returns the uses of [entity] that have been registered.
   EnumSet<T> get appliedUse => _originalUse.minus(_pendingUse);
 
   EnumSet<T> get _originalUse;
 
   /// `true` if the [appliedUse] is non-empty.
   bool get hasUse => appliedUse.isNotEmpty;
+
+  /// Returns `true` if [other] has the same original and pending usage as this.
+  bool hasSameUsage(AbstractUsage<T> other) {
+    if (identical(this, other)) return true;
+    return _originalUse.value == other._originalUse.value &&
+        _pendingUse.value == other._pendingUse.value;
+  }
 }
 
 /// Registry for the observed use of a member [entity] in the open world.
-abstract class _MemberUsage extends _AbstractUsage<MemberUse> {
+abstract class _MemberUsage extends AbstractUsage<MemberUse> {
   // TODO(johnniwinther): Change [Entity] to [MemberEntity].
   final Entity entity;
 
   _MemberUsage.internal(this.entity);
 
   factory _MemberUsage(MemberEntity member, {bool isNative: false}) {
     if (member.isField) {
       if (member.isAssignable) {
         return new _FieldUsage(member, isNative: isNative);
       } else {
@@ skipping 50 matching lines @@
   EnumSet<MemberUse> get _originalUse => MemberUses.NORMAL_ONLY;
 
   int get hashCode => entity.hashCode;
 
   bool operator ==(other) {
     if (identical(this, other)) return true;
     if (other is! _MemberUsage) return false;
     return entity == other.entity;
   }
 
-  String toString() => entity.toString();
+  String toString() => '$entity:${appliedUse.iterable(MemberUse.values)}';
 }
 
 class _FieldUsage extends _MemberUsage {
   bool hasRead = false;
   bool hasWrite = false;
 
   _FieldUsage(FieldEntity field, {bool isNative: false})
       : super.internal(field) {
     if (!isNative) {
       // All field initializers must be resolved as they could
@@ skipping 171 matching lines @@
   static const EnumSet<MemberUse> ALL_INSTANCE =
       const EnumSet<MemberUse>.fixed(3);
   static const EnumSet<MemberUse> ALL_STATIC =
       const EnumSet<MemberUse>.fixed(5);
 }
 
 typedef void MemberUsedCallback(MemberEntity member, EnumSet<MemberUse> useSet);
 
 /// Registry for the observed use of a class [entity] in the open world.
 // TODO(johnniwinther): Merge this with [InstantiationInfo].
-class _ClassUsage extends _AbstractUsage<ClassUse> {
+class _ClassUsage extends AbstractUsage<ClassUse> {
   bool isInstantiated = false;
   bool isImplemented = false;
 
   final ClassEntity cls;
 
   _ClassUsage(this.cls);
 
   EnumSet<ClassUse> instantiate() {
     if (isInstantiated) {
       return ClassUses.NONE;
     }
     isInstantiated = true;
     return _pendingUse.removeAll(ClassUses.INSTANTIATED_ONLY);
   }
 
   EnumSet<ClassUse> implement() {
     if (isImplemented) {
       return ClassUses.NONE;
     }
     isImplemented = true;
     return _pendingUse.removeAll(ClassUses.IMPLEMENTED_ONLY);
   }
 
   @override
   EnumSet<ClassUse> get _originalUse => ClassUses.ALL;
 
-  String toString() => cls.toString();
+  String toString() => '$cls:${appliedUse.iterable(ClassUse.values)}';
 }
 
 /// Enum class for the possible kind of use of [ClassEntity] objects.
 enum ClassUse { INSTANTIATED, IMPLEMENTED }
 
 /// Common [EnumSet]s used for [ClassUse].
 class ClassUses {
   static const EnumSet<ClassUse> NONE = const EnumSet<ClassUse>.fixed(0);
   static const EnumSet<ClassUse> INSTANTIATED_ONLY =
       const EnumSet<ClassUse>.fixed(1);
   static const EnumSet<ClassUse> IMPLEMENTED_ONLY =
       const EnumSet<ClassUse>.fixed(2);
   static const EnumSet<ClassUse> ALL = const EnumSet<ClassUse>.fixed(3);
 }
 
 typedef void ClassUsedCallback(ClassEntity cls, EnumSet<ClassUse> useSet);
 
 // TODO(johnniwinther): Merge this with [_MemberUsage].
-abstract class _StaticMemberUsage extends _AbstractUsage<MemberUse> {
+abstract class _StaticMemberUsage extends AbstractUsage<MemberUse> {
   final Entity entity;
 
   bool hasNormalUse = false;
   bool get hasClosurization => false;
 
   _StaticMemberUsage.internal(this.entity);
 
   EnumSet<MemberUse> normalUse() {
     if (hasNormalUse) {
       return MemberUses.NONE;
     }
     hasNormalUse = true;
     return _pendingUse.removeAll(MemberUses.NORMAL_ONLY);
   }
 
   EnumSet<MemberUse> tearOff();
 
   @override
   EnumSet<MemberUse> get _originalUse => MemberUses.NORMAL_ONLY;
 
-  String toString() => entity.toString();
+  String toString() => '$entity:${appliedUse.iterable(MemberUse.values)}';
 }
 
 class _GeneralStaticMemberUsage extends _StaticMemberUsage {
   _GeneralStaticMemberUsage(Entity entity) : super.internal(entity);
 
   EnumSet<MemberUse> tearOff() => normalUse();
 }
 
 class _StaticFunctionUsage extends _StaticMemberUsage {
   bool hasClosurization = false;
 
   _StaticFunctionUsage(Entity entity) : super.internal(entity);
 
   EnumSet<MemberUse> tearOff() {
     if (hasClosurization) {
       return MemberUses.NONE;
     }
     hasNormalUse = hasClosurization = true;
     return _pendingUse.removeAll(MemberUses.ALL_STATIC);
   }
 
   @override
   EnumSet<MemberUse> get _originalUse => MemberUses.ALL_STATIC;
 }