Reorganize equivalence test helpers

tests/compiler/dart2js/kernel/closed_world2_test.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.
 
 // Partial test that the closed world computed from [WorldImpact]s derived from
 // kernel is equivalent to the original computed from resolution.
 library dart2js.kernel.closed_world2_test;
 
 import 'dart:async';
 
 import 'package:async_helper/async_helper.dart';
 import 'package:compiler/src/commandline_options.dart';
 import 'package:compiler/src/common.dart';
 import 'package:compiler/src/common_elements.dart';
-import 'package:compiler/src/common/backend_api.dart';
-import 'package:compiler/src/common/tasks.dart';
 import 'package:compiler/src/compiler.dart';
-import 'package:compiler/src/deferred_load.dart';
-import 'package:compiler/src/elements/entities.dart';
 import 'package:compiler/src/elements/resolution_types.dart';
 import 'package:compiler/src/elements/types.dart';
 import 'package:compiler/src/enqueue.dart';
-import 'package:compiler/src/js_backend/backend.dart'
-    hide RuntimeTypesNeedBuilderImpl;
-import 'package:compiler/src/js_backend/backend_impact.dart';
 import 'package:compiler/src/js_backend/backend_usage.dart';
-import 'package:compiler/src/js_backend/custom_elements_analysis.dart';
-import 'package:compiler/src/js_backend/native_data.dart';
-import 'package:compiler/src/js_backend/impact_transformer.dart';
-import 'package:compiler/src/js_backend/interceptor_data.dart';
-import 'package:compiler/src/js_backend/lookup_map_analysis.dart';
-import 'package:compiler/src/js_backend/mirrors_analysis.dart'
-    hide MirrorsResolutionAnalysisImpl;
-import 'package:compiler/src/js_backend/mirrors_data.dart';
-import 'package:compiler/src/js_backend/no_such_method_registry.dart';
-import 'package:compiler/src/js_backend/resolution_listener.dart';
-import 'package:compiler/src/js_backend/type_variable_handler.dart';
-import 'package:compiler/src/native/enqueue.dart';
-import 'package:compiler/src/native/resolver.dart';
 import 'package:compiler/src/kernel/element_map_impl.dart';
 import 'package:compiler/src/kernel/kernel_strategy.dart';
-import 'package:compiler/src/library_loader.dart';
-import 'package:compiler/src/options.dart';
+import 'package:compiler/src/serialization/equivalence.dart';
 import 'package:compiler/src/universe/world_builder.dart';
 import 'package:compiler/src/util/util.dart';
 import 'package:compiler/src/world.dart';
 import 'package:expect/expect.dart';
-import 'package:kernel/ast.dart' as ir;
 import '../memory_compiler.dart';
 import '../serialization/helper.dart';
-import '../serialization/model_test_helper.dart';
-import '../serialization/test_helper.dart';
-
-import 'closed_world_test.dart' hide KernelWorkItemBuilder;
+import '../equivalence/check_functions.dart';
 import 'compiler_helper.dart';
-import 'impact_test.dart';
+import 'test_helpers.dart';
 
 const SOURCE = const {
   'main.dart': '''
 import 'dart:html';
 import 'dart:typed_data';
 import 'package:expect/expect.dart';
 
 class ClassWithSetter {
   void set setter(_) {}
 }
@@ skipping 83 matching lines @@
   Compiler compiler = compilers.a;
   compiler.resolutionWorldBuilder.closeWorld();
   ElementEnvironment environment1 = compiler.elementEnvironment;
 
   Compiler compiler2 = compilers.b;
   KernelFrontEndStrategy frontEndStrategy = compiler2.frontEndStrategy;
   KernelToElementMapImpl elementMap = frontEndStrategy.elementMap;
   Expect.isFalse(compiler2.compilationFailed);
 
   KernelEquivalence equivalence = new KernelEquivalence(elementMap);
+  TestStrategy strategy = equivalence.defaultStrategy;
 
   ElementEnvironment environment2 = compiler2.elementEnvironment;
-  checkElementEnvironment(environment1, environment2, equivalence);
+  checkElementEnvironment(environment1, environment2, strategy);
 
   ResolutionEnqueuer enqueuer2 = compiler2.enqueuer.resolution;
   BackendUsage backendUsage2 = compiler2.backend.backendUsage;
   ClosedWorld closedWorld2 = compiler2.resolutionWorldBuilder.closeWorld();
 
-  checkNativeClasses(compiler1, compiler2, equivalence);
+  checkNativeClasses(compiler1, compiler2, strategy);
 
-  checkBackendUsage(backendUsage1, backendUsage2, equivalence);
+  checkBackendUsage(backendUsage1, backendUsage2, strategy);
 
   checkResolutionEnqueuers(backendUsage1, backendUsage2, enqueuer1, enqueuer2,
       elementEquivalence: equivalence.entityEquivalence,
       typeEquivalence: (ResolutionDartType a, DartType b) {
     return equivalence.typeEquivalence(unalias(a), b);
   }, elementFilter: elementFilter, verbose: arguments.verbose);
 
   checkClosedWorlds(closedWorld1, closedWorld2,
       strategy: equivalence.defaultStrategy, verbose: arguments.verbose);
 
   return ResultKind.success;
 }
-
-void checkNativeClasses(

[Johnni Winther, 2017/05/15 07:43:03]

These were changed to used [TestStrategy] instead of [KernelEquivalence] when
moved to check_function.dart

-    Compiler compiler1, Compiler compiler2, KernelEquivalence equivalence) {
-  Iterable<ClassEntity> nativeClasses1 = compiler1
-      .backend.nativeResolutionEnqueuerForTesting.nativeClassesForTesting;
-  Iterable<ClassEntity> nativeClasses2 = compiler2
-      .backend.nativeResolutionEnqueuerForTesting.nativeClassesForTesting;
-
-  checkSetEquivalence(compiler1, compiler2, 'nativeClasses', nativeClasses1,
-      nativeClasses2, equivalence.entityEquivalence);
-
-  Iterable<ClassEntity> registeredClasses1 = compiler1
-      .backend.nativeResolutionEnqueuerForTesting.registeredClassesForTesting;
-  Iterable<ClassEntity> registeredClasses2 = compiler2
-      .backend.nativeResolutionEnqueuerForTesting.registeredClassesForTesting;
-
-  checkSetEquivalence(compiler1, compiler2, 'registeredClasses',
-      registeredClasses1, registeredClasses2, equivalence.entityEquivalence);
-}
-
-void checkNativeBasicData(NativeBasicDataImpl data1, NativeBasicDataImpl data2,
-    KernelEquivalence equivalence) {
-  checkMapEquivalence(
-      data1,
-      data2,
-      'nativeClassTagInfo',
-      data1.nativeClassTagInfo,
-      data2.nativeClassTagInfo,
-      equivalence.entityEquivalence,
-      (a, b) => a == b);
-  // TODO(johnniwinther): Check the remaining properties.
-}
-
-void checkBackendUsage(BackendUsageImpl usage1, BackendUsageImpl usage2,
-    KernelEquivalence equivalence) {
-  checkSetEquivalence(
-      usage1,
-      usage2,
-      'globalClassDependencies',
-      usage1.globalClassDependencies,
-      usage2.globalClassDependencies,
-      equivalence.entityEquivalence);
-  checkSetEquivalence(
-      usage1,
-      usage2,
-      'globalFunctionDependencies',
-      usage1.globalFunctionDependencies,
-      usage2.globalFunctionDependencies,
-      equivalence.entityEquivalence);
-  checkSetEquivalence(
-      usage1,
-      usage2,
-      'helperClassesUsed',
-      usage1.helperClassesUsed,
-      usage2.helperClassesUsed,
-      equivalence.entityEquivalence);
-  checkSetEquivalence(
-      usage1,
-      usage2,
-      'helperFunctionsUsed',
-      usage1.helperFunctionsUsed,
-      usage2.helperFunctionsUsed,
-      equivalence.entityEquivalence);
-  check(
-      usage1,
-      usage2,
-      'needToInitializeIsolateAffinityTag',
-      usage1.needToInitializeIsolateAffinityTag,
-      usage2.needToInitializeIsolateAffinityTag);
-  check(
-      usage1,
-      usage2,
-      'needToInitializeDispatchProperty',
-      usage1.needToInitializeDispatchProperty,
-      usage2.needToInitializeDispatchProperty);
-  check(usage1, usage2, 'requiresPreamble', usage1.requiresPreamble,
-      usage2.requiresPreamble);
-  check(usage1, usage2, 'isInvokeOnUsed', usage1.isInvokeOnUsed,
-      usage2.isInvokeOnUsed);
-  check(usage1, usage2, 'isRuntimeTypeUsed', usage1.isRuntimeTypeUsed,
-      usage2.isRuntimeTypeUsed);
-  check(usage1, usage2, 'isIsolateInUse', usage1.isIsolateInUse,
-      usage2.isIsolateInUse);
-  check(usage1, usage2, 'isFunctionApplyUsed', usage1.isFunctionApplyUsed,
-      usage2.isFunctionApplyUsed);
-  check(usage1, usage2, 'isNoSuchMethodUsed', usage1.isNoSuchMethodUsed,
-      usage2.isNoSuchMethodUsed);
-}
-
-checkElementEnvironment(ElementEnvironment env1, ElementEnvironment env2,
-    KernelEquivalence equivalence) {
-  checkMembers(MemberEntity member1, MemberEntity member2) {
-    Expect.equals(env1.isDeferredLoadLibraryGetter(member1),
-        env2.isDeferredLoadLibraryGetter(member2));
-
-    checkListEquivalence(
-        member1,
-        member2,
-        'metadata',
-        env1.getMemberMetadata(member1),
-        env2.getMemberMetadata(member2),
-        equivalence.defaultStrategy.testConstantValues);
-  }
-
-  checkSetEquivalence(env1, env2, 'libraries', env1.libraries, env2.libraries,
-      equivalence.entityEquivalence,
-      onSameElement: (LibraryEntity lib1, LibraryEntity lib2) {
-    Expect.identical(lib1, env1.lookupLibrary(lib1.canonicalUri));
-    Expect.identical(lib2, env2.lookupLibrary(lib2.canonicalUri));
-
-    List<ClassEntity> classes2 = <ClassEntity>[];
-    env1.forEachClass(lib1, (ClassEntity cls1) {
-      Expect.identical(cls1, env1.lookupClass(lib1, cls1.name));
-
-      String className = cls1.name;
-      ClassEntity cls2 = env2.lookupClass(lib2, className);
-      Expect.isNotNull(cls2, 'Missing class $className in $lib2');
-      Expect.identical(cls2, env2.lookupClass(lib2, cls2.name));
-
-      check(lib1, lib2, 'class:${className}', cls1, cls2,
-          equivalence.entityEquivalence);
-
-      Expect.equals(env1.isGenericClass(cls1), env2.isGenericClass(cls2));
-
-      check(
-          cls1,
-          cls2,
-          'superclass',
-          env1.getSuperClass(cls1, skipUnnamedMixinApplications: false),
-          env2.getSuperClass(cls2, skipUnnamedMixinApplications: false),
-          equivalence.entityEquivalence);
-      check(
-          cls1,
-          cls2,
-          'superclass',
-          env1.getSuperClass(cls1, skipUnnamedMixinApplications: true),
-          env2.getSuperClass(cls2, skipUnnamedMixinApplications: true),
-          equivalence.entityEquivalence);
-
-      List<InterfaceType> supertypes1 = <InterfaceType>[];
-      env1.forEachSupertype(cls1, supertypes1.add);
-      List<InterfaceType> supertypes2 = <InterfaceType>[];
-      env2.forEachSupertype(cls2, supertypes1.add);
-      equivalence.defaultStrategy
-          .testTypeLists(cls1, cls2, 'supertypes', supertypes1, supertypes2);
-
-      List<ClassEntity> mixins1 = <ClassEntity>[];
-      env1.forEachMixin(cls1, mixins1.add);
-      List<ClassEntity> mixins2 = <ClassEntity>[];
-      env2.forEachMixin(cls2, mixins2.add);
-      equivalence.defaultStrategy.testLists(cls1, cls2, 'mixins', mixins1,
-          mixins2, equivalence.entityEquivalence);
-
-      Map<MemberEntity, ClassEntity> members1 = <MemberEntity, ClassEntity>{};
-      Map<MemberEntity, ClassEntity> members2 = <MemberEntity, ClassEntity>{};
-      env1.forEachClassMember(cls1,
-          (ClassEntity declarer1, MemberEntity member1) {
-        if (cls1 == declarer1) {
-          Expect.identical(
-              member1,
-              env1.lookupClassMember(cls1, member1.name,
-                  setter: member1.isSetter));
-        }
-        members1[member1] = declarer1;
-      });
-      env2.forEachClassMember(cls2,
-          (ClassEntity declarer2, MemberEntity member2) {
-        if (cls2 == declarer2) {
-          Expect.identical(
-              member2,
-              env2.lookupClassMember(cls2, member2.name,
-                  setter: member2.isSetter));
-        }
-        members2[member2] = declarer2;
-      });
-      checkMapEquivalence(cls1, cls2, 'members', members1, members2, (a, b) {
-        bool result = equivalence.entityEquivalence(a, b);
-        if (result) checkMembers(a, b);
-        return result;
-      }, equivalence.entityEquivalence);
-
-      classes2.add(cls2);
-    });
-    env2.forEachClass(lib2, (ClassEntity cls2) {
-      Expect.isTrue(classes2.contains(cls2), "Extra class $cls2 in $lib2");
-    });
-  });
-  // TODO(johnniwinther): Test the remaining properties of [ElementEnvironment].
-}