Split backend implementation of EnqueuerListener

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 'common/resolution.dart' show Resolution;
 import 'common/tasks.dart' show CompilerTask;
@@ skipping 31 matching lines @@
   EnqueueTask(Compiler compiler)
       : this.compiler = compiler,
         super(compiler.measurer) {
     _resolution = new ResolutionEnqueuer(
         this,
         compiler.options,
         compiler.reporter,
         compiler.options.analyzeOnly && compiler.options.analyzeMain
             ? const DirectEnqueuerStrategy()
             : const TreeShakingEnqueuerStrategy(),
-        compiler.backend,
+        compiler.backend.resolutionEnqueuerListener,
         compiler.backend.nativeResolutionEnqueuer(),
         new ResolutionWorldBuilderImpl(
             compiler.backend, compiler.resolution, const OpenWorldStrategy()),
         new ResolutionWorkItemBuilder(compiler.resolution));
     _codegen = compiler.backend.createCodegenEnqueuer(this, compiler);
   }
 
   ResolutionEnqueuer get resolution => _resolution;
   Enqueuer get codegen => _codegen;
 }
@@ skipping 39 matching lines @@
 
   Iterable<ClassEntity> get processedClasses;
 }
 
 abstract class EnqueuerListener {
   /// Called to instruct to the backend that [type] has been instantiated.
   void registerInstantiatedType(InterfaceType type, {bool isGlobal});
 
   /// Called to notify to the backend that a class is being instantiated. Any
   /// backend specific [WorldImpact] of this is returned.
-  WorldImpact registerInstantiatedClass(ClassEntity cls, {bool forResolution});
+  WorldImpact registerInstantiatedClass(ClassEntity cls);
 
   /// Called to notify to the backend that a class is implemented by an
   /// instantiated class. Any backend specific [WorldImpact] of this is
   /// returned.
-  WorldImpact registerImplementedClass(ClassEntity cls, {bool forResolution});
+  WorldImpact registerImplementedClass(ClassEntity cls);
 
   /// Called to register that a static function has been closurized. Any backend
   /// specific [WorldImpact] of this is returned.
   WorldImpact registerGetOfStaticFunction();
 
   /// Called to instruct the backend to register that a closure exists for a
   /// function on an instantiated generic class. Any backend specific
   /// [WorldImpact] of this is returned.
-  WorldImpact registerClosureWithFreeTypeVariables(MemberEntity member,
-      {bool forResolution});
+  WorldImpact registerClosureWithFreeTypeVariables(MemberEntity member);
 
   /// Called to register that a member has been closurized. Any backend specific
   /// [WorldImpact] of this is returned.
   WorldImpact registerBoundClosure();
 
   /// Called to register that [element] is statically known to be used. Any
   /// backend specific [WorldImpact] of this is returned.
-  WorldImpact registerUsedElement(MemberEntity member, {bool forResolution});
+  WorldImpact registerUsedElement(MemberEntity member);
 
   /// Called when [enqueuer]'s queue is empty, but before it is closed.
   ///
   /// This is used, for example, by the JS backend to enqueue additional
   /// elements needed for reflection. [recentClasses] is a collection of
   /// all classes seen for the first time by the [enqueuer] since the last call
   /// to [onQueueEmpty].
   ///
   /// A return value of `true` indicates that [recentClasses] has been
   /// processed and its elements do not need to be seen in the next round. When
@@ skipping 118 matching lines @@
   }
 
   /// Callback for applying the use of a [cls].
   void _applyClassUse(ClassEntity cls, EnumSet<ClassUse> useSet) {
     if (useSet.contains(ClassUse.INSTANTIATED)) {
       _recentClasses.add(cls);
       _universe.processClassMembers(cls, _applyMemberUse);
       // We only tell the backend once that [cls] was instantiated, so
       // any additional dependencies must be treated as global
       // dependencies.
-      applyImpact(
-          _listener.registerInstantiatedClass(cls, forResolution: true));
+      applyImpact(_listener.registerInstantiatedClass(cls));
     }
     if (useSet.contains(ClassUse.IMPLEMENTED)) {
-      applyImpact(_listener.registerImplementedClass(cls, forResolution: true));
+      applyImpact(_listener.registerImplementedClass(cls));
     }
   }
 
   void processDynamicUse(DynamicUse dynamicUse) {
     task.measure(() {
       _universe.registerDynamicUse(dynamicUse, _applyMemberUse);
     });
   }
 
   void processStaticUse(StaticUse staticUse) {
@@ skipping 53 matching lines @@
     type = _universe.registerIsCheck(type);
     // 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.
     assert(!type.isTypeVariable || !type.element.enclosingElement.isTypedef);
   }
 
   void _registerClosurizedMember(MemberElement element) {
     assert(element.isInstanceMember);
     if (element.type.containsTypeVariables) {
-      applyImpact(_listener.registerClosureWithFreeTypeVariables(element,
-          forResolution: true));
+      applyImpact(_listener.registerClosureWithFreeTypeVariables(element));
       _universe.closuresWithFreeTypeVariables.add(element);
     }
     applyImpact(_listener.registerBoundClosure());
     _universe.closurizedMembers.add(element);
   }
 
   void forEach(void f(WorkItem work)) {
     do {
       while (_queue.isNotEmpty) {
         // TODO(johnniwinther): Find an optimal process order.
@@ skipping 43 matching lines @@
   void _addToWorkList(MemberEntity entity) {
     if (hasBeenProcessed(entity)) return;
     WorkItem workItem = _workItemBuilder.createWorkItem(entity);
     if (workItem == null) return;
 
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(
           entity, "Resolution work list is closed. Trying to add $entity.");
     }
 
-    applyImpact(_listener.registerUsedElement(entity, forResolution: true));
+    applyImpact(_listener.registerUsedElement(entity));
     _universe.registerUsedElement(entity);
     _queue.add(workItem);
   }
 
   /// Adds an action to the deferred task queue.
   /// The action is performed the next time the resolution queue has been
   /// emptied.
   ///
   /// The queue is processed in FIFO order.
   void addDeferredAction(Entity entity, void action()) {
@@ skipping 141 matching lines @@
   @override
   WorkItem createWorkItem(MemberElement element) {
     assert(invariant(element, element.isDeclaration));
     if (element.isMalformed) return null;
 
     assert(invariant(element, element is AnalyzableElement,
         message: 'Element $element is not analyzable.'));
     return _resolution.createWorkItem(element);
   }
 }