Extract ClosedWorldRefiner implementation from ClosedWorldImpl to ClosedWorldBase

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 73 matching lines @@
   /// 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, {var impactSource});
   bool checkNoEnqueuedInvokedInstanceMethods();
 
   /// Check the enqueuer queue is empty or fail otherwise.
   void checkQueueIsEmpty();
   void logSummary(void log(String message));
 
-  Iterable<Entity> get processedEntities;
+  Iterable<MemberEntity> get processedEntities;
 
   Iterable<ClassEntity> get processedClasses;
 }
 
 abstract class EnqueuerListener {
   /// Called to instruct to the backend that [type] has been instantiated.
   void registerInstantiatedType(InterfaceType type,
       {bool isGlobal: false, bool nativeUsage: false});
 
   /// Called to notify to the backend that a class is being instantiated. Any
@@ skipping 93 matching lines @@
   bool _recentConstants = false;
   final ResolutionEnqueuerWorldBuilder _worldBuilder;
   final WorkItemBuilder _workItemBuilder;
   final DiagnosticReporter _reporter;
 
   bool queueIsClosed = false;
 
   WorldImpactVisitor _impactVisitor;
 
   /// All declaration elements that have been processed by the resolver.
-  final Set<Entity> _processedEntities = new Set<Entity>();
+  final Set<MemberEntity> _processedEntities = new Set<MemberEntity>();
 
   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, this._reporter, this.strategy,
       this.listener, this._worldBuilder, this._workItemBuilder,
       [this.name = 'resolution enqueuer']) {
@@ skipping 179 matching lines @@
         _recentConstants);
   }
 
   void logSummary(void log(String message)) {
     log('Resolved ${_processedEntities.length} elements.');
     listener.logSummary(log);
   }
 
   String toString() => 'Enqueuer($name)';
 
-  Iterable<Entity> get processedEntities => _processedEntities;
+  Iterable<MemberEntity> 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): Remove this together with the resolver.
   bool hasBeenProcessed(MemberElement element) {
     assert(invariant(element, element == element.analyzableElement.declaration,
         message: "Unexpected element $element"));
     return _processedEntities.contains(element);
   }
 
   /// Registers [entity] as processed by the resolution enqueuer. Used only for
   /// testing.
-  void registerProcessedElementInternal(Entity entity) {
+  void registerProcessedElementInternal(MemberEntity entity) {
     _processedEntities.add(entity);
   }
 
   /// 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;
 
@@ skipping 174 matching lines @@
   @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);
   }
 }