Change Enqueuer to use Entity instead of Element.

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 49 matching lines @@
         compiler.globalDependencies,
         compiler.backend,
         compiler.coreClasses,
         compiler.cacheStrategy);
     _codegen = compiler.backend.createCodegenEnqueuer(this, compiler);
   }
 
   ResolutionEnqueuer get resolution => _resolution;
   Enqueuer get codegen => _codegen;
 
-  void forgetElement(Element element) {
-    resolution.forgetElement(element, compiler);
-    codegen.forgetElement(element, compiler);
+  void forgetEntity(Entity entity) {
+    resolution.forgetEntity(entity, compiler);
+    codegen.forgetEntity(entity, compiler);
   }
 }
 
 abstract class Enqueuer {
   WorldBuilder get universe;
   native.NativeEnqueuer get nativeEnqueuer;
-  void forgetElement(Element element, Compiler compiler);
+  void forgetEntity(Entity entity, Compiler compiler);
 
   // TODO(johnniwinther): Initialize [_impactStrategy] to `null`.
   ImpactStrategy _impactStrategy = const ImpactStrategy();
 
   ImpactStrategy get impactStrategy => _impactStrategy;
 
   void open(ImpactStrategy impactStrategy) {
     _impactStrategy = impactStrategy;
   }
 
@@ skipping 10 matching lines @@
 
   bool get queueIsEmpty;
 
   ImpactUseCase get impactUse;
 
   void forEach(void f(WorkItem work));
 
   /// Apply the [worldImpact] to this enqueuer. If the [impactSource] is
   /// provided the impact strategy will remove it from the element impact cache,
   /// if it is no longer needed.
-  void applyImpact(WorldImpact worldImpact, {Element impactSource});
+  void applyImpact(WorldImpact worldImpact, {var impactSource});
   bool checkNoEnqueuedInvokedInstanceMethods();
   void logSummary(log(message));
 
-  /// Returns [:true:] if [member] has been processed by this enqueuer.
-  bool isProcessed(Element member);
-
   Iterable<Entity> get processedEntities;
 
-  Iterable<ClassElement> get processedClasses;
+  Iterable<ClassEntity> get processedClasses;
 }
 
 abstract class EnqueuerImpl extends Enqueuer {
   CompilerTask get task;
   EnqueuerStrategy get strategy;
-  void checkClass(ClassElement cls);
+  void checkClass(ClassEntity cls);
   void processStaticUse(StaticUse staticUse);
   void processTypeUse(TypeUse typeUse);
   void processDynamicUse(DynamicUse dynamicUse);
 }
 
 /// [Enqueuer] which is specific to resolution.
 class ResolutionEnqueuer extends EnqueuerImpl {
   static const ImpactUseCase IMPACT_USE =
       const ImpactUseCase('ResolutionEnqueuer');
 
   final CompilerTask task;
   final String name;
   final Resolution _resolution;
   final CompilerOptions _options;
   final Backend backend;
   final GlobalDependencyRegistry _globalDependencies;
   final CommonElements _commonElements;
   final native.NativeEnqueuer nativeEnqueuer;
 
   final EnqueuerStrategy strategy;
-  Set<ClassElement> _recentClasses = new Setlet<ClassElement>();
+  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<AstElement> processedElements = new Set<AstElement>();
+  final Set<AstElement> _processedElements = new Set<AstElement>();
 
   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 13 matching lines @@
   }
 
   ResolutionWorldBuilder get universe => _universe;
 
   OpenWorld get _openWorld => universe.openWorld;
 
   bool get queueIsEmpty => _queue.isEmpty;
 
   DiagnosticReporter get _reporter => _resolution.reporter;
 
-  Iterable<ClassElement> get processedClasses => _universe.processedClasses;
+  Iterable<ClassEntity> get processedClasses => _universe.processedClasses;
 
-  void applyImpact(WorldImpact worldImpact, {Element impactSource}) {
+  void applyImpact(WorldImpact worldImpact, {var impactSource}) {
     if (worldImpact.isEmpty) return;
     impactStrategy.visitImpact(
         impactSource, worldImpact, _impactVisitor, impactUse);
   }
 
   void _registerInstantiatedType(InterfaceType type,
       {ConstructorElement constructor,
       bool mirrorUsage: false,
       bool nativeUsage: false,
       bool globalDependency: false,
@@ skipping 10 matching lines @@
         nativeEnqueuer.onInstantiatedType(type);
       }
       backend.registerInstantiatedType(type);
     });
   }
 
   bool checkNoEnqueuedInvokedInstanceMethods() {
     return strategy.checkEnqueuerConsistency(this);
   }
 
-  void checkClass(ClassElement cls) {
+  void checkClass(ClassEntity cls) {
     _universe.processClassMembers(cls,
-        (MemberElement member, EnumSet<MemberUse> useSet) {
+        (MemberEntity member, EnumSet<MemberUse> useSet) {
       if (useSet.isNotEmpty) {
         _reporter.internalError(member,
             'Unenqueued use of $member: ${useSet.iterable(MemberUse.values)}');
       }
     });
   }
 
   /// Callback for applying the first seen use of a [member].
   void _applyFirstMemberUse(MemberElement member, EnumSet<MemberUse> useSet) {
     ClassElement cls = member.enclosingClass;
@@ skipping 38 matching lines @@
     task.measure(() {
       _universe.registerDynamicUse(dynamicUse, _applyMemberUse);
     });
   }
 
   void processStaticUse(StaticUse staticUse) {
     Element element = staticUse.element;
     assert(invariant(element, element.isDeclaration,
         message: "Element ${element} is not the declaration."));
     _universe.registerStaticUse(staticUse);
-    applyImpact(backend.registerStaticUse(element, forResolution: true));
     bool addElement = true;
     switch (staticUse.kind) {
       case StaticUseKind.STATIC_TEAR_OFF:
         applyImpact(backend.registerGetOfStaticFunction());
         break;
       case StaticUseKind.FIELD_GET:
       case StaticUseKind.FIELD_SET:
       case StaticUseKind.CLOSURE:
         // TODO(johnniwinther): Avoid this. Currently [FIELD_GET] and
         // [FIELD_SET] contains [BoxFieldElement]s which we cannot enqueue.
@@ skipping 83 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 (!isProcessed(work.element)) {
+        if (!_processedElements.contains(work.element)) {
           strategy.processWorkItem(f, work);
           registerProcessedElement(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 ${_processedElements.length} elements.');
     nativeEnqueuer.logSummary(log);
   }
 
   String toString() => 'Enqueuer($name)';
 
-  Iterable<Entity> get processedEntities => processedElements;
+  Iterable<Entity> get processedEntities => _processedElements;
 
   ImpactUseCase get impactUse => IMPACT_USE;
 
   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);
+    return _processedElements.contains(element.analyzableElement.declaration);
   }
 
   /// Registers [element] as processed by the resolution enqueuer.
   void registerProcessedElement(AstElement element) {
-    processedElements.add(element);
-    backend.onElementResolved(element);
+    _processedElements.add(element);
   }
 
   /// 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,
         message: 'Element $element is not analyzable.'));
     if (hasBeenProcessed(element)) return;
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(
           element, "Resolution work list is closed. Trying to add $element.");
     }
 
+    applyImpact(backend.registerUsedElement(element, forResolution: true));
     _openWorld.registerUsedElement(element);
 
     ResolutionWorkItem workItem = _resolution.createWorkItem(element);
     _queue.add(workItem);
 
     // Enable isolate support if we start using something from the isolate
     // library, or timers for the async library.  We exclude constant fields,
     // which are ending here because their initializing expression is compiled.
     LibraryElement library = element.library;
     if (!universe.hasIsolateSupport && (!element.isField || !element.isConst)) {
@@ skipping 25 matching lines @@
 
   void _registerNoSuchMethod(Element element) {
     backend.registerNoSuchMethod(element);
   }
 
   void _enableIsolateSupport() {
     _universe.hasIsolateSupport = true;
     applyImpact(backend.enableIsolateSupport(forResolution: true));
   }
 
-  /**
-   * 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(Element element, void action()) {
+  /// 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()) {
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(
-          element,
+          entity,
           "Resolution work list is closed. "
-          "Trying to add deferred action for $element");
+          "Trying to add deferred action for $entity");
     }
-    _deferredQueue.add(new _DeferredAction(element, action));
+    _deferredQueue.add(new _DeferredAction(entity, 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) {
+  bool _onQueueEmpty(Iterable<ClassEntity> recentClasses) {
     _emptyDeferredQueue();
 
     return backend.onQueueEmpty(this, recentClasses);
   }
 
   void emptyDeferredQueueForTesting() => _emptyDeferredQueue();
 
   void _emptyDeferredQueue() {
     while (!_deferredQueue.isEmpty) {
       _DeferredAction task = _deferredQueue.removeFirst();
       _reporter.withCurrentElement(task.element, task.action);
     }
   }
 
-  void forgetElement(Element element, Compiler compiler) {
-    _universe.forgetElement(element, compiler);
-    processedElements.remove(element);
+  void forgetEntity(Entity entity, Compiler compiler) {
+    _universe.forgetEntity(entity, compiler);
+    _processedElements.remove(entity);
   }
 }
 
-void removeFromSet(Map<String, Set<Element>> map, Element element) {
-  Set<Element> set = map[element.name];
-  if (set == null) return;
-  set.remove(element);
-}
-
 /// 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) {}
 
   /// Process a type use in live code.
   void processTypeUse(EnqueuerImpl enqueuer, TypeUse typeUse) {}
 
@@ skipping 77 matching lines @@
 }
 
 typedef void _DeferredActionFunction();
 
 class _DeferredAction {
   final Element element;
   final _DeferredActionFunction action;
 
   _DeferredAction(this.element, this.action);
 }