Merge _applyMemberUse and _applyStaticMemberUse in ResolutionEnqueuer

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 473 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, ClassUsed classUsed,
+  void registerTypeInstantiation(
+      InterfaceType type, ClassUsedCallback classUsed,
       {ConstructorElement constructor,
       bool byMirrors: false,
       bool isRedirection: false}) {
     ClassElement cls = type.element;
     cls.ensureResolved(_resolution);
     InstantiationInfo info =
         _instantiationInfo.putIfAbsent(cls, () => new InstantiationInfo());
     Instantiation kind = Instantiation.UNINSTANTIATED;
     bool isNative = _backend.isNative(cls);
     if (!cls.isAbstract ||
@@ skipping 274 matching lines @@
   _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) {
+  void _processInstantiatedClass(
+      ClassElement cls, ClassUsedCallback 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;
@@ skipping 76 matching lines @@
         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>())
             .add(usage);
       }
-      if (usage.pendingUse.contains(MemberUse.CLOSURIZE)) {
+      if (usage.pendingUse.contains(MemberUse.CLOSURIZE_INSTANCE)) {
         // Store the member in [instanceFunctionsByName] to catch
         // getters on the function.
         _instanceFunctionsByName
             .putIfAbsent(memberName, () => new Set<_MemberUsage>())
             .add(usage);
       }
 
       memberUsed(usage.entity, useSet);
       return usage;
     });
@@ skipping 434 matching lines @@
   @override
   EnumSet<MemberUse> fullyUse() => read();
 }
 
 class _FunctionUsage extends _MemberUsage {
   bool hasInvoke = false;
   bool hasRead = false;
 
   _FunctionUsage(FunctionEntity function) : super.internal(function);
 
-  EnumSet<MemberUse> get _originalUse => MemberUses.ALL;
+  EnumSet<MemberUse> get _originalUse => MemberUses.ALL_INSTANCE;
 
   @override
   EnumSet<MemberUse> read() => fullyUse();
 
   @override
   EnumSet<MemberUse> invoke() {
     if (hasInvoke) {
       return MemberUses.NONE;
     }
     hasInvoke = true;
     return _pendingUse
         .removeAll(hasRead ? MemberUses.NONE : MemberUses.NORMAL_ONLY);
   }
 
   @override
   EnumSet<MemberUse> fullyUse() {
     if (hasInvoke) {
       if (hasRead) {
         return MemberUses.NONE;
       }
       hasRead = true;
-      return _pendingUse.removeAll(MemberUses.CLOSURIZE_ONLY);
+      return _pendingUse.removeAll(MemberUses.CLOSURIZE_INSTANCE_ONLY);
     } else if (hasRead) {
       hasInvoke = true;
       return _pendingUse.removeAll(MemberUses.NORMAL_ONLY);
     } else {
       hasRead = hasInvoke = true;
-      return _pendingUse.removeAll(MemberUses.ALL);
+      return _pendingUse.removeAll(MemberUses.ALL_INSTANCE);
     }
   }
 
   @override
   bool get fullyUsed => hasInvoke && hasRead;
 }
 
 class _GetterUsage extends _MemberUsage {
   bool hasRead = false;
 
@@ skipping 33 matching lines @@
     }
     hasWrite = true;
     return MemberUses.NORMAL_ONLY;
   }
 
   @override
   EnumSet<MemberUse> fullyUse() => write();
 }
 
 /// Enum class for the possible kind of use of [MemberEntity] objects.
-enum MemberUse { NORMAL, CLOSURIZE }
+enum MemberUse { NORMAL, CLOSURIZE_INSTANCE, CLOSURIZE_STATIC }
 
 /// Common [EnumSet]s used for [MemberUse].
 class MemberUses {
   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 =
+  static const EnumSet<MemberUse> CLOSURIZE_INSTANCE_ONLY =
       const EnumSet<MemberUse>.fixed(2);
-  static const EnumSet<MemberUse> ALL = const EnumSet<MemberUse>.fixed(3);
+  static const EnumSet<MemberUse> CLOSURIZE_STATIC_ONLY =
+      const EnumSet<MemberUse>.fixed(4);
+  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> {
   bool isInstantiated = false;
   bool isImplemented = false;
 
@@ skipping 29 matching lines @@
 /// 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);
+typedef void ClassUsedCallback(ClassEntity cls, EnumSet<ClassUse> useSet);
 
 // TODO(johnniwinther): Merge this with [_MemberUsage].
 abstract class _StaticMemberUsage extends _AbstractUsage<MemberUse> {
   final Entity entity;
 
   bool hasNormalUse = false;
   bool get hasClosurization => false;
 
   _StaticMemberUsage.internal(this.entity);
 
@@ skipping 22 matching lines @@
 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);
+    return _pendingUse.removeAll(MemberUses.ALL_STATIC);
   }
 
   @override
-  EnumSet<MemberUse> get _originalUse => MemberUses.ALL;
+  EnumSet<MemberUse> get _originalUse => MemberUses.ALL_STATIC;
 }