Extract sorting method from AstInferrerEngine.

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';
 import '../constants/values.dart';
 import '../elements/elements.dart'
     show
         ClassElement,
         ConstructorElement,
         Elements,
         MemberElement,
         ParameterElement;
 import '../elements/entities.dart';
 import '../elements/names.dart';
 import '../js_backend/annotations.dart';
 import '../js_backend/js_backend.dart';
 import '../native/behavior.dart' as native;
 import '../types/constants.dart';
 import '../types/types.dart';
 import '../universe/call_structure.dart';
 import '../universe/selector.dart';
 import '../universe/side_effects.dart';
+import '../util/setlet.dart';
 import '../world.dart';
 import 'closure_tracer.dart';
 import 'debug.dart' as debug;
 import 'locals_handler.dart';
 import 'list_tracer.dart';
 import 'map_tracer.dart';
 import 'builder.dart';
 import 'type_graph_dump.dart';
 import 'type_graph_inferrer.dart';
 import 'type_graph_nodes.dart';
@@ skipping 585 matching lines @@
       });
     }
     dump?.afterAnalysis();
 
     reporter.log('Inferred $overallRefineCount types.');
 
     processLoopInformation();
   }
 
   /// Call [analyze] for all live members.
-  void analyzeAllElements();
+  void analyzeAllElements() {
+    sortMembers(compiler, 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.');
+  }
+
+  /// Compute a 'size' of [member] used for sorting member for the type
+  /// inference work-queue. Smallest members are processed first.
+  int computeMemberSize(MemberEntity member);
+
+  /// Returns the body node for [member].
+  T computeMemberBody(MemberEntity member);
 
   /// Calls [f] for each parameter of [method].
   void forEachParameter(FunctionEntity method, void f(Local parameter));
 
   /// Returns the `call` method on [cls] or the `noSuchMethod` if [cls] doesn't
   /// implement `call`.
   FunctionEntity lookupCallMethod(ClassEntity cls);
 
   void analyze(MemberEntity element, T body, ArgumentsTypes arguments) {
     assert(!(element is MemberElement && !element.isDeclaration));
@@ skipping 442 matching lines @@
         assert(element.isGetter);
         return returnTypeOfMember(element);
       }
     } else if (element.isGetter || element.isField) {
       assert(selector.isCall || selector.isSetter);
       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)) {
+    Map<int, Set<MemberEntity>> methodSizes =
+        groupMembers(compiler, 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)) {
+    Map<int, Set<MemberEntity>> methodSizes = <int, Set<MemberEntity>>{};
+    compiler.enqueuer.resolution.processedEntities
+        .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;
+  }
 }