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 294 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, MemberUsed memberUsed) {

[Harry Terkelsen, 2016/12/07 21:02:00]

Maybe rename this typedef to 'MemberUsedCallback' or something? It's not obvious
that it's a callback, it looks like it's a reference to the member which is
used. It's also very close to 'MemberUse'

[Johnni Winther, 2016/12/08 08:56:12]

Done.

     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 710 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;
+}