Add kernel/closed_world2_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/closure.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/resolution.dart';
+import 'package:compiler/src/common/work.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/deferred_load.dart';
 import 'package:compiler/src/elements/resolution_types.dart';
 import 'package:compiler/src/elements/elements.dart';
+import 'package:compiler/src/elements/entities.dart';
+import 'package:compiler/src/elements/types.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/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';
 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/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 'package:kernel/ast.dart' as ir;
 import 'impact_test.dart';
 import '../memory_compiler.dart';
 import '../serialization/helper.dart';
 import '../serialization/model_test_helper.dart';
 
 const SOURCE = const {
   'main.dart': '''
 abstract class A {
   // redirecting factory in abstract class to other class
   factory A.a() = D.a;
@@ skipping 50 matching lines @@
     // Create a new resolution enqueuer and feed it with the [WorldImpact]s
     // computed from kernel through the [build] in `kernel_impact.dart`.
     ResolutionEnqueuer enqueuer = new ResolutionEnqueuer(
         compiler.enqueuer,
         compiler.options,
         compiler.reporter,
         const TreeShakingEnqueuerStrategy(),
         createResolutionEnqueuerListener(compiler),
         new ElementResolutionWorldBuilder(
             backend, compiler.resolution, const OpenWorldStrategy()),
-        new ResolutionWorkItemBuilder(compiler.resolution),
+        new KernelWorkItemBuilder(compiler),
         'enqueuer from kernel');
-    ClosedWorld closedWorld = computeClosedWorld(compiler, enqueuer);
+    ClosedWorld closedWorld = computeClosedWorld(
+        compiler.reporter, enqueuer, compiler.elementEnvironment);
     BackendUsage backendUsage = compiler.backend.backendUsageBuilder.close();
     checkResolutionEnqueuers(
         backendUsage, backendUsage, compiler.enqueuer.resolution, enqueuer,
         typeEquivalence: (ResolutionDartType a, ResolutionDartType b) {
       return areTypesEquivalent(unalias(a), unalias(b));
     }, elementFilter: (Element element) {
       if (element is ConstructorElement && element.isRedirectingFactory) {
         // Redirecting factory constructors are skipped in kernel.
         return false;
       }
@@ skipping 32 matching lines @@
       backend.customElementsResolutionAnalysis,
       backend.lookupMapResolutionAnalysis,
       backend.mirrorsResolutionAnalysis,
       new TypeVariableResolutionAnalysis(compiler.elementEnvironment,
           backend.impacts, backend.backendUsageBuilder),
       backend.nativeResolutionEnqueuer,
       compiler.deferredLoadTask,
       backend.kernelTask);
 }
 
-EnqueuerListener createKernelResolutionEnqueuerListener(CompilerOptions options,
-    DeferredLoadTask deferredLoadTask, 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;
-  RuntimeTypesNeedBuilder rtiNeedBuilder;
-  MirrorsDataBuilder mirrorsDataBuilder;
-  CustomElementsResolutionAnalysis customElementsResolutionAnalysis;
-  LookupMapResolutionAnalysis lookupMapResolutionAnalysis;
-  MirrorsResolutionAnalysis mirrorsResolutionAnalysis;
-
-  BackendClasses backendClasses = new JavaScriptBackendClasses(
-      elementEnvironment, helpers, nativeBasicData);
-  InterceptorDataBuilder interceptorDataBuilder =
-      new InterceptorDataBuilderImpl(
-          nativeBasicData, helpers, elementEnvironment, commonElements);
-  BackendUsageBuilder backendUsageBuilder =
-      new BackendUsageBuilderImpl(commonElements, helpers);
-  NoSuchMethodRegistry noSuchMethodRegistry = new NoSuchMethodRegistry(
-      helpers, new KernelNoSuchMethodResolver(worldBuilder));
-  NativeResolutionEnqueuer nativeResolutionEnqueuer =
-      new NativeResolutionEnqueuer(
-          options,
-          elementEnvironment,
-          commonElements,
-          helpers,
-          backendClasses,
-          backendUsageBuilder,
-          new KernelNativeClassResolver(worldBuilder));
-
-  return new ResolutionEnqueuerListener(
-      options,
-      elementEnvironment,
-      commonElements,
-      helpers,
-      impacts,
-      backendClasses,
-      nativeBasicData,
-      interceptorDataBuilder,
-      backendUsageBuilder,
-      rtiNeedBuilder,
-      mirrorsDataBuilder,
-      noSuchMethodRegistry,
-      customElementsResolutionAnalysis,
-      lookupMapResolutionAnalysis,
-      mirrorsResolutionAnalysis,
-      new TypeVariableResolutionAnalysis(
-          elementEnvironment, impacts, backendUsageBuilder),
-      nativeResolutionEnqueuer,
-      deferredLoadTask);
+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(reporter);
 }
 
-ClosedWorld computeClosedWorld(Compiler compiler, ResolutionEnqueuer enqueuer) {
-  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);
+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);
+  }
+}