Reorganize equivalence test helpers

tests/compiler/dart2js/kernel/closed_world_test.dart

 // Copyright (c) 2016, 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.
 
 // Tests that the closed world computed from [WorldImpact]s derived from kernel
 // is equivalent to the original computed from resolution.
 library dart2js.kernel.closed_world_test;
 
 import 'package:async_helper/async_helper.dart';
 import 'package:compiler/src/commandline_options.dart';
@@ skipping 14 matching lines @@
 import 'package:compiler/src/js_backend/type_variable_handler.dart';
 import 'package:compiler/src/ssa/kernel_impact.dart';
 import 'package:compiler/src/serialization/equivalence.dart';
 import 'package:compiler/src/universe/world_builder.dart';
 import 'package:compiler/src/universe/world_impact.dart';
 import 'package:compiler/src/world.dart';
 import 'impact_test.dart';
 import '../memory_compiler.dart';
 import '../serialization/helper.dart';
 import '../serialization/model_test_helper.dart';
+import '../equivalence/check_functions.dart';
+import 'test_helpers.dart';
 
 const SOURCE = const {
   'main.dart': '''
 abstract class A {
   // redirecting factory in abstract class to other class
   factory A.a() = D.a;
   // redirecting factory in abstract class to factory in abstract class
   factory A.b() = B.a;
 }
 abstract class B implements A {
@@ skipping 55 matching lines @@
         compiler.reporter,
         const TreeShakingEnqueuerStrategy(),
         resolutionEnqueuerListener,
         new ElementResolutionWorldBuilder(
             backend,
             compiler.resolution,
             backend.nativeBasicData,
             backend.nativeDataBuilder,
             interceptorDataBuilder,
             const OpenWorldStrategy()),
-        new KernelWorkItemBuilder(compiler),
+        new KernelTestWorkItemBuilder(compiler),
         'enqueuer from kernel');
     ClosedWorld closedWorld = computeClosedWorld(
         compiler.reporter, enqueuer, compiler.elementEnvironment);
     BackendUsage backendUsage = backendUsageBuilder.close();
     checkResolutionEnqueuers(
         backendUsage, backendUsage, compiler.enqueuer.resolution, enqueuer,
         typeEquivalence: (ResolutionDartType a, ResolutionDartType b) {
       return areTypesEquivalent(unalias(a), unalias(b));
     }, elementFilter: elementFilter, verbose: arguments.verbose);
     checkClosedWorlds(
         compiler.resolutionWorldBuilder.closedWorldForTesting, closedWorld,
         verbose: arguments.verbose);
   });
 }
 
-bool elementFilter(Entity element) {
-  if (element is ConstructorElement && element.isRedirectingFactory) {
-    // Redirecting factory constructors are skipped in kernel.
-    return false;
-  }
-  if (element is ClassElement) {
-    for (ConstructorElement constructor in element.constructors) {
-      if (!constructor.isRedirectingFactory) {
-        return true;
-      }
-    }
-    // The class cannot itself be instantiated.
-    return false;
-  }
-  return true;
-}
-
 List createResolutionEnqueuerListener(Compiler compiler) {
   JavaScriptBackend backend = compiler.backend;
   BackendUsageBuilder backendUsageBuilder =
       new BackendUsageBuilderImpl(compiler.commonElements);
   InterceptorDataBuilder interceptorDataBuilder =
       new InterceptorDataBuilderImpl(backend.nativeBasicData,
           compiler.elementEnvironment, compiler.commonElements);
   ResolutionEnqueuerListener listener = new ResolutionEnqueuerListener(
       compiler.options,
       compiler.elementEnvironment,
@@ skipping 18 matching lines @@
 
 ClosedWorld computeClosedWorld(DiagnosticReporter reporter,
     ResolutionEnqueuer enqueuer, ElementEnvironment elementEnvironment) {
   enqueuer.open(const ImpactStrategy(), elementEnvironment.mainFunction,
       elementEnvironment.libraries);
   enqueuer.forEach((WorkItem work) {
     enqueuer.applyImpact(work.run(), impactSource: work.element);
   });
   return enqueuer.worldBuilder.closeWorld();
 }
-
-class KernelWorkItemBuilder implements WorkItemBuilder {
-  final Compiler _compiler;
-
-  KernelWorkItemBuilder(this._compiler);
-
-  @override
-  WorkItem createWorkItem(MemberEntity entity) {
-    return new KernelWorkItem(
-        _compiler, _compiler.backend.impactTransformer, entity);
-  }
-}
-
-class KernelWorkItem implements ResolutionWorkItem {
-  final Compiler _compiler;
-  final ImpactTransformer _impactTransformer;
-  final MemberElement element;
-
-  KernelWorkItem(this._compiler, this._impactTransformer, this.element);
-
-  @override
-  WorldImpact run() {
-    ResolutionImpact resolutionImpact = build(_compiler, element.resolvedAst);
-    return _impactTransformer.transformResolutionImpact(resolutionImpact);
-  }
-}