Add model test of CodegenWorldBuilder to compile_from_dill_test

tests/compiler/dart2js/equivalence/check_functions.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.
 
 /// Equivalence test functions for data objects.
 
 library dart2js.equivalence.functions;
 
 import 'package:expect/expect.dart';
 import 'package:compiler/src/common/resolution.dart';
 import 'package:compiler/src/common_elements.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/elements/types.dart';
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/elements/entities.dart';
 import 'package:compiler/src/enqueue.dart';
 import 'package:compiler/src/js_backend/backend_usage.dart';
+import 'package:compiler/src/js_backend/enqueuer.dart';
 import 'package:compiler/src/js_backend/native_data.dart';
 import 'package:compiler/src/js_backend/interceptor_data.dart';
 import 'package:compiler/src/serialization/equivalence.dart';
 import 'package:compiler/src/universe/class_set.dart';
 import 'package:compiler/src/universe/world_builder.dart';
 import 'package:compiler/src/world.dart';
 import 'check_helpers.dart';
 
 void checkClosedWorlds(ClosedWorld closedWorld1, ClosedWorld closedWorld2,
     {TestStrategy strategy: const TestStrategy(),
@@ skipping 580 matching lines @@
 
 bool areInstancesEquivalent(Instance instance1, Instance instance2,
     bool typeEquivalence(DartType a, DartType b)) {
   InterfaceType type1 = instance1.type;
   InterfaceType type2 = instance2.type;
   return typeEquivalence(type1, type2) &&
       instance1.kind == instance2.kind &&
       instance1.isRedirection == instance2.isRedirection;
 }
 
+bool areAbstractUsagesEquivalent(AbstractUsage usage1, AbstractUsage usage2) {
+  return usage1.hasSameUsage(usage2);
+}
+
 void checkResolutionEnqueuers(
     BackendUsage backendUsage1,
     BackendUsage backendUsage2,
     ResolutionEnqueuer enqueuer1,
     ResolutionEnqueuer enqueuer2,
     {bool elementEquivalence(Entity a, Entity b): areElementsEquivalent,
     bool typeEquivalence(DartType a, DartType b): areTypesEquivalent,
     bool elementFilter(Element element),
-    bool verbose: false}) {
+    bool verbose: false,
+    bool skipClassUsageTesting: false}) {
+  elementFilter ??= (_) => true;
+
   ResolutionWorldBuilderBase worldBuilder1 = enqueuer1.worldBuilder;
   ResolutionWorldBuilderBase worldBuilder2 = enqueuer2.worldBuilder;
 
-  checkSets(
-      enqueuer1.worldBuilder.instantiatedTypes,
-      enqueuer2.worldBuilder.instantiatedTypes,
-      "Instantiated types mismatch",
-      typeEquivalence,
+  checkSets(worldBuilder1.instantiatedTypes, worldBuilder2.instantiatedTypes,
+      "Instantiated types mismatch", typeEquivalence,
       verbose: verbose);
 
   checkSets(
-      enqueuer1.worldBuilder.directlyInstantiatedClasses,
-      enqueuer2.worldBuilder.directlyInstantiatedClasses,
+      worldBuilder1.directlyInstantiatedClasses,
+      worldBuilder2.directlyInstantiatedClasses,
       "Directly instantiated classes mismatch",
       elementEquivalence,
       verbose: verbose);
 
   checkMaps(
       worldBuilder1.getInstantiationMap(),
       worldBuilder2.getInstantiationMap(),
       "Instantiated classes mismatch",
       elementEquivalence,
       (a, b) => areInstantiationInfosEquivalent(
           a, b, elementEquivalence, typeEquivalence),
       verbose: verbose);
 
   checkSets(enqueuer1.processedEntities, enqueuer2.processedEntities,
-      "Processed element mismatch", elementEquivalence, elementFilter: (e) {
-    return elementFilter != null ? elementFilter(e) : true;
-  }, verbose: verbose);
+      "Processed element mismatch", elementEquivalence,
+      elementFilter: elementFilter, verbose: verbose);
 
-  checkSets(enqueuer1.worldBuilder.isChecks, enqueuer2.worldBuilder.isChecks,
-      "Is-check mismatch", typeEquivalence,
+  checkSets(worldBuilder1.isChecks, worldBuilder2.isChecks, "Is-check mismatch",
+      typeEquivalence,
+      verbose: verbose);
+
+  checkSets(worldBuilder1.closurizedMembers, worldBuilder2.closurizedMembers,
+      "closurizedMembers", elementEquivalence,
+      verbose: verbose);
+  checkSets(worldBuilder1.fieldSetters, worldBuilder2.fieldSetters,
+      "fieldSetters", elementEquivalence,
+      verbose: verbose);
+  checkSets(
+      worldBuilder1.methodsNeedingSuperGetter,
+      worldBuilder2.methodsNeedingSuperGetter,
+      "methodsNeedingSuperGetter",
+      elementEquivalence,
+      verbose: verbose);
+
+  if (!skipClassUsageTesting) {
+    checkMaps(
+        worldBuilder1.classUsageForTesting,
+        worldBuilder2.classUsageForTesting,
+        'classUsageForTesting',
+        elementEquivalence,
+        areAbstractUsagesEquivalent,
+        verbose: verbose);
+  }
+  checkMaps(
+      worldBuilder1.staticMemberUsageForTesting,
+      worldBuilder2.staticMemberUsageForTesting,
+      'staticMemberUsageForTesting',
+      elementEquivalence,
+      areAbstractUsagesEquivalent,
+      keyFilter: elementFilter,
+      verbose: verbose);
+  checkMaps(
+      worldBuilder1.instanceMemberUsageForTesting,
+      worldBuilder2.instanceMemberUsageForTesting,
+      'instanceMemberUsageForTesting',
+      elementEquivalence,
+      areAbstractUsagesEquivalent,
       verbose: verbose);
 
   Expect.equals(backendUsage1.isInvokeOnUsed, backendUsage2.isInvokeOnUsed,
       "JavaScriptBackend.hasInvokeOnSupport mismatch");
   Expect.equals(
       backendUsage1.isFunctionApplyUsed,
       backendUsage1.isFunctionApplyUsed,
       "JavaScriptBackend.hasFunctionApplySupport mismatch");
   Expect.equals(
       backendUsage1.isRuntimeTypeUsed,
       backendUsage2.isRuntimeTypeUsed,
       "JavaScriptBackend.hasRuntimeTypeSupport mismatch");
   Expect.equals(backendUsage1.isIsolateInUse, backendUsage2.isIsolateInUse,
       "JavaScriptBackend.hasIsolateSupport mismatch");
 }
+
+void checkCodegenEnqueuers(CodegenEnqueuer enqueuer1, CodegenEnqueuer enqueuer2,
+    {bool elementEquivalence(Entity a, Entity b): areElementsEquivalent,
+    bool typeEquivalence(DartType a, DartType b): areTypesEquivalent,
+    bool elementFilter(Element element),
+    bool verbose: false}) {
+  CodegenWorldBuilderImpl worldBuilder1 = enqueuer1.worldBuilder;
+  CodegenWorldBuilderImpl worldBuilder2 = enqueuer2.worldBuilder;
+
+  checkSets(worldBuilder1.instantiatedTypes, worldBuilder2.instantiatedTypes,
+      "Instantiated types mismatch", typeEquivalence,
+      verbose: verbose);
+
+  checkSets(
+      worldBuilder1.directlyInstantiatedClasses,
+      worldBuilder2.directlyInstantiatedClasses,
+      "Directly instantiated classes mismatch",
+      elementEquivalence,
+      verbose: verbose);
+
+  checkSets(enqueuer1.processedEntities, enqueuer2.processedEntities,
+      "Processed element mismatch", elementEquivalence, elementFilter: (e) {
+    return elementFilter != null ? elementFilter(e) : true;
+  }, verbose: verbose);
+
+  checkSets(worldBuilder1.isChecks, worldBuilder2.isChecks, "Is-check mismatch",
+      typeEquivalence,
+      verbose: verbose);
+
+  checkSets(
+      worldBuilder1.allReferencedStaticFields,
+      worldBuilder2.allReferencedStaticFields,
+      "Directly instantiated classes mismatch",
+      elementEquivalence,
+      verbose: verbose);
+  checkSets(worldBuilder1.closurizedMembers, worldBuilder2.closurizedMembers,
+      "closurizedMembers", elementEquivalence,
+      verbose: verbose);
+  checkSets(worldBuilder1.processedClasses, worldBuilder2.processedClasses,
+      "processedClasses", elementEquivalence,
+      verbose: verbose);
+  checkSets(
+      worldBuilder1.methodsNeedingSuperGetter,
+      worldBuilder2.methodsNeedingSuperGetter,
+      "methodsNeedingSuperGetter",
+      elementEquivalence,
+      verbose: verbose);
+  checkSets(
+      worldBuilder1.staticFunctionsNeedingGetter,
+      worldBuilder2.staticFunctionsNeedingGetter,
+      "staticFunctionsNeedingGetter",
+      elementEquivalence,
+      verbose: verbose);
+
+  checkMaps(
+      worldBuilder1.classUsageForTesting,
+      worldBuilder2.classUsageForTesting,
+      'classUsageForTesting',
+      elementEquivalence,
+      areAbstractUsagesEquivalent,
+      verbose: verbose);
+  checkMaps(
+      worldBuilder1.staticMemberUsageForTesting,
+      worldBuilder2.staticMemberUsageForTesting,
+      'staticMemberUsageForTesting',
+      elementEquivalence,
+      areAbstractUsagesEquivalent,
+      verbose: verbose);
+  checkMaps(
+      worldBuilder1.instanceMemberUsageForTesting,
+      worldBuilder2.instanceMemberUsageForTesting,
+      'instanceMemberUsageForTesting',
+      elementEquivalence,
+      areAbstractUsagesEquivalent,
+      verbose: verbose);
+}