Use KernelTypeGraphBuilder in KernelInferrerEngine

pkg/compiler/lib/src/universe/resolution_world_builder.dart

 // Copyright (c) 2017, 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.
 
 part of world_builder;
 
 abstract class ResolutionWorldBuilder implements WorldBuilder, OpenWorld {
   /// Set of all local functions in the program. Used by the mirror tracking
   /// system to find all live closure instances.
   Iterable<Local> get localFunctions;
@@ skipping 71 matching lines @@
   /// [membersUsed] with the usage changes for each member.
   void registerDynamicUse(DynamicUse dynamicUse, MemberUsedCallback memberUsed);
 
   /// Applies the [staticUse] to applicable members. Calls [membersUsed] with
   /// the usage changes for each member.
   void registerStaticUse(StaticUse staticUse, MemberUsedCallback memberUsed);
 
   /// Register the constant [use] with this world builder. Returns `true` if
   /// the constant use was new to the world.
   bool registerConstantUse(ConstantUse use);
+
+  bool isMemberProcessed(MemberEntity member);
+  void registerProcessedMember(MemberEntity member);
+  Iterable<MemberEntity> get processedMembers;
 }
 
 /// The type and kind of an instantiation registered through
 /// `ResolutionWorldBuilder.registerTypeInstantiation`.
 class Instance {
   final InterfaceType type;
   final Instantiation kind;
   final bool isRedirection;
 
   Instance(this.type, this.kind, {this.isRedirection: false});
@@ skipping 263 matching lines @@
       new Map<ClassEntity, Set<ClassEntity>>();
 
   // We keep track of subtype and subclass relationships in four
   // distinct sets to make class hierarchy analysis faster.
   final Map<ClassEntity, ClassHierarchyNode> _classHierarchyNodes =
       <ClassEntity, ClassHierarchyNode>{};
   final Map<ClassEntity, ClassSet> _classSets = <ClassEntity, ClassSet>{};
 
   final Set<ConstantValue> _constantValues = new Set<ConstantValue>();
 
+  Set<MemberEntity> _processedMembers = new Set<MemberEntity>();
+
   bool get isClosed => _closed;
 
   ResolutionWorldBuilderBase(
       this._options,
       this._elementEnvironment,
       this._dartTypes,
       this._commonElements,
       this._constantSystem,
       this._nativeBasicData,
       this._nativeDataBuilder,
       this._interceptorDataBuilder,
       this._backendUsageBuilder,
       this._rtiNeedBuilder,
       this._nativeResolutionEnqueuer,
       this.selectorConstraintsStrategy);
 
   Iterable<ClassEntity> get processedClasses => _processedClasses.keys
       .where((cls) => _processedClasses[cls].isInstantiated);
 
+  bool isMemberProcessed(MemberEntity member) =>
+      _processedMembers.contains(member);
+  void registerProcessedMember(MemberEntity member) {
+    _processedMembers.add(member);
+  }
+
+  Iterable<MemberEntity> get processedMembers => _processedMembers;
+
   ClosedWorld get closedWorldForTesting {
     if (!_closed) {
       failedAt(
           NO_LOCATION_SPANNABLE, "The world builder has not yet been closed.");
     }
     return _closedWorldCache;
   }
 
   /// All directly instantiated classes, that is, classes with a generative
   /// constructor that has been called directly and not only through a
@@ skipping 592 matching lines @@
         nativeData: _nativeDataBuilder.close(),
         interceptorData: _interceptorDataBuilder.close(),
         backendUsage: _backendUsageBuilder.close(),
         resolutionWorldBuilder: this,
         rtiNeedBuilder: _rtiNeedBuilder,
         constantSystem: _constantSystem,
         implementedClasses: _implementedClasses,
         liveNativeClasses: _nativeResolutionEnqueuer.liveNativeClasses,
         liveInstanceMembers: _liveInstanceMembers,
         assignedInstanceMembers: computeAssignedInstanceMembers(),
+        processedMembers: _processedMembers,
         allTypedefs: _allTypedefs,
         mixinUses: _mixinUses,
         typesImplementedBySubclasses: typesImplementedBySubclasses,
         classHierarchyNodes: _classHierarchyNodes,
         classSets: _classSets);
   }
 
   @override
   void registerClass(ClassEntity cls) {
     throw new UnimplementedError('KernelResolutionWorldBuilder.registerClass');
   }
 }