Move handling of regular static use from ResolutionEnqueuer to ResolutionWorldBuilderImpl

pkg/compiler/lib/src/enqueue.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 dart2js.enqueue;
 
 import 'dart:collection' show Queue;
 
 import 'cache_strategy.dart';
 import 'common/backend_api.dart' show Backend;
@@ skipping 253 matching lines @@
       applyImpact(backend.registerImplementedClass(cls, forResolution: true));
     }
   }
 
   void processDynamicUse(DynamicUse dynamicUse) {
     task.measure(() {
       _universe.registerDynamicUse(dynamicUse, _applyMemberUse);
     });
   }
 
+  /// Callback for applying the use of a [member].
+  void _applyStaticMemberUse(Entity member, EnumSet<MemberUse> useSet) {
+    if (useSet.contains(MemberUse.NORMAL)) {
+      _addToWorkList(member);
+    }
+    if (useSet.contains(MemberUse.CLOSURIZE)) {
+      applyImpact(backend.registerGetOfStaticFunction());
+    }
+  }
+
   void processStaticUse(StaticUse staticUse) {
-    Element element = staticUse.element;
-    assert(invariant(element, element.isDeclaration,
-        message: "Element ${element} is not the declaration."));
-    _universe.registerStaticUse(staticUse);
-    bool addElement = true;
+    _universe.registerStaticUse(staticUse, _applyStaticMemberUse);
+    // TODO(johnniwinther): Add `ResolutionWorldBuilder.registerConstructorUse`
+    // for these:
     switch (staticUse.kind) {
-      case StaticUseKind.STATIC_TEAR_OFF:
-        applyImpact(backend.registerGetOfStaticFunction());
-        break;
-      case StaticUseKind.FIELD_GET:
-      case StaticUseKind.FIELD_SET:
-      case StaticUseKind.CLOSURE:
-        // 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.
-        LocalFunctionElement closure = staticUse.element;
-        if (closure.type.containsTypeVariables) {
-          _universe.closuresWithFreeTypeVariables.add(closure);
-        }
-        addElement = false;
-        break;
-      case StaticUseKind.SUPER_FIELD_SET:
-      case StaticUseKind.SUPER_TEAR_OFF:
-      case StaticUseKind.GENERAL:
-      case StaticUseKind.DIRECT_USE:
-        break;
       case StaticUseKind.CONSTRUCTOR_INVOKE:
       case StaticUseKind.CONST_CONSTRUCTOR_INVOKE:
         _registerInstantiatedType(staticUse.type,
             constructor: staticUse.element, globalDependency: false);
         break;
       case StaticUseKind.REDIRECTION:
         _registerInstantiatedType(staticUse.type,
             constructor: staticUse.element,
             globalDependency: false,
             isRedirection: true);
         break;
-      case StaticUseKind.DIRECT_INVOKE:
-        invariant(
-            element, 'Direct static use is not supported for resolution.');
+      default:
         break;
     }
-    if (addElement) {
-      _addToWorkList(element);
-    }
   }
 
   void processTypeUse(TypeUse typeUse) {
     DartType type = typeUse.type;
     switch (typeUse.kind) {
       case TypeUseKind.INSTANTIATION:
         _registerInstantiatedType(type, globalDependency: false);
         break;
       case TypeUseKind.MIRROR_INSTANTIATION:
         _registerInstantiatedType(type,
@@ skipping 43 matching lines @@
     _universe.closurizedMembers.add(element);
   }
 
   void forEach(void f(WorkItem work)) {
     do {
       while (_queue.isNotEmpty) {
         // TODO(johnniwinther): Find an optimal process order.
         WorkItem work = _queue.removeLast();
         if (!_processedElements.contains(work.element)) {
           strategy.processWorkItem(f, work);
-          registerProcessedElement(work.element);
+          _processedElements.add(work.element);
         }
       }
       List recents = _recentClasses.toList(growable: false);
       _recentClasses.clear();
       if (!_onQueueEmpty(recents)) {
         _recentClasses.addAll(recents);
       }
     } while (_queue.isNotEmpty || _recentClasses.isNotEmpty);
   }
 
   void logSummary(log(message)) {
     log('Resolved ${_processedElements.length} elements.');
     nativeEnqueuer.logSummary(log);
   }
 
   String toString() => 'Enqueuer($name)';
 
   Iterable<Entity> get processedEntities => _processedElements;
 
   ImpactUseCase get impactUse => IMPACT_USE;
 
   bool get isResolutionQueue => true;
 
   /// Returns `true` if [element] has been processed by the resolution enqueuer.
+  // TODO(johnniwinther): Move this to the [OpenWorld]/[ResolutionWorldBuilder].
   bool hasBeenProcessed(Element element) {
-    return _processedElements.contains(element.analyzableElement.declaration);
+    assert(invariant(element, element == element.analyzableElement.declaration,
+        message: "Unexpected element $element"));
+    return _processedElements.contains(element);
   }
 
-  /// Registers [element] as processed by the resolution enqueuer.
-  void registerProcessedElement(AstElement element) {
+  /// Registers [element] as processed by the resolution enqueuer. Used only for
+  /// testing.
+  void registerProcessedElementInternal(AstElement element) {
     _processedElements.add(element);
   }
 
   /// Adds [element] to the work list if it has not already been processed.
   ///
   /// Invariant: [element] must be a declaration element.
   void _addToWorkList(Element element) {
     assert(invariant(element, element.isDeclaration));
     if (element.isMalformed) return;
 
@@ skipping 183 matching lines @@
 }
 
 typedef void _DeferredActionFunction();
 
 class _DeferredAction {
   final Element element;
   final _DeferredActionFunction action;
 
   _DeferredAction(this.element, this.action);
 }