Move handling of regular static use 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 357 matching lines @@
   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.
+  /// Map of registered usage of static members of live classes.
+  final Map<Entity, _StaticMemberUsage> _staticMemberUsage =
+      <Entity, _StaticMemberUsage>{};
+
+  /// Map of registered usage of instance members of live classes.
   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>>{};
 
   /// Map containing instance methods of live classes that are not yet
   /// closurized.
@@ skipping 223 matching lines @@
 
   bool _hasInvokedGetter(Element member) {
     return _hasMatchingSelector(_invokedGetters[member.name], member) ||
         member.isFunction && methodsNeedingSuperGetter.contains(member);
   }
 
   bool hasInvokedSetter(Element member) {
     return _hasMatchingSelector(_invokedSetters[member.name], member);
   }
 
-  void registerDynamicUse(DynamicUse dynamicUse, MemberUsed memberUsed) {
+  void registerDynamicUse(
+      DynamicUse dynamicUse, MemberUsedCallback 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.entity, _openWorld)) {
               memberUsed(usage.entity, usage.invoke());
               return true;
             }
@@ skipping 50 matching lines @@
   DartType registerIsCheck(DartType type, Resolution resolution) {
     type.computeUnaliased(resolution);
     type = type.unaliased;
     // Even in checked mode, type annotations for return type and argument
     // types do not imply type checks, so there should never be a check
     // against the type variable of a typedef.
     isChecks.add(type);
     return type;
   }
 
-  void registerStaticUse(StaticUse staticUse) {
+  void registerStaticUse(StaticUse staticUse, MemberUsedCallback memberUsed) {
     Element element = staticUse.element;
+    assert(invariant(element, element.isDeclaration,
+        message: "Element ${element} is not the declaration."));
+    _StaticMemberUsage usage = _staticMemberUsage.putIfAbsent(element, () {
+      if ((element.isStatic || element.isTopLevel) && element.isFunction) {
+        return new _StaticFunctionUsage(element);
+      } else {
+        return new _GeneralStaticMemberUsage(element);
+      }
+    });
+    EnumSet<MemberUse> useSet = new EnumSet<MemberUse>();
+
     if (Elements.isStaticOrTopLevel(element) && element.isField) {
       allReferencedStaticFields.add(element);
     }
+    // TODO(johnniwinther): Avoid this. Currently [FIELD_GET] and
+    // [FIELD_SET] contains [BoxFieldElement]s which we cannot enqueue.
+    // Also [CLOSURE] contains [LocalFunctionElement] which we cannot
+    // enqueue.
     switch (staticUse.kind) {
-      case StaticUseKind.SUPER_FIELD_SET:
+      case StaticUseKind.FIELD_GET:
+        break;
       case StaticUseKind.FIELD_SET:
         fieldSetters.add(element);
         break;
+      case StaticUseKind.CLOSURE:
+        LocalFunctionElement closure = staticUse.element;
+        if (closure.type.containsTypeVariables) {
+          closuresWithFreeTypeVariables.add(closure);
+        }
+        allClosures.add(element);
+        break;
       case StaticUseKind.SUPER_TEAR_OFF:
+        useSet.addAll(usage.tearOff());
         methodsNeedingSuperGetter.add(element);
         break;
+      case StaticUseKind.SUPER_FIELD_SET:
+        fieldSetters.add(element);
+        useSet.addAll(usage.normalUse());
+        break;
+      case StaticUseKind.STATIC_TEAR_OFF:
+        useSet.addAll(usage.tearOff());
+        break;
       case StaticUseKind.GENERAL:
       case StaticUseKind.DIRECT_USE:
-      case StaticUseKind.STATIC_TEAR_OFF:
-      case StaticUseKind.FIELD_GET:
       case StaticUseKind.CONSTRUCTOR_INVOKE:
       case StaticUseKind.CONST_CONSTRUCTOR_INVOKE:
       case StaticUseKind.REDIRECTION:
-        break;
-      case StaticUseKind.CLOSURE:
-        allClosures.add(element);
+        useSet.addAll(usage.normalUse());
         break;
       case StaticUseKind.DIRECT_INVOKE:
         invariant(
             element, 'Direct static use is not supported for resolution.');
         break;
     }
+    if (useSet.isNotEmpty) {
+      memberUsed(usage.entity, useSet);
+    }
   }
 
   void forgetEntity(Entity entity, Compiler compiler) {
     allClosures.remove(entity);
     slowDirectlyNestedClosures(entity).forEach(compiler.forgetElement);
     closurizedMembers.remove(entity);
     fieldSetters.remove(entity);
     _instantiationInfo.remove(entity);
 
     void removeUsage(Set<_MemberUsage> set, Entity entity) {
@@ skipping 41 matching lines @@
       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) {
+  void processClassMembers(ClassElement cls, MemberUsedCallback memberUsed) {
     cls.implementation.forEachMember((ClassElement cls, MemberElement member) {
       _processInstantiatedClassMember(cls, member, memberUsed);
     });
   }
 
   /// Call [updateUsage] on all [MemberUsage]s in the set in [map] for
   /// [memberName]. If [updateUsage] returns `true` the usage is removed from
   /// the set.
   void _processSet(Map<String, Set<_MemberUsage>> map, String memberName,
       bool updateUsage(_MemberUsage e)) {
@@ skipping 13 matching lines @@
   void _processInstanceMembers(String name, bool updateUsage(_MemberUsage e)) {
     _processSet(_instanceMembersByName, name, updateUsage);
   }
 
   void _processInstanceFunctions(
       String name, bool updateUsage(_MemberUsage e)) {
     _processSet(_instanceFunctionsByName, name, updateUsage);
   }
 
   void _processInstantiatedClassMember(
-      ClassElement cls, MemberElement member, MemberUsed memberUsed) {
+      ClassElement cls, MemberElement member, MemberUsedCallback 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.
@@ skipping 566 matching lines @@
 /// 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 =
       const EnumSet<MemberUse>.fixed(2);
   static const EnumSet<MemberUse> ALL = const EnumSet<MemberUse>.fixed(3);
 }
 
-typedef void MemberUsed(MemberEntity member, EnumSet<MemberUse> useSet);
+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;
 
   final ClassEntity cls;
 
   _ClassUsage(this.cls);
@@ skipping 27 matching lines @@
 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);
+
+// 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);
+
+  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();
+}
+
+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);
+  }
+
+  @override
+  EnumSet<MemberUse> get _originalUse => MemberUses.ALL;
+}