Use KernelTypeGraphBuilder in KernelInferrerEngine

pkg/compiler/lib/src/world.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.world;
 
 import 'common.dart';
 import 'constants/constant_system.dart';
 import 'common_elements.dart' show CommonElements, ElementEnvironment;
 import 'elements/entities.dart';
@@ skipping 46 matching lines @@
   CommonElements get commonElements;
 
   CommonMasks get commonMasks;
 
   ConstantSystem get constantSystem;
 
   RuntimeTypesNeed get rtiNeed;
 
   Iterable<ClassEntity> get liveNativeClasses;
 
+  Iterable<MemberEntity> get processedMembers;
+
   /// Returns `true` if [cls] is either directly or indirectly instantiated.
   bool isInstantiated(ClassEntity cls);
 
   /// Returns `true` if [cls] is directly instantiated. This means that at
   /// runtime instances of exactly [cls] are assumed to exist.
   bool isDirectlyInstantiated(ClassEntity cls);
 
   /// Returns `true` if [cls] is abstractly instantiated. This means that at
   /// runtime instances of [cls] or unknown subclasses of [cls] are assumed to
   /// exist.
@@ skipping 377 matching lines @@
   // TODO(johnniwinther): Can this be derived from [ClassSet]s?
   final Set<ClassEntity> _implementedClasses;
 
   final Iterable<MemberEntity> liveInstanceMembers;
 
   /// Members that are written either directly or through a setter selector.
   final Iterable<MemberEntity> assignedInstanceMembers;
 
   final Iterable<ClassEntity> liveNativeClasses;
 
+  final Iterable<MemberEntity> processedMembers;
+
   ClosedWorldBase(
       this.elementEnvironment,
       this.dartTypes,
       this.commonElements,
       this.constantSystem,
       this.nativeData,
       this.interceptorData,
       this.backendUsage,
       Set<ClassEntity> implementedClasses,
       this.liveNativeClasses,
       this.liveInstanceMembers,
       this.assignedInstanceMembers,
+      this.processedMembers,
       Set<TypedefEntity> allTypedefs,
       this.mixinUses,
       this.typesImplementedBySubclasses,
       Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
       Map<ClassEntity, ClassSet> classSets)
       : this._implementedClasses = implementedClasses,
         this._allTypedefs = allTypedefs,
         this._classHierarchyNodes = classHierarchyNodes,
         this._classSets = classSets {
     _commonMasks = new CommonMasks(this);
@@ skipping 713 matching lines @@
       ConstantSystem constantSystem,
       NativeData nativeData,
       InterceptorData interceptorData,
       BackendUsage backendUsage,
       ResolutionWorldBuilder resolutionWorldBuilder,
       RuntimeTypesNeedBuilder rtiNeedBuilder,
       Set<ClassEntity> implementedClasses,
       Iterable<ClassEntity> liveNativeClasses,
       Iterable<MemberEntity> liveInstanceMembers,
       Iterable<MemberEntity> assignedInstanceMembers,
+      Iterable<MemberEntity> processedMembers,
       Set<TypedefEntity> allTypedefs,
       Map<ClassEntity, Set<ClassEntity>> mixinUses,
       Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses,
       Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
       Map<ClassEntity, ClassSet> classSets})
       : super(
             elementEnvironment,
             dartTypes,
             commonElements,
             constantSystem,
             nativeData,
             interceptorData,
             backendUsage,
             implementedClasses,
             liveNativeClasses,
             liveInstanceMembers,
             assignedInstanceMembers,
+            processedMembers,
             allTypedefs,
             mixinUses,
             typesImplementedBySubclasses,
             classHierarchyNodes,
             classSets) {
     computeRtiNeed(resolutionWorldBuilder, rtiNeedBuilder,
         enableTypeAssertions: options.enableTypeAssertions);
   }
 
   bool checkClass(ClassElement cls) => cls.isDeclaration;
@@ skipping 117 matching lines @@
   void computeRtiNeed(ResolutionWorldBuilder resolutionWorldBuilder,
       RuntimeTypesNeedBuilder rtiNeedBuilder,
       {bool enableTypeAssertions}) {
     _rtiNeed = rtiNeedBuilder.computeRuntimeTypesNeed(
         resolutionWorldBuilder, this,
         enableTypeAssertions: enableTypeAssertions);
   }
 
   RuntimeTypesNeed get rtiNeed => _rtiNeed;
 }