Add createKernelResolutionEnqueuerListener to kernel/closed_world_test

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';
 import 'package:compiler/src/common.dart';
+import 'package:compiler/src/common_elements.dart';
 import 'package:compiler/src/common/resolution.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/elements/resolution_types.dart';
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/enqueue.dart';
 import 'package:compiler/src/js_backend/backend.dart';
+import 'package:compiler/src/js_backend/backend_helpers.dart';
+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/interceptor_data.dart';
+import 'package:compiler/src/js_backend/lookup_map_analysis.dart';
+import 'package:compiler/src/js_backend/mirrors_analysis.dart';
+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/js_backend/resolution_listener.dart';
+import 'package:compiler/src/native/enqueue.dart';
+import 'package:compiler/src/kernel/world_builder.dart';
+import 'package:compiler/src/options.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';
 
@@ skipping 88 matching lines @@
     }, verbose: arguments.verbose);
     checkClosedWorlds(
         compiler.resolutionWorldBuilder.closedWorldForTesting, closedWorld,
         verbose: arguments.verbose);
   });
 }
 
 EnqueuerListener createResolutionEnqueuerListener(Compiler compiler) {
   JavaScriptBackend backend = compiler.backend;
   return new ResolutionEnqueuerListener(
-      backend.kernelTask,
       compiler.options,
       compiler.elementEnvironment,
       compiler.commonElements,
       backend.helpers,
       backend.impacts,
       backend.backendClasses,
       backend.nativeBasicData,
       backend.interceptorDataBuilder,
       backend.backendUsageBuilder,
       backend.rtiNeedBuilder,
       backend.mirrorsDataBuilder,
       backend.noSuchMethodRegistry,
       backend.customElementsResolutionAnalysis,
       backend.lookupMapResolutionAnalysis,
       backend.mirrorsResolutionAnalysis,
       new TypeVariableResolutionAnalysis(compiler.elementEnvironment,
           backend.impacts, backend.backendUsageBuilder),
-      backend.nativeResolutionEnqueuer);
+      backend.nativeResolutionEnqueuer,
+      backend.kernelTask);
+}
+
+EnqueuerListener createKernelResolutionEnqueuerListener(
+    CompilerOptions options, KernelWorldBuilder worldBuilder) {
+  ElementEnvironment elementEnvironment = worldBuilder.elementEnvironment;
+  CommonElements commonElements = worldBuilder.commonElements;
+  BackendHelpers helpers =
+      new BackendHelpers(elementEnvironment, commonElements);
+  BackendImpacts impacts = new BackendImpacts(options, commonElements, helpers);
+
+  // TODO(johnniwinther): Create Kernel based implementations for these:
+  NativeBasicData nativeBasicData;
+  InterceptorDataBuilder interceptorDataBuilder;
+  BackendUsageBuilder backendUsageBuilder;
+  RuntimeTypesNeedBuilder rtiNeedBuilder;
+  MirrorsDataBuilder mirrorsDataBuilder;
+  NoSuchMethodRegistry noSuchMethodRegistry;
+  CustomElementsResolutionAnalysis customElementsResolutionAnalysis;
+  LookupMapResolutionAnalysis lookupMapResolutionAnalysis;
+  MirrorsResolutionAnalysis mirrorsResolutionAnalysis;
+  NativeResolutionEnqueuer nativeResolutionEnqueuer;
+
+  return new ResolutionEnqueuerListener(
+      options,
+      elementEnvironment,
+      commonElements,
+      helpers,
+      impacts,
+      new JavaScriptBackendClasses(
+          elementEnvironment, helpers, nativeBasicData),
+      nativeBasicData,
+      interceptorDataBuilder,
+      backendUsageBuilder,
+      rtiNeedBuilder,
+      mirrorsDataBuilder,
+      noSuchMethodRegistry,
+      customElementsResolutionAnalysis,
+      lookupMapResolutionAnalysis,
+      mirrorsResolutionAnalysis,
+      new TypeVariableResolutionAnalysis(
+          elementEnvironment, impacts, backendUsageBuilder),
+      nativeResolutionEnqueuer);
 }
 
 ClosedWorld computeClosedWorld(Compiler compiler, ResolutionEnqueuer enqueuer) {
   JavaScriptBackend backend = compiler.backend;
 
   if (compiler.deferredLoadTask.isProgramSplit) {
     enqueuer.applyImpact(backend.computeDeferredLoadingImpact());
   }
   enqueuer.open(const ImpactStrategy(), compiler.mainFunction,
       compiler.libraryLoader.libraries);
   enqueuer.forEach((work) {
     MemberElement element = work.element;
     ResolutionImpact resolutionImpact = build(compiler, element.resolvedAst);
     WorldImpact worldImpact = compiler.backend.impactTransformer
         .transformResolutionImpact(enqueuer, resolutionImpact);
     enqueuer.applyImpact(worldImpact, impactSource: element);
   });
   return enqueuer.worldBuilder.closeWorld(compiler.reporter);
 }