Split backend implementation of EnqueuerListener

pkg/compiler/lib/src/js_backend/enqueuer.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.js.enqueue;
 
 import 'dart:collection' show Queue;
 
 import '../common/codegen.dart' show CodegenWorkItem;
 import '../common/tasks.dart' show CompilerTask;
@@ skipping 21 matching lines @@
   final String name;
   final EnqueuerStrategy strategy;
 
   Set<ClassEntity> _recentClasses = new Setlet<ClassEntity>();
   final CodegenWorldBuilderImpl _universe;
   final WorkItemBuilder _workItemBuilder;
 
   bool queueIsClosed = false;
   final CompilerTask task;
   final native.NativeEnqueuer nativeEnqueuer;
-  final JavaScriptBackend _backend;
+  final EnqueuerListener _listener;
   final CompilerOptions _options;
 
   WorldImpactVisitor _impactVisitor;
 
   final Queue<WorkItem> _queue = new Queue<WorkItem>();
 
   /// All declaration elements that have been processed by codegen.
   final Set<Entity> _processedEntities = new Set<Entity>();
 
   static const ImpactUseCase IMPACT_USE =
       const ImpactUseCase('CodegenEnqueuer');
 
   CodegenEnqueuer(this.task, JavaScriptBackend backend, CompilerOptions options,
       this.strategy)
       : _universe =
             new CodegenWorldBuilderImpl(backend, const TypeMaskStrategy()),
         _workItemBuilder = new CodegenWorkItemBuilder(backend, options),
         nativeEnqueuer = backend.nativeCodegenEnqueuer(),
-        this._backend = backend,
+        this._listener = backend.codegenEnqueuerListener,
         this._options = options,
         this.name = 'codegen enqueuer' {
     _impactVisitor = new EnqueuerImplImpactVisitor(this);
   }
 
   CodegenWorldBuilder get worldBuilder => _universe;
 
   bool get queueIsEmpty => _queue.isEmpty;
 
   /// Returns [:true:] if this enqueuer is the resolution enqueuer.
   bool get isResolutionQueue => false;
 
   /// Create a [WorkItem] for [entity] and add it to the work list if it has not
   /// already been processed.
   void _addToWorkList(MemberEntity entity) {
     if (_processedEntities.contains(entity)) return;
 
     WorkItem workItem = _workItemBuilder.createWorkItem(entity);
     if (workItem == null) return;
 
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(
           entity, "Codegen work list is closed. Trying to add $entity");
     }
 
-    applyImpact(_backend.registerUsedElement(entity, forResolution: false));
+    applyImpact(_listener.registerUsedElement(entity));
     _queue.add(workItem);
   }
 
   void applyImpact(WorldImpact worldImpact, {var impactSource}) {
     if (worldImpact.isEmpty) return;
     impactStrategy.visitImpact(
         impactSource, worldImpact, _impactVisitor, impactUse);
   }
 
   void _registerInstantiatedType(ResolutionInterfaceType type,
       {bool mirrorUsage: false, bool nativeUsage: false}) {
     task.measure(() {
       _universe.registerTypeInstantiation(type, _applyClassUse,
           byMirrors: mirrorUsage);
       if (nativeUsage) {
         nativeEnqueuer.onInstantiatedType(type);
       }
-      _backend.registerInstantiatedType(type);
+      _listener.registerInstantiatedType(type);
     });
   }
 
   bool checkNoEnqueuedInvokedInstanceMethods() {
     return strategy.checkEnqueuerConsistency(this);
   }
 
   void checkClass(ClassEntity cls) {
     _universe.processClassMembers(cls, (MemberEntity member, useSet) {
       if (useSet.isNotEmpty) {
-        _backend.compiler.reporter.internalError(member,
+        throw new SpannableAssertionFailure(member,
             'Unenqueued use of $member: ${useSet.iterable(MemberUse.values)}');
       }
     });
   }
 
   /// 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(
-          _backend.registerInstantiatedClass(cls, forResolution: false));
+      applyImpact(_listener.registerInstantiatedClass(cls));
     }
     if (useSet.contains(ClassUse.IMPLEMENTED)) {
-      applyImpact(_backend.registerImplementedClass(cls, forResolution: false));
+      applyImpact(_listener.registerImplementedClass(cls));
     }
   }
 
   /// Callback for applying the use of a [member].
   void _applyMemberUse(Entity member, EnumSet<MemberUse> useSet) {
     if (useSet.contains(MemberUse.NORMAL)) {
       _addToWorkList(member);
     }
     if (useSet.contains(MemberUse.CLOSURIZE_INSTANCE)) {
       _registerClosurizedMember(member);
     }
     if (useSet.contains(MemberUse.CLOSURIZE_STATIC)) {
-      applyImpact(_backend.registerGetOfStaticFunction());
+      applyImpact(_listener.registerGetOfStaticFunction());
     }
   }
 
   void processDynamicUse(DynamicUse dynamicUse) {
     task.measure(() {
       _universe.registerDynamicUse(dynamicUse, _applyMemberUse);
     });
   }
 
   void processStaticUse(StaticUse staticUse) {
@@ skipping 40 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(TypedElement element) {
     assert(element.isInstanceMember);
     if (element.type.containsTypeVariables) {
-      applyImpact(_backend.registerClosureWithFreeTypeVariables(element,
-          forResolution: false));
+      MemberElement member = element;
+      applyImpact(_listener.registerClosureWithFreeTypeVariables(member));
     }
-    applyImpact(_backend.registerBoundClosure());
+    applyImpact(_listener.registerBoundClosure());
   }
 
   void forEach(void f(WorkItem work)) {
     do {
       while (_queue.isNotEmpty) {
         // TODO(johnniwinther): Find an optimal process order.
         WorkItem work = _queue.removeLast();
         if (!_processedEntities.contains(work.element)) {
           strategy.processWorkItem(f, work);
           // TODO(johnniwinther): Register the processed element here. This
           // is currently a side-effect of calling `work.run`.
           _processedEntities.add(work.element);
         }
       }
       List recents = _recentClasses.toList(growable: false);
       _recentClasses.clear();
       if (!_onQueueEmpty(recents)) _recentClasses.addAll(recents);
     } while (_queue.isNotEmpty || _recentClasses.isNotEmpty);
   }
 
   /// [_onQueueEmpty] is called whenever the queue is drained. [recentClasses]
   /// contains the set of all classes seen for the first time since
   /// [_onQueueEmpty] was called last. A return value of [true] indicates that
   /// the [recentClasses] have been processed and may be cleared. If [false] is
   /// returned, [_onQueueEmpty] will be called once the queue is empty again (or
   /// still empty) and [recentClasses] will be a superset of the current value.
   bool _onQueueEmpty(Iterable<ClassEntity> recentClasses) {
-    return _backend.onQueueEmpty(this, recentClasses);
+    return _listener.onQueueEmpty(this, recentClasses);
   }
 
   void logSummary(log(message)) {
     log('Compiled ${_processedEntities.length} methods.');
     nativeEnqueuer.logSummary(log);
   }
 
   String toString() => 'Enqueuer($name)';
 
   ImpactUseCase get impactUse => IMPACT_USE;
@@ skipping 24 matching lines @@
     // code for checked setters.
     if (element.isField && element.isInstanceMember) {
       if (!_options.enableTypeAssertions ||
           element.enclosingElement.isClosure) {
         return null;
       }
     }
     return new CodegenWorkItem(_backend, element);
   }
 }