Use KernelTypeGraphBuilder in KernelInferrerEngine

pkg/compiler/lib/src/inferrer/inferrer_engine.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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
 import '../common_elements.dart';
@@ skipping 51 matching lines @@
   ClosedWorldRefiner get closedWorldRefiner;
   JavaScriptBackend get backend => compiler.backend;
   OptimizerHintsForTests get optimizerHints => backend.optimizerHints;
   DiagnosticReporter get reporter => compiler.reporter;
   CommonMasks get commonMasks => closedWorld.commonMasks;
   CommonElements get commonElements => closedWorld.commonElements;
 
   TypeSystem<T> get types;
   Map<T, TypeInformation> get concreteTypes;
 
-  /// Parallel structure for concreteTypes.
-  // TODO(efortuna): Remove concreteTypes and/or parameterize InferrerEngine by
-  // ir.Node or ast.Node type. Then remove this in favor of `concreteTypes`.
-  Map<ir.Node, TypeInformation> get concreteKernelTypes;
-
   FunctionEntity get mainElement;
 
   void runOverAllElements();
 
   void analyze(MemberEntity member, T node, ArgumentsTypes arguments);
   void analyzeListAndEnqueue(ListTypeInformation info);
   void analyzeMapAndEnqueue(MapTypeInformation info);
 
   /// Notifies to the inferrer that [analyzedElement] can have return type
   /// [newType]. [currentType] is the type the [ElementGraphBuilder] currently
@@ skipping 539 matching lines @@
     }
     dump?.afterAnalysis();
 
     reporter.log('Inferred $overallRefineCount types.');
 
     processLoopInformation();
   }
 
   /// Call [analyze] for all live members.
   void analyzeAllElements() {
-    sortMembers(compiler, computeMemberSize).forEach((MemberEntity member) {
+    sortMembers(closedWorld.processedMembers, computeMemberSize)
+        .forEach((MemberEntity member) {
       if (compiler.shouldPrintProgress) {
         reporter.log('Added $addedInGraph elements in inferencing graph.');
         compiler.progress.reset();
       }
       // This also forces the creation of the [ElementTypeInformation] to ensure
       // it is in the graph.
       T body = computeMemberBody(member);
       types.withMember(member, () => analyze(member, body, null));
     });
     reporter.log('Added $addedInGraph elements in inferencing graph.');
@@ skipping 465 matching lines @@
       return types.dynamicType;
     } else {
       return returnTypeOfMember(element);
     }
   }
 
   // Sorts the resolved elements by size. We do this for this inferrer
   // to get the same results for [ListTracer] compared to the
   // [SimpleTypesInferrer].
   static Iterable<MemberEntity> sortMembers(
-      Compiler compiler, int computeSize(MemberEntity member)) {
+      Iterable<MemberEntity> members, int computeSize(MemberEntity member)) {
     Map<int, Set<MemberEntity>> methodSizes =
-        groupMembers(compiler, computeSize);
+        groupMembers(members, computeSize);
     int max = methodSizes.keys.fold(0, (a, b) => a > b ? a : b);
     List<MemberEntity> result = <MemberEntity>[];
     for (int i = 0; i <= max; i++) {
       Set<MemberEntity> set = methodSizes[i];
       if (set != null) result.addAll(set);
     }
     return result;
   }
 
   static Map<int, Set<MemberEntity>> groupMembers(
-      Compiler compiler, int computeSize(MemberEntity member)) {
+      Iterable<MemberEntity> members, int computeSize(MemberEntity member)) {
     Map<int, Set<MemberEntity>> methodSizes = <int, Set<MemberEntity>>{};
-    compiler.enqueuer.resolution.processedEntities
-        .forEach((MemberEntity element) {
+    members.forEach((MemberEntity element) {
       if (element.isAbstract) return;
       // Put the other operators in buckets by size, later to be added in
       // size order.
       int size = computeSize(element);
       Set<MemberEntity> set =
           methodSizes.putIfAbsent(size, () => new Setlet<MemberEntity>());
       set.add(element);
     });
     return methodSizes;
   }
 }