Move CodegenEnqueuer.generatedCode to JavaScriptBackend.

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 125 matching lines @@
 
   final EnqueuerStrategy strategy;
   final Set<ClassEntity> _recentClasses = new Setlet<ClassEntity>();
   final ResolutionWorldBuilderImpl _universe;
 
   bool queueIsClosed = false;
 
   WorldImpactVisitor _impactVisitor;
 
   /// All declaration elements that have been processed by the resolver.
-  final Set<Entity> _processedElements = new Set<Entity>();
+  final Set<Entity> _processedEntities = new Set<Entity>();
 
   final Queue<WorkItem> _queue = new Queue<WorkItem>();
 
   /// Queue of deferred resolution actions to execute when the resolution queue
   /// has been emptied.
   final Queue<_DeferredAction> _deferredQueue = new Queue<_DeferredAction>();
 
   ResolutionEnqueuer(
       this.task,
       this._options,
@@ skipping 166 matching lines @@
     }
     applyImpact(backend.registerBoundClosure());
     _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)) {
+        if (!_processedEntities.contains(work.element)) {
           strategy.processWorkItem(f, work);
-          _processedElements.add(work.element);
+          _processedEntities.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.');
+    log('Resolved ${_processedEntities.length} elements.');
     nativeEnqueuer.logSummary(log);
   }
 
   String toString() => 'Enqueuer($name)';
 
-  Iterable<Entity> get processedEntities => _processedElements;
+  Iterable<Entity> get processedEntities => _processedEntities;
 
   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) {
     assert(invariant(element, element == element.analyzableElement.declaration,
         message: "Unexpected element $element"));
-    return _processedElements.contains(element);
+    return _processedEntities.contains(element);
   }
 
   /// Registers [element] as processed by the resolution enqueuer. Used only for
   /// testing.
-  void registerProcessedElementInternal(AstElement element) {
-    _processedElements.add(element);
+  void registerProcessedElementInternal(Entity entity) {
+    _processedEntities.add(entity);
   }
 
   /// 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;
 
     assert(invariant(element, element is AnalyzableElement,
@@ skipping 42 matching lines @@
 
   void _emptyDeferredQueue() {
     while (!_deferredQueue.isEmpty) {
       _DeferredAction task = _deferredQueue.removeFirst();
       _reporter.withCurrentElement(task.element, task.action);
     }
   }
 
   void forgetEntity(Entity entity, Compiler compiler) {
     _universe.forgetEntity(entity, compiler);
-    _processedElements.remove(entity);
+    _processedEntities.remove(entity);
   }
 }
 
 /// Strategy used by the enqueuer to populate the world.
 class EnqueuerStrategy {
   const EnqueuerStrategy();
 
   /// Process a static use of and element in live code.
   void processStaticUse(EnqueuerImpl enqueuer, StaticUse staticUse) {}
 
@@ skipping 80 matching lines @@
 }
 
 typedef void _DeferredActionFunction();
 
 class _DeferredAction {
   final Element element;
   final _DeferredActionFunction action;
 
   _DeferredAction(this.element, this.action);
 }