Make Enqueuer a pure interface.

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/codegen.dart' show CodegenWorkItem;
 import 'common/names.dart' show Identifiers;
 import 'common/resolution.dart' show Resolution;
 import 'common/resolution.dart' show ResolutionWorkItem;
 import 'common/tasks.dart' show CompilerTask;
 import 'common/work.dart' show ItemCompilationContext, WorkItem;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
 import 'dart_types.dart' show DartType, InterfaceType;
 import 'elements/elements.dart'
     show
         AnalyzableElement,
         AstElement,
         ClassElement,
         ConstructorElement,
         Element,
         Elements,
+        Entity,
         FunctionElement,
         LibraryElement,
         Member,
-        MemberElement,
         Name,
         TypedElement,
         TypedefElement;
-import 'js/js.dart' as js;
 import 'native/native.dart' as native;
 import 'types/types.dart' show TypeMaskStrategy;
 import 'universe/selector.dart' show Selector;
 import 'universe/universe.dart';
 import 'universe/use.dart'
     show DynamicUse, StaticUse, StaticUseKind, TypeUse, TypeUseKind;
 import 'universe/world_impact.dart'
     show ImpactUseCase, WorldImpact, WorldImpactVisitor;
 import 'util/util.dart' show Setlet;
 
 typedef ItemCompilationContext ItemCompilationContextCreator();
 
 class EnqueueTask extends CompilerTask {
   final ResolutionEnqueuer resolution;
-  final CodegenEnqueuer codegen;
+  final Enqueuer codegen;
   final Compiler compiler;
 
   String get name => 'Enqueue';
 
   EnqueueTask(Compiler compiler)
       : compiler = compiler,
         resolution = new ResolutionEnqueuer(
             compiler,
             compiler.backend.createItemCompilationContext,
             compiler.options.analyzeOnly && compiler.options.analyzeMain
                 ? const EnqueuerStrategy()
                 : const TreeShakingEnqueuerStrategy()),
         codegen = compiler.backend.createCodegenEnqueuer(compiler),
         super(compiler.measurer) {
     codegen.task = this;
     resolution.task = this;
 
     codegen.nativeEnqueuer = compiler.backend.nativeCodegenEnqueuer(codegen);
     resolution.nativeEnqueuer =
         compiler.backend.nativeResolutionEnqueuer(resolution);
   }
 
   void forgetElement(Element element) {
     resolution.forgetElement(element);
     codegen.forgetElement(element);
   }
 }
 
 abstract class Enqueuer {
+  EnqueueTask task;
+  Universe get universe;
+  native.NativeEnqueuer nativeEnqueuer; // Set by EnqueueTask
+  void forgetElement(Element element);
+  void processInstantiatedClassMembers(ClassElement cls);
+  void processInstantiatedClassMember(ClassElement cls, Element member);
+  void handleUnseenSelectorInternal(DynamicUse dynamicUse);
+  void registerStaticUse(StaticUse staticUse);
+  void registerStaticUseInternal(StaticUse staticUse);
+  void registerDynamicUse(DynamicUse dynamicUse);
+  void registerTypeUse(TypeUse typeUse);
+
+  /// Returns [:true:] if this enqueuer is the resolution enqueuer.
+  bool get isResolutionQueue;
+
+  bool queueIsClosed;
+
+  bool get queueIsEmpty;
+
+  ImpactUseCase get impactUse;
+
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: [element] must be a declaration element.
+   */
+  void addToWorkList(Element element);
+
+  void enableIsolateSupport();
+
+  /// Enqueue the static fields that have been marked as used by reflective
+  /// usage through `MirrorsUsed`.
+  void enqueueReflectiveStaticFields(Iterable<Element> elements);
+
+  /// Enqueue all elements that are matched by the mirrors used
+  /// annotation or, in lack thereof, all elements.
+  void enqueueReflectiveElements(Iterable<ClassElement> recents);
+
+  void registerInstantiatedType(InterfaceType type, {bool mirrorUsage: false});
+  void forEach(void f(WorkItem work));
+  void applyImpact(Element element, WorldImpact worldImpact);
+  bool checkNoEnqueuedInvokedInstanceMethods();
+  void logSummary(log(message));
+
+  /// Returns [:true:] if [member] has been processed by this enqueuer.
+  bool isProcessed(Element member);
+
+  Iterable<Entity> get processedEntities;
+}
+
+/// [Enqueuer] which is specific to resolution.
+class ResolutionEnqueuer extends Enqueuer {
   final String name;
   final Compiler compiler; // TODO(ahe): Remove this dependency.
   final EnqueuerStrategy strategy;
   final ItemCompilationContextCreator itemCompilationContextCreator;
   final Map<String, Set<Element>> instanceMembersByName =
       new Map<String, Set<Element>>();
   final Map<String, Set<Element>> instanceFunctionsByName =
       new Map<String, Set<Element>>();
   final Set<ClassElement> _processedClasses = new Set<ClassElement>();
   Set<ClassElement> recentClasses = new Setlet<ClassElement>();
   final Universe universe = new Universe(const TypeMaskStrategy());
 
   static final TRACE_MIRROR_ENQUEUING =
       const bool.fromEnvironment("TRACE_MIRROR_ENQUEUING");
 
   bool queueIsClosed = false;
-  EnqueueTask task;
-  native.NativeEnqueuer nativeEnqueuer; // Set by EnqueueTask
 
   bool hasEnqueuedReflectiveElements = false;
   bool hasEnqueuedReflectiveStaticFields = false;
 
   WorldImpactVisitor impactVisitor;
 
-  Enqueuer(this.name, this.compiler, this.itemCompilationContextCreator,
-      this.strategy) {
+  ResolutionEnqueuer(
+      Compiler compiler, this.itemCompilationContextCreator, this.strategy)
+      : this.name = 'resolution enqueuer',
+        this.compiler = compiler,
+        processedElements = new Set<AstElement>(),
+        queue = new Queue<ResolutionWorkItem>(),
+        deferredQueue = new Queue<_DeferredAction>() {
     impactVisitor = new _EnqueuerImpactVisitor(this);
   }
 
   // TODO(johnniwinther): Move this to [ResolutionEnqueuer].
   Resolution get resolution => compiler.resolution;
 
-  Queue<WorkItem> get queue;
   bool get queueIsEmpty => queue.isEmpty;
 
-  /// Returns [:true:] if this enqueuer is the resolution enqueuer.
-  bool get isResolutionQueue => false;
-
   QueueFilter get filter => compiler.enqueuerFilter;
 
   DiagnosticReporter get reporter => compiler.reporter;
 
-  /// Returns [:true:] if [member] has been processed by this enqueuer.
-  bool isProcessed(Element member);
-
   bool isClassProcessed(ClassElement cls) => _processedClasses.contains(cls);
 
   Iterable<ClassElement> get processedClasses => _processedClasses;
 
-  ImpactUseCase get impactUse;
-
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [element] must be a declaration element.
    */
   void addToWorkList(Element element) {
     assert(invariant(element, element.isDeclaration));
     if (internalAddToWorkList(element) && compiler.options.dumpInfo) {
       // TODO(sigmund): add other missing dependencies (internals, selectors
       // enqueued after allocations), also enable only for the codegen enqueuer.
       compiler.dumpInfoTask
           .registerDependency(compiler.currentElement, element);
     }
   }
 
-  /**
-   * Adds [element] to the work list if it has not already been processed.
-   *
-   * Returns [true] if the element was actually added to the queue.
-   */
-  bool internalAddToWorkList(Element element);
-
   /// Apply the [worldImpact] of processing [element] to this enqueuer.
   void applyImpact(Element element, WorldImpact worldImpact) {
     compiler.impactStrategy
         .visitImpact(element, worldImpact, impactVisitor, impactUse);
   }
 
   void registerInstantiatedType(InterfaceType type, {bool mirrorUsage: false}) {
     task.measure(() {
       ClassElement cls = type.element;
       cls.ensureResolved(resolution);
@@ skipping 100 matching lines @@
       }
     }
 
     // The element is not yet used. Add it to the list of instance
     // members to still be processed.
     instanceMembersByName
         .putIfAbsent(memberName, () => new Set<Element>())
         .add(member);
   }
 
-  void registerNoSuchMethod(Element noSuchMethod);
-
-  void enableIsolateSupport() {}
-
   void processInstantiatedClass(ClassElement cls) {
     task.measure(() {
       if (_processedClasses.contains(cls)) return;
       // The class must be resolved to compute the set of all
       // supertypes.
       cls.ensureResolved(resolution);
 
       void processClass(ClassElement superclass) {
         if (_processedClasses.contains(superclass)) return;
         // TODO(johnniwinther): Re-insert this invariant when unittests don't
@@ skipping 30 matching lines @@
   }
 
   void registerDynamicUse(DynamicUse dynamicUse) {
     task.measure(() {
       if (universe.registerDynamicUse(dynamicUse)) {
         handleUnseenSelector(dynamicUse);
       }
     });
   }
 
-  /**
-   * Decides whether an element should be included to satisfy requirements
-   * of the mirror system. [includedEnclosing] provides a hint whether the
-   * enclosing element was included.
-   *
-   * The actual implementation depends on the current compiler phase.
-   */
-  bool shouldIncludeElementDueToMirrors(Element element,
-      {bool includedEnclosing});
-
   void logEnqueueReflectiveAction(action, [msg = ""]) {
     if (TRACE_MIRROR_ENQUEUING) {
       print("MIRROR_ENQUEUE (${isResolutionQueue ? "R" : "C"}): $action $msg");
     }
   }
 
   /// Enqeue the constructor [ctor] if it is required for reflection.
   ///
   /// [enclosingWasIncluded] provides a hint whether the enclosing element was
   /// needed for reflection.
@@ skipping 295 matching lines @@
       while (queue.isNotEmpty) {
         // TODO(johnniwinther): Find an optimal process order.
         filter.processWorkItem(f, queue.removeLast());
       }
       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<ClassElement> recentClasses) {
-    return compiler.backend.onQueueEmpty(this, recentClasses);
-  }
-
   void logSummary(log(message)) {
-    _logSpecificSummary(log);
+    log('Resolved ${processedElements.length} elements.');
     nativeEnqueuer.logSummary(log);
   }
 
-  /// Log summary specific to the concrete enqueuer.
-  void _logSpecificSummary(log(message));
-
   String toString() => 'Enqueuer($name)';
 
-  void forgetElement(Element element) {
-    universe.forgetElement(element, compiler);
-    _processedClasses.remove(element);
-    instanceMembersByName[element.name]?.remove(element);
-    instanceFunctionsByName[element.name]?.remove(element);
-  }
-}
-
-/// [Enqueuer] which is specific to resolution.
-class ResolutionEnqueuer extends Enqueuer {
   /// All declaration elements that have been processed by the resolver.
   final Set<AstElement> processedElements;
 
+  Iterable<Entity> get processedEntities => processedElements;
+
   final Queue<ResolutionWorkItem> queue;
 
   /// Queue of deferred resolution actions to execute when the resolution queue
   /// has been emptied.
   final Queue<_DeferredAction> deferredQueue;
 
   static const ImpactUseCase IMPACT_USE =
       const ImpactUseCase('ResolutionEnqueuer');
 
   ImpactUseCase get impactUse => IMPACT_USE;
 
-  ResolutionEnqueuer(
-      Compiler compiler,
-      ItemCompilationContext itemCompilationContextCreator(),
-      EnqueuerStrategy strategy)
-      : super('resolution enqueuer', compiler, itemCompilationContextCreator,
-            strategy),
-        processedElements = new Set<AstElement>(),
-        queue = new Queue<ResolutionWorkItem>(),
-        deferredQueue = new Queue<_DeferredAction>();
-
   bool get isResolutionQueue => true;
 
   bool isProcessed(Element member) => processedElements.contains(member);
 
   /// Returns `true` if [element] has been processed by the resolution enqueuer.
   bool hasBeenProcessed(Element element) {
     return processedElements.contains(element.analyzableElement.declaration);
   }
 
   /// Registers [element] as processed by the resolution enqueuer.
   void registerProcessedElement(AstElement element) {
     processedElements.add(element);
     compiler.backend.onElementResolved(element);
   }
 
   /**
    * Decides whether an element should be included to satisfy requirements
    * of the mirror system.
    *
    * During resolution, we have to resort to matching elements against the
    * [MirrorsUsed] pattern, as we do not have a complete picture of the world,
    * yet.
    */
   bool shouldIncludeElementDueToMirrors(Element element,
       {bool includedEnclosing}) {
     return includedEnclosing ||
         compiler.backend.requiredByMirrorSystem(element);
   }
 
+  /**
+   * Adds [element] to the work list if it has not already been processed.
+   *
+   * Returns [true] if the element was actually added to the queue.
+   */
   bool internalAddToWorkList(Element element) {
     if (element.isMalformed) return false;
 
     assert(invariant(element, element is AnalyzableElement,
         message: 'Element $element is not analyzable.'));
     if (hasBeenProcessed(element)) return false;
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(
           element, "Resolution work list is closed. Trying to add $element.");
     }
@@ skipping 57 matching lines @@
   void addDeferredAction(Element element, void action()) {
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(
           element,
           "Resolution work list is closed. "
           "Trying to add deferred action for $element");
     }
     deferredQueue.add(new _DeferredAction(element, action));
   }
 
+  /// [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<ClassElement> recentClasses) {
     _emptyDeferredQueue();
-    return super.onQueueEmpty(recentClasses);
+
+    return compiler.backend.onQueueEmpty(this, recentClasses);
   }
 
   void emptyDeferredQueueForTesting() => _emptyDeferredQueue();
 
   void _emptyDeferredQueue() {
     while (!deferredQueue.isEmpty) {
       _DeferredAction task = deferredQueue.removeFirst();
       reporter.withCurrentElement(task.element, task.action);
     }
   }
 
-  void _logSpecificSummary(log(message)) {
-    log('Resolved ${processedElements.length} elements.');
-  }
-
   void forgetElement(Element element) {
-    super.forgetElement(element);
+    universe.forgetElement(element, compiler);
+    _processedClasses.remove(element);
+    instanceMembersByName[element.name]?.remove(element);
+    instanceFunctionsByName[element.name]?.remove(element);
     processedElements.remove(element);
   }
 }
 
-/// [Enqueuer] which is specific to code generation.
-abstract class CodegenEnqueuer implements Enqueuer {
-  Map<Element, js.Expression> get generatedCode;
-
-  Set<Element> get newlyEnqueuedElements;
-}
-
 /// Parameterizes filtering of which work items are enqueued.
 class QueueFilter {
   bool checkNoEnqueuedInvokedInstanceMethods(Enqueuer enqueuer) {
     enqueuer.task.measure(() {
       // Run through the classes and see if we need to compile methods.
       for (ClassElement classElement
           in enqueuer.universe.directlyInstantiatedClasses) {
         for (ClassElement currentClass = classElement;
             currentClass != null;
             currentClass = currentClass.superclass) {
@@ skipping 71 matching lines @@
 }
 
 typedef void _DeferredActionFunction();
 
 class _DeferredAction {
   final Element element;
   final _DeferredActionFunction action;
 
   _DeferredAction(this.element, this.action);
 }