Remove EnqueuerImpl.processInstantiatedClassMembers

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 104 matching lines @@
   bool isProcessed(Element member);
 
   Iterable<Entity> get processedEntities;
 
   Iterable<ClassElement> get processedClasses;
 }
 
 abstract class EnqueuerImpl extends Enqueuer {
   CompilerTask get task;
   EnqueuerStrategy get strategy;
-  void processInstantiatedClassMembers(ClassElement cls);
   void processInstantiatedClassMember(ClassElement cls, Element member);
   void processStaticUse(StaticUse staticUse);
   void processTypeUse(TypeUse typeUse);
   void processDynamicUse(DynamicUse dynamicUse);
 }
 
 /// [Enqueuer] which is specific to resolution.
 class ResolutionEnqueuer extends EnqueuerImpl {
   static const ImpactUseCase IMPACT_USE =
       const ImpactUseCase('ResolutionEnqueuer');
@@ skipping 91 matching lines @@
       if (!cls.isAbstract || isNative || mirrorUsage) {
         _processInstantiatedClass(cls);
       }
     });
   }
 
   bool checkNoEnqueuedInvokedInstanceMethods() {
     return strategy.checkEnqueuerConsistency(this);
   }
 
-  void processInstantiatedClassMembers(ClassElement cls) {
-    strategy.processInstantiatedClass(this, cls);
-  }
-
   void processInstantiatedClassMember(ClassElement cls, Element member) {
     assert(invariant(member, member.isDeclaration));
     if (isProcessed(member)) return;
     if (!member.isInstanceMember) return;
     String memberName = member.name;
 
     if (member.isField) {
       // 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.
@@ skipping 419 matching lines @@
 void removeFromSet(Map<String, Set<Element>> map, Element element) {
   Set<Element> set = map[element.name];
   if (set == null) return;
   set.remove(element);
 }
 
 /// Strategy used by the enqueuer to populate the world.
 class EnqueuerStrategy {
   const EnqueuerStrategy();
 
-  /// Process a class instantiated in live code.
-  void processInstantiatedClass(EnqueuerImpl enqueuer, ClassElement cls) {}
-
   /// Process a static use of and element in live code.
   void processStaticUse(EnqueuerImpl enqueuer, StaticUse staticUse) {}
 
   /// Process a type use in live code.
   void processTypeUse(EnqueuerImpl enqueuer, TypeUse typeUse) {}
 
   /// Process a dynamic use for a call site in live code.
   void processDynamicUse(EnqueuerImpl enqueuer, DynamicUse dynamicUse) {}
 
   /// Check enqueuer consistency after the queue has been closed.
-  bool checkEnqueuerConsistency(EnqueuerImpl enqueuer) {
-    enqueuer.task.measure(() {
-      // Run through the classes and see if we need to enqueue more methods.
-      for (ClassElement classElement
-          in enqueuer.universe.directlyInstantiatedClasses) {
-        for (ClassElement currentClass = classElement;
-            currentClass != null;
-            currentClass = currentClass.superclass) {
-          enqueuer.processInstantiatedClassMembers(currentClass);
-        }
-      }
-    });
-    return true;
-  }
+  bool checkEnqueuerConsistency(EnqueuerImpl enqueuer) => true;
 
   /// Process [work] using [f].
   void processWorkItem(void f(WorkItem work), WorkItem work) {
     f(work);
   }
 }
 
 /// Strategy that only enqueues directly used elements.
 class DirectEnqueuerStrategy extends EnqueuerStrategy {
   const DirectEnqueuerStrategy();
   void processStaticUse(EnqueuerImpl enqueuer, StaticUse staticUse) {
     if (staticUse.kind == StaticUseKind.DIRECT_USE) {
       enqueuer.processStaticUse(staticUse);
     }
   }
 }
 
 /// Strategy used for tree-shaking.
 class TreeShakingEnqueuerStrategy extends EnqueuerStrategy {
   const TreeShakingEnqueuerStrategy();
 
   @override
-  void processInstantiatedClass(EnqueuerImpl enqueuer, ClassElement cls) {
-    cls.implementation.forEachMember(enqueuer.processInstantiatedClassMember);
-  }
-
-  @override
   void processStaticUse(EnqueuerImpl enqueuer, StaticUse staticUse) {
     enqueuer.processStaticUse(staticUse);
   }
 
   @override
   void processTypeUse(EnqueuerImpl enqueuer, TypeUse typeUse) {
     enqueuer.processTypeUse(typeUse);
   }
 
   @override
   void processDynamicUse(EnqueuerImpl enqueuer, DynamicUse dynamicUse) {
     enqueuer.processDynamicUse(dynamicUse);
   }
+
+  /// Check enqueuer consistency after the queue has been closed.
+  bool checkEnqueuerConsistency(EnqueuerImpl enqueuer) {
+    enqueuer.task.measure(() {
+      // Run through the classes and see if we need to enqueue more methods.
+      for (ClassElement classElement
+          in enqueuer.universe.directlyInstantiatedClasses) {
+        for (ClassElement currentClass = classElement;
+            currentClass != null;
+            currentClass = currentClass.superclass) {
+          currentClass.implementation
+              .forEachMember(enqueuer.processInstantiatedClassMember);
+        }
+      }
+    });
+    return true;
+  }
 }
 
 class EnqueuerImplImpactVisitor implements WorldImpactVisitor {
   final EnqueuerImpl enqueuer;
 
   EnqueuerImplImpactVisitor(this.enqueuer);
 
   @override
   void visitDynamicUse(DynamicUse dynamicUse) {
     enqueuer.strategy.processDynamicUse(enqueuer, dynamicUse);
@@ skipping 11 matching lines @@
 }
 
 typedef void _DeferredActionFunction();
 
 class _DeferredAction {
   final Element element;
   final _DeferredActionFunction action;
 
   _DeferredAction(this.element, this.action);
 }