Move processing of instantiated classes from ResolutionEnqueuer to ResolutionWorldBuilderImpl

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

 // Copyright (c) 2012, 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 universe;
 
 import 'dart:collection';
 
 import '../cache_strategy.dart';
 import '../common.dart';
@@ skipping 354 matching lines @@
    */
   final Set<FunctionElement> methodsNeedingSuperGetter =
       new Set<FunctionElement>();
   final Map<String, Map<Selector, SelectorConstraints>> _invokedNames =
       <String, Map<Selector, SelectorConstraints>>{};
   final Map<String, Map<Selector, SelectorConstraints>> _invokedGetters =
       <String, Map<Selector, SelectorConstraints>>{};
   final Map<String, Map<Selector, SelectorConstraints>> _invokedSetters =
       <String, Map<Selector, SelectorConstraints>>{};
 
+  final Map<ClassElement, _ClassUsage> _processedClasses =
+      <ClassElement, _ClassUsage>{};
+
   /// Map of registers usage of instance members of live classes.
-  final Map<MemberEntity, MemberUsage> _instanceMemberUsage =
-      <MemberEntity, MemberUsage>{};
+  final Map<MemberEntity, _MemberUsage> _instanceMemberUsage =
+      <MemberEntity, _MemberUsage>{};
 
   /// Map containing instance members of live classes that are not yet live
   /// themselves.
-  final Map<String, Set<MemberUsage>> _instanceMembersByName =
-      <String, Set<MemberUsage>>{};
+  final Map<String, Set<_MemberUsage>> _instanceMembersByName =
+      <String, Set<_MemberUsage>>{};
 
   /// Map containing instance methods of live classes that are not yet
   /// closurized.
-  final Map<String, Set<MemberUsage>> _instanceFunctionsByName =
-      <String, Set<MemberUsage>>{};
+  final Map<String, Set<_MemberUsage>> _instanceFunctionsByName =
+      <String, Set<_MemberUsage>>{};
 
   /// Fields set.
   final Set<Element> fieldSetters = new Set<Element>();
   final Set<DartType> isChecks = new Set<DartType>();
 
   /**
    * Set of (live) [:call:] methods whose signatures reference type variables.
    *
    * A live [:call:] method is one whose enclosing class has been instantiated.
    */
@@ skipping 35 matching lines @@
   final Resolution _resolution;
 
   ResolutionWorldBuilderImpl(Backend backend, Resolution resolution,
       CacheStrategy cacheStrategy, this.selectorConstraintsStrategy)
       : this._backend = backend,
         this._resolution = resolution {
     _openWorld =
         new WorldImpl(this, backend, resolution.coreClasses, cacheStrategy);
   }
 
+  Iterable<ClassElement> get processedClasses => _processedClasses.keys
+      .where((cls) => _processedClasses[cls].isInstantiated);
+
   OpenWorld get openWorld => _openWorld;
 
   /// All directly instantiated classes, that is, classes with a generative
   /// constructor that has been called directly and not only through a
   /// super-call.
   // TODO(johnniwinther): Improve semantic precision.
   Iterable<ClassElement> get directlyInstantiatedClasses {
     Set<ClassElement> classes = new Set<ClassElement>();
     getInstantiationMap().forEach((ClassElement cls, InstantiationInfo info) {
       if (info.hasInstantiation) {
@@ skipping 30 matching lines @@
   bool isImplemented(ClassElement cls) {
     return _implementedClasses.contains(cls.declaration);
   }
 
   /// Register [type] as (directly) instantiated.
   ///
   /// If [byMirrors] is `true`, the instantiation is through mirrors.
   // TODO(johnniwinther): Fully enforce the separation between exact, through
   // subclass and through subtype instantiated types/classes.
   // TODO(johnniwinther): Support unknown type arguments for generic types.
-  void registerTypeInstantiation(InterfaceType type,
+  void registerTypeInstantiation(InterfaceType type, ClassUsed classUsed,
       {ConstructorElement constructor,
       bool byMirrors: false,
-      bool isNative: false,
-      bool isRedirection: false,
-      void onImplemented(ClassElement cls)}) {
+      bool isRedirection: false}) {
     ClassElement cls = type.element;
+    cls.ensureResolved(_resolution);
     InstantiationInfo info =
         _instantiationInfo.putIfAbsent(cls, () => new InstantiationInfo());
     Instantiation kind = Instantiation.UNINSTANTIATED;
-    if (!cls.isAbstract
+    bool isNative = _backend.isNative(cls);
+    if (!cls.isAbstract ||
         // We can't use the closed-world assumption with native abstract
         // classes; a native abstract class may have non-abstract subclasses
         // not declared to the program.  Instances of these classes are
         // indistinguishable from the abstract class.
-        ||
-        isNative
+        isNative ||
         // Likewise, if this registration comes from the mirror system,
         // all bets are off.
         // TODO(herhut): Track classes required by mirrors seperately.
-        ||
         byMirrors) {
       if (isNative || byMirrors) {
         kind = Instantiation.ABSTRACTLY_INSTANTIATED;
       } else {
         kind = Instantiation.DIRECTLY_INSTANTIATED;
       }
+      _processInstantiatedClass(cls, classUsed);
     }
     info.addInstantiation(constructor, type, kind,
         isRedirection: isRedirection);
 
     // TODO(johnniwinther): Use [_instantiationInfo] to compute this information
     // instead.
     if (_implementedClasses.add(cls)) {
+      void onImplemented(ClassElement cls) {
+        _ClassUsage usage = _getClassUsage(cls);
+        classUsed(usage.cls, usage.implement());
+      }
+
       onImplemented(cls);
       cls.allSupertypes.forEach((InterfaceType supertype) {
         if (_implementedClasses.add(supertype.element)) {
           onImplemented(supertype.element);
         }
       });
     }
   }
 
   @override
@@ skipping 71 matching lines @@
   bool hasInvokedSetter(Element member) {
     return _hasMatchingSelector(_invokedSetters[member.name], member);
   }
 
   void registerDynamicUse(DynamicUse dynamicUse, MemberUsed memberUsed) {
     Selector selector = dynamicUse.selector;
     String methodName = selector.name;
     switch (dynamicUse.kind) {
       case DynamicUseKind.INVOKE:
         if (_registerNewSelector(dynamicUse, _invokedNames)) {
-          _processInstanceMembers(methodName, (MemberUsage usage) {
-            if (dynamicUse.appliesUnnamed(usage.member, _openWorld)) {
-              memberUsed(usage.member, usage.invoke());
+          _processInstanceMembers(methodName, (_MemberUsage usage) {
+            if (dynamicUse.appliesUnnamed(usage.entity, _openWorld)) {
+              memberUsed(usage.entity, usage.invoke());
               return true;
             }
             return false;
           });
         }
         break;
       case DynamicUseKind.GET:
         if (_registerNewSelector(dynamicUse, _invokedGetters)) {
-          _processInstanceMembers(methodName, (MemberUsage usage) {
-            if (dynamicUse.appliesUnnamed(usage.member, _openWorld)) {
-              memberUsed(usage.member, usage.read());
+          _processInstanceMembers(methodName, (_MemberUsage usage) {
+            if (dynamicUse.appliesUnnamed(usage.entity, _openWorld)) {
+              memberUsed(usage.entity, usage.read());
               return true;
             }
             return false;
           });
-          _processInstanceFunctions(methodName, (MemberUsage usage) {
-            if (dynamicUse.appliesUnnamed(usage.member, _openWorld)) {
-              memberUsed(usage.member, usage.read());
+          _processInstanceFunctions(methodName, (_MemberUsage usage) {
+            if (dynamicUse.appliesUnnamed(usage.entity, _openWorld)) {
+              memberUsed(usage.entity, usage.read());
               return true;
             }
             return false;
           });
         }
         break;
       case DynamicUseKind.SET:
         if (_registerNewSelector(dynamicUse, _invokedSetters)) {
-          _processInstanceMembers(methodName, (MemberUsage usage) {
-            if (dynamicUse.appliesUnnamed(usage.member, _openWorld)) {
-              memberUsed(usage.member, usage.write());
+          _processInstanceMembers(methodName, (_MemberUsage usage) {
+            if (dynamicUse.appliesUnnamed(usage.entity, _openWorld)) {
+              memberUsed(usage.entity, usage.write());
               return true;
             }
             return false;
           });
         }
         break;
     }
   }
 
   bool _registerNewSelector(DynamicUse dynamicUse,
@@ skipping 51 matching lines @@
     }
   }
 
   void forgetElement(Element element, Compiler compiler) {
     allClosures.remove(element);
     slowDirectlyNestedClosures(element).forEach(compiler.forgetElement);
     closurizedMembers.remove(element);
     fieldSetters.remove(element);
     _instantiationInfo.remove(element);
 
-    void removeUsage(Set<MemberUsage> set, Element element) {
+    void removeUsage(Set<_MemberUsage> set, Element element) {
       if (set == null) return;
       set.removeAll(
-          set.where((MemberUsage usage) => usage.member == element).toList());
+          set.where((_MemberUsage usage) => usage.entity == element).toList());
     }
 
+    _processedClasses.remove(element);
     removeUsage(_instanceMembersByName[element.name], element);
     removeUsage(_instanceFunctionsByName[element.name], element);
   }
 
   // TODO(ahe): Replace this method with something that is O(1), for example,
   // by using a map.
   List<LocalFunctionElement> slowDirectlyNestedClosures(Element element) {
     // Return new list to guard against concurrent modifications.
     return new List<LocalFunctionElement>.from(
         allClosures.where((LocalFunctionElement closure) {
       return closure.executableContext == element;
     }));
   }
 
-  void _processSet(Map<String, Set<MemberUsage>> map, String memberName,
-      bool f(MemberUsage e)) {
-    Set<MemberUsage> members = map[memberName];
+  /// Return the canonical [_ClassUsage] for [cls].
+  _ClassUsage _getClassUsage(ClassElement cls) {
+    return _processedClasses.putIfAbsent(cls, () {
+      cls.ensureResolved(_resolution);
+      _ClassUsage usage = new _ClassUsage(cls);
+      _resolution.ensureClassMembers(cls);
+      return usage;
+    });
+  }
+
+  /// Register [cls] and all its superclasses as instantiated.
+  void _processInstantiatedClass(ClassElement cls, ClassUsed classUsed) {
+    // Registers [superclass] as instantiated. Returns `true` if it wasn't
+    // already instantiated and we therefore have to process its superclass as
+    // well.
+    bool processClass(ClassElement superclass) {
+      _ClassUsage usage = _getClassUsage(superclass);
+      if (!usage.isInstantiated) {
+        classUsed(usage.cls, usage.instantiate());
+        return true;
+      }
+      return false;
+    }
+
+    while (cls != null && processClass(cls)) {
+      cls = cls.superclass;
+    }
+  }
+
+  /// Computes usage for all members declared by [cls]. Calls [membersUsed] with
+  /// the usage changes for each member.
+  void processClassMembers(ClassElement cls, MemberUsed memberUsed) {
+    cls.implementation.forEachMember((ClassElement cls, MemberElement member) {
+      _processInstantiatedClassMember(cls, member, memberUsed);
+    });
+  }
+
+  void _processSet(Map<String, Set<_MemberUsage>> map, String memberName,
+      bool f(_MemberUsage e)) {
+    Set<_MemberUsage> members = map[memberName];
     if (members == null) return;
     // [f] might add elements to [: map[memberName] :] during the loop below
     // so we create a new list for [: map[memberName] :] and prepend the
     // [remaining] members after the loop.
-    map[memberName] = new Set<MemberUsage>();
-    Set<MemberUsage> remaining = new Set<MemberUsage>();
-    for (MemberUsage usage in members) {
+    map[memberName] = new Set<_MemberUsage>();
+    Set<_MemberUsage> remaining = new Set<_MemberUsage>();
+    for (_MemberUsage usage in members) {
       if (!f(usage)) remaining.add(usage);
     }
     map[memberName].addAll(remaining);
   }
 
-  void _processInstanceMembers(String n, bool f(MemberUsage e)) {
-    _processSet(_instanceMembersByName, n, f);
+  void _processInstanceMembers(String name, bool f(_MemberUsage e)) {
+    _processSet(_instanceMembersByName, name, f);
   }
 
-  void _processInstanceFunctions(String n, bool f(MemberUsage e)) {
+  void _processInstanceFunctions(String n, bool f(_MemberUsage e)) {
     _processSet(_instanceFunctionsByName, n, f);
   }
 
-  // TODO(johnniwinther): Make this private when
-  // [ResolutionEnqueuer._processClass] is move to [ResolutionWorldBuilderImpl].
-  void processInstantiatedClassMember(
+  void _processInstantiatedClassMember(
       ClassElement cls, MemberElement member, MemberUsed memberUsed) {
     assert(invariant(member, member.isDeclaration));
     if (!member.isInstanceMember) return;
     String memberName = member.name;
     member.computeType(_resolution);
     EnumSet<MemberUse> useSet = new EnumSet<MemberUse>();
     // The obvious thing to test here would be "member.isNative",
     // however, that only works after metadata has been parsed/analyzed,
     // and that may not have happened yet.
     // So instead we use the enclosing class, which we know have had
     // its metadata parsed and analyzed.
     // Note: this assumes that there are no non-native fields on native
     // classes, which may not be the case when a native class is subclassed.
     bool isNative = _backend.isNative(cls);
-    MemberUsage usage = _instanceMemberUsage.putIfAbsent(member, () {
-      MemberUsage usage = new MemberUsage(member, isNative: isNative);
+    _MemberUsage usage = _instanceMemberUsage.putIfAbsent(member, () {
+      _MemberUsage usage = new _MemberUsage(member, isNative: isNative);
       useSet.addAll(usage.appliedUse);
       if (member.isField && isNative) {
         _openWorld.registerUsedElement(member);
       }
 
       if (_hasInvokedGetter(member)) {
         useSet.addAll(usage.read());
       }
       if (_hasInvocation(member)) {
         useSet.addAll(usage.invoke());
       }
       if (hasInvokedSetter(member)) {
         useSet.addAll(usage.write());
       }
 
       if (usage.pendingUse.contains(MemberUse.NORMAL)) {
         // The element is not yet used. Add it to the list of instance
         // members to still be processed.
         _instanceMembersByName
-            .putIfAbsent(memberName, () => new Set<MemberUsage>())
+            .putIfAbsent(memberName, () => new Set<_MemberUsage>())
             .add(usage);
       }
       if (usage.pendingUse.contains(MemberUse.CLOSURIZE)) {
         // Store the member in [instanceFunctionsByName] to catch
         // getters on the function.
         _instanceFunctionsByName
-            .putIfAbsent(memberName, () => new Set<MemberUsage>())
+            .putIfAbsent(memberName, () => new Set<_MemberUsage>())
             .add(usage);
       }
 
-      memberUsed(usage.member, useSet);
+      memberUsed(usage.entity, useSet);
       return usage;
     });
   }
 }
 
 /// World builder specific to codegen.
 ///
 /// This adds additional access to liveness of selectors and elements.
 abstract class CodegenWorldBuilder implements WorldBuilder {
   void forEachInvokedName(
@@ skipping 249 matching lines @@
   void forgetElement(Element element, Compiler compiler) {
     _directlyInstantiatedClasses.remove(element);
     if (element is ClassElement) {
       assert(invariant(element, element.thisType.isRaw,
           message: 'Generic classes not supported (${element.thisType}).'));
       _instantiatedTypes..remove(element.rawType)..remove(element.thisType);
     }
   }
 }
 
-/// Registry for the observed use of [member] in the open world.
-abstract class MemberUsage {
-  // TODO(johnniwinther): Change [Entity] to [MemberEntity].
-  final Entity member;
-  final EnumSet<MemberUse> _pendingUse = new EnumSet<MemberUse>();
+abstract class _AbstractUsage<T> {
+  final EnumSet<T> _pendingUse = new EnumSet<T>();
 
-  MemberUsage.internal(this.member) {
+  _AbstractUsage() {
     _pendingUse.addAll(_originalUse);
   }
 
-  factory MemberUsage(MemberEntity member, {bool isNative: false}) {
+  /// 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;
+}
+
+/// Registry for the observed use of a member [entity] in the open world.
+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 {
         return new _FinalFieldUsage(member, isNative: isNative);
       }
     } else if (member.isGetter) {
       return new _GetterUsage(member);
     } else if (member.isSetter) {
       return new _SetterUsage(member);
     } else {
       assert(member.isFunction);
       return new _FunctionUsage(member);
     }
   }
 
-  /// `true` if [member] has be read as a value. For a field this is a normal
+  /// `true` if [entity] has be read as a value. For a field this is a normal
   /// read access, for a function this is a closurization.
   bool get hasRead => false;
 
-  /// `true` if a value as been written to [member].
+  /// `true` if a value as been written to [entity].
   bool get hasWrite => false;
 
-  /// `true` if an invocation has been performed on the value [member]. For a
+  /// `true` if an invocation has been performed on the value [entity]. For a
   /// function this is a normal invocation, for a field this is a read access
   /// followed by an invocation of the function-like value.
   bool get hasInvoke => false;
 
-  /// `true` if [member] has been used in all the ways possible.
+  /// `true` if [entity] has been used in all the ways possible.
   bool get fullyUsed;
 
-  /// Registers a read of the value of [member] and returns the new [MemberUse]s
+  /// Registers a read of the value of [entity] and returns the new [MemberUse]s
   /// that it caused.
   ///
   /// For a field this is a normal read access, for a function this is a
   /// closurization.
   EnumSet<MemberUse> read() => MemberUse.NONE;
 
-  /// Registers a write of a value to [member] and returns the new [MemberUse]s
+  /// Registers a write of a value to [entity] and returns the new [MemberUse]s
   /// that it caused.
   EnumSet<MemberUse> write() => MemberUse.NONE;
 
-  /// Registers an invocation on the value of [member] and returns the new
+  /// Registers an invocation on the value of [entity] and returns the new
   /// [MemberUse]s that it caused.
   ///
   /// For a function this is a normal invocation, for a field this is a read
   /// access followed by an invocation of the function-like value.
   EnumSet<MemberUse> invoke() => MemberUse.NONE;
 
-  /// Registers all possible uses of [member] and returns the new [MemberUse]s
+  /// Registers all possible uses of [entity] and returns the new [MemberUse]s
   /// that it caused.
   EnumSet<MemberUse> fullyUse() => MemberUse.NONE;
 
-  /// Returns the possible [MemberUse]s of [member] that have not yet been
-  /// registered.
-  EnumSet<MemberUse> get pendingUse => _pendingUse;
-
-  /// Returns the [MemberUse]s of [member] that have been registered.
-  EnumSet<MemberUse> get appliedUse => _originalUse.minus(_pendingUse);
-
-  EnumSet<MemberUse> get _originalUse;
-
-  int get hashCode => member.hashCode;
+  int get hashCode => entity.hashCode;
 
   bool operator ==(other) {
     if (identical(this, other)) return true;
-    if (other is! MemberUsage) return false;
-    return member == other.member;
+    if (other is! _MemberUsage) return false;
+    return entity == other.entity;
   }
 
-  String toString() => member.toString();
+  String toString() => entity.toString();
 }
 
-class _FieldUsage extends MemberUsage {
+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
       // have an observable side-effect (and cannot be tree-shaken
       // away).
       fullyUse();
@@ skipping 29 matching lines @@
   @override
   EnumSet<MemberUse> fullyUse() {
     if (fullyUsed) {
       return MemberUse.NONE;
     }
     hasRead = hasWrite = true;
     return _pendingUse.removeAll(MemberUse.NORMAL_ONLY);
   }
 }
 
-class _FinalFieldUsage extends MemberUsage {
+class _FinalFieldUsage extends _MemberUsage {
   bool hasRead = false;
 
   _FinalFieldUsage(FieldEntity field, {bool isNative: false})
       : super.internal(field) {
     if (!isNative) {
       // All field initializers must be resolved as they could
       // have an observable side-effect (and cannot be tree-shaken
       // away).
       read();
     }
@@ skipping 13 matching lines @@
     return _pendingUse.removeAll(MemberUse.NORMAL_ONLY);
   }
 
   @override
   EnumSet<MemberUse> invoke() => read();
 
   @override
   EnumSet<MemberUse> fullyUse() => read();
 }
 
-class _FunctionUsage extends MemberUsage {
+class _FunctionUsage extends _MemberUsage {
   bool hasInvoke = false;
   bool hasRead = false;
 
   _FunctionUsage(FunctionEntity function) : super.internal(function);
 
   EnumSet<MemberUse> get _originalUse => MemberUse.ALL;
 
   @override
   EnumSet<MemberUse> read() => fullyUse();
 
@@ skipping 21 matching lines @@
     } else {
       hasRead = hasInvoke = true;
       return _pendingUse.removeAll(MemberUse.ALL);
     }
   }
 
   @override
   bool get fullyUsed => hasInvoke && hasRead;
 }
 
-class _GetterUsage extends MemberUsage {
+class _GetterUsage extends _MemberUsage {
   bool hasRead = false;
 
   _GetterUsage(FunctionEntity getter) : super.internal(getter);
 
   EnumSet<MemberUse> get _originalUse => MemberUse.NORMAL_ONLY;
 
   @override
   bool get fullyUsed => hasRead;
 
   @override
   EnumSet<MemberUse> read() {
     if (hasRead) {
       return MemberUse.NONE;
     }
     hasRead = true;
     return _pendingUse.removeAll(MemberUse.NORMAL_ONLY);
   }
 
   @override
   EnumSet<MemberUse> invoke() => read();
 
   @override
   EnumSet<MemberUse> fullyUse() => read();
 }
 
-class _SetterUsage extends MemberUsage {
+class _SetterUsage extends _MemberUsage {
   bool hasWrite = false;
 
   _SetterUsage(FunctionEntity setter) : super.internal(setter);
 
   EnumSet<MemberUse> get _originalUse => MemberUse.NORMAL_ONLY;
 
   @override
   bool get fullyUsed => hasWrite;
 
   @override
   EnumSet<MemberUse> write() {
     if (hasWrite) {
       return MemberUse.NONE;
     }
     hasWrite = true;
     return MemberUse.NORMAL_ONLY;
   }
 
   @override
   EnumSet<MemberUse> fullyUse() => write();
 }
 
 /// Enum-like class for the possible kind of use of [MemberEntity] objects.
 class MemberUse {
   final int index;
 
   const MemberUse._(this.index);
 
+  String toString() => 'MemberUse($index)';
+
   static const List<MemberUse> values = const <MemberUse>[NORMAL, CLOSURIZE];
 
   static const MemberUse NORMAL = const MemberUse._(0);
   static const MemberUse CLOSURIZE = const MemberUse._(1);
 
   static const EnumSet<MemberUse> NONE = const EnumSet<MemberUse>.fixed(0);
   static const EnumSet<MemberUse> NORMAL_ONLY =
       const EnumSet<MemberUse>.fixed(1);
   static const EnumSet<MemberUse> CLOSURIZE_ONLY =
       const EnumSet<MemberUse>.fixed(2);
   static const EnumSet<MemberUse> ALL = const EnumSet<MemberUse>.fixed(3);
 }
 
 typedef void MemberUsed(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> {
+  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();
+}
+
+/// 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 ClassUsed(ClassEntity cls, EnumSet<ClassUse> useSet);