Create ResolutionEnqueuer after library loading.

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 16 matching lines @@
 import 'world.dart' show ClosedWorld;
 
 class EnqueueTask extends CompilerTask {
   ResolutionEnqueuer _resolution;
   final Compiler compiler;
 
   String get name => 'Enqueue';
 
   EnqueueTask(Compiler compiler)
       : this.compiler = compiler,
-        super(compiler.measurer) {
-    createResolutionEnqueuer();
-  }
+        super(compiler.measurer);
 
+  // TODO(johnniwinther): Remove the need for this.
+  bool get hasResolution => _resolution != null;
+
+  // TODO(johnniwinther): Remove the need for this.
   ResolutionEnqueuer get resolution {
     assert(invariant(NO_LOCATION_SPANNABLE, _resolution != null,
         message: "ResolutionEnqueuer has not been created yet."));
     return _resolution;
   }
 
   ResolutionEnqueuer createResolutionEnqueuer() {
     return _resolution ??=
         compiler.backend.createResolutionEnqueuer(this, compiler);
   }
@@ skipping 134 matching lines @@
 
   WorldImpactVisitor _impactVisitor;
 
   /// All declaration elements that have been processed by the resolver.
   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>();
+  final Queue<DeferredAction> _deferredQueue = new Queue<DeferredAction>();
 
   ResolutionEnqueuer(this.task, this._options, this._reporter, this.strategy,
       this.listener, this._worldBuilder, this._workItemBuilder,
       [this.name = 'resolution enqueuer']) {
     _impactVisitor = new EnqueuerImplImpactVisitor(this);
   }
 
   ResolutionWorldBuilder get worldBuilder => _worldBuilder;
 
   bool get queueIsEmpty => _queue.isEmpty;
@@ skipping 202 matching lines @@
     applyImpact(listener.registerUsedElement(entity));
     _worldBuilder.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()) {
+  void addDeferredAction(DeferredAction deferredAction) {
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(
-          entity,
+          deferredAction.element,
           "Resolution work list is closed. "
-          "Trying to add deferred action for $entity");
+          "Trying to add deferred action for ${deferredAction.element}");
     }
-    _deferredQueue.add(new _DeferredAction(entity, action));
+    _deferredQueue.add(deferredAction);
+  }
+
+  void addDeferredActions(Iterable<DeferredAction> deferredActions) {
+    deferredActions.forEach(addDeferredAction);
   }
 
   /// [_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) {
     _emptyDeferredQueue();
 
     return listener.onQueueEmpty(this, recentClasses);
   }
 
   void emptyDeferredQueueForTesting() => _emptyDeferredQueue();
 
   void _emptyDeferredQueue() {
     while (!_deferredQueue.isEmpty) {
-      _DeferredAction task = _deferredQueue.removeFirst();
+      DeferredAction task = _deferredQueue.removeFirst();
       _reporter.withCurrentElement(task.element, task.action);
     }
   }
 }
 
 /// Strategy used by the enqueuer to populate the world.
 class EnqueuerStrategy {
   const EnqueuerStrategy();
 
   /// Process a static use of and element in live code.
@@ skipping 74 matching lines @@
   void visitStaticUse(StaticUse staticUse) {
     enqueuer.strategy.processStaticUse(enqueuer, staticUse);
   }
 
   @override
   void visitTypeUse(TypeUse typeUse) {
     enqueuer.strategy.processTypeUse(enqueuer, typeUse);
   }
 }
 
-typedef void _DeferredActionFunction();
+typedef void DeferredActionFunction();
 
-class _DeferredAction {
+class DeferredAction {
   final Entity element;
-  final _DeferredActionFunction action;
+  final DeferredActionFunction action;
 
-  _DeferredAction(this.element, this.action);
+  DeferredAction(this.element, this.action);
 }
 
 /// Interface for creating work items for enqueued member entities.
 abstract class WorkItemBuilder {
   WorkItem createWorkItem(MemberEntity entity);
 }
 
 /// Builder that creates work item necessary for the resolution of a
 /// [MemberElement].
 class ResolutionWorkItemBuilder extends WorkItemBuilder {
   final Resolution _resolution;
 
   ResolutionWorkItemBuilder(this._resolution);
 
   @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);
   }
 }