Use KernelTypeGraphBuilder in KernelInferrerEngine

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/tasks.dart' show CompilerTask;
 import 'common/work.dart' show WorkItem;
@@ skipping 189 matching lines @@
   final Set<ClassEntity> _recentClasses = new Setlet<ClassEntity>();
   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<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']) {
     _impactVisitor = new EnqueuerImplImpactVisitor(this);
@@ skipping 159 matching lines @@
     applyImpact(listener.registerClosurizedMember(element),
         impactSource: 'closurized member');
     _worldBuilder.registerClosurizedMember(element);
   }
 
   void forEach(void f(WorkItem work)) {
     do {
       while (_queue.isNotEmpty) {
         // TODO(johnniwinther): Find an optimal process order.
         WorkItem work = _queue.removeLast();
-        if (!_processedEntities.contains(work.element)) {
+        if (!_worldBuilder.isMemberProcessed(work.element)) {
           strategy.processWorkItem(f, work);
-          _processedEntities.add(work.element);
+          _worldBuilder.registerProcessedMember(work.element);
         }
       }
       List<ClassEntity> recents = _recentClasses.toList(growable: false);
       _recentClasses.clear();
       _recentConstants = false;
       if (!_onQueueEmpty(recents)) {
         _recentClasses.addAll(recents);
       }
     } while (_queue.isNotEmpty ||
         _recentClasses.isNotEmpty ||
         _deferredQueue.isNotEmpty ||
         _recentConstants);
   }
 
   void logSummary(void log(String message)) {
-    log('Resolved ${_processedEntities.length} elements.');
+    log('Resolved ${processedEntities.length} elements.');
     listener.logSummary(log);
   }
 
   String toString() => 'Enqueuer($name)';
 
-  Iterable<MemberEntity> get processedEntities => _processedEntities;
+  Iterable<MemberEntity> get processedEntities =>
+      _worldBuilder.processedMembers;
 
   ImpactUseCase get impactUse => IMPACT_USE;
 
   bool get isResolutionQueue => true;
 
   /// Registers [entity] as processed by the resolution enqueuer. Used only for
   /// testing.
   void registerProcessedElementInternal(MemberEntity entity) {
-    _processedEntities.add(entity);
+    _worldBuilder.registerProcessedMember(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;
+    if (_worldBuilder.isMemberProcessed(entity)) return;
     WorkItem workItem = _workItemBuilder.createWorkItem(entity);
     if (workItem == null) return;
 
     if (queueIsClosed) {
       failedAt(
           entity, "Resolution work list is closed. Trying to add $entity.");
     }
 
     applyImpact(listener.registerUsedElement(entity),
         impactSource: 'used element');
@@ skipping 153 matching lines @@
   final Entity element;
   final DeferredActionFunction action;
 
   DeferredAction(this.element, this.action);
 }
 
 /// Interface for creating work items for enqueued member entities.
 abstract class WorkItemBuilder {
   WorkItem createWorkItem(covariant MemberEntity entity);
 }