Assert that we don't mix K and J elements

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/work.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/enqueue.dart';
 import 'package:compiler/src/js_backend/backend.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/interceptor_data.dart';
 import 'package:compiler/src/js_backend/resolution_listener.dart';
+import 'package:compiler/src/js_backend/runtime_types.dart';
 import 'package:compiler/src/js_backend/type_variable_handler.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 '../memory_compiler.dart';
 import '../serialization/helper.dart';
 import '../equivalence/check_functions.dart';
 import 'test_helpers.dart';
 
@@ skipping 51 matching lines @@
     await compiler.run(entryPoint);
     compiler.resolutionWorldBuilder.closeWorld();
 
     JavaScriptBackend backend = compiler.backend;
     // Create a new resolution enqueuer and feed it with the [WorldImpact]s
     // computed from kernel through the [build] in `kernel_impact.dart`.
     List list = createResolutionEnqueuerListener(compiler);
     ResolutionEnqueuerListener resolutionEnqueuerListener = list[0];
     BackendUsageBuilder backendUsageBuilder = list[1];
     InterceptorDataBuilder interceptorDataBuilder = list[2];
+    RuntimeTypesNeedBuilder rtiNeedBuilder = list[3];
     ResolutionEnqueuer enqueuer = new ResolutionEnqueuer(
         compiler.enqueuer,
         compiler.options,
         compiler.reporter,
         const TreeShakingEnqueuerStrategy(),
         resolutionEnqueuerListener,
         new ElementResolutionWorldBuilder(
             backend,
             compiler.resolution,
-            backend.nativeBasicData,
+            compiler.frontendStrategy.nativeBasicData,
             backend.nativeDataBuilder,
             interceptorDataBuilder,
             backendUsageBuilder,
+            rtiNeedBuilder,
+            backend.nativeResolutionEnqueuerForTesting,
             const OpenWorldStrategy()),
         new KernelTestWorkItemBuilder(compiler),
         'enqueuer from kernel');
     ClosedWorld closedWorld = computeClosedWorld(compiler.reporter, enqueuer,
         compiler.frontendStrategy.elementEnvironment);
     BackendUsage backendUsage = backendUsageBuilder.close();
     checkResolutionEnqueuers(
         backendUsage, backendUsage, compiler.enqueuer.resolution, enqueuer,
         typeEquivalence: (a, b) => areTypesEquivalent(unalias(a), unalias(b)),
         elementFilter: elementFilter,
         verbose: arguments.verbose,
         // TODO(johnniwinther): Support class usage testing in presence of
         // redirecting constructors.
         skipClassUsageTesting: true);
     checkClosedWorlds(
         compiler.resolutionWorldBuilder.closedWorldForTesting, closedWorld,
         verbose: arguments.verbose);
   });
 }
 
 List createResolutionEnqueuerListener(Compiler compiler) {
   JavaScriptBackend backend = compiler.backend;
   BackendUsageBuilder backendUsageBuilder =
       new BackendUsageBuilderImpl(compiler.frontendStrategy.commonElements);
   InterceptorDataBuilder interceptorDataBuilder =
       new InterceptorDataBuilderImpl(
-          backend.nativeBasicData,
+          compiler.frontendStrategy.nativeBasicData,
           compiler.frontendStrategy.elementEnvironment,
           compiler.frontendStrategy.commonElements);
+  RuntimeTypesNeedBuilder rtiNeedBuilder =
+      compiler.frontendStrategy.createRuntimeTypesNeedBuilder();
+  BackendImpacts impacts = new BackendImpacts(
+      compiler.options, compiler.frontendStrategy.commonElements);
   ResolutionEnqueuerListener listener = new ResolutionEnqueuerListener(
       compiler.options,
       compiler.frontendStrategy.elementEnvironment,
       compiler.frontendStrategy.commonElements,
-      backend.impacts,
-      backend.nativeBasicData,
+      impacts,
+      compiler.frontendStrategy.nativeBasicData,
       interceptorDataBuilder,
       backendUsageBuilder,
-      backend.rtiNeedBuilder,
+      rtiNeedBuilder,
       backend.mirrorsDataBuilder,
       backend.noSuchMethodRegistry,
       backend.customElementsResolutionAnalysis,
       backend.lookupMapResolutionAnalysis,
       backend.mirrorsResolutionAnalysis,
       new TypeVariableResolutionAnalysis(
           compiler.frontendStrategy.elementEnvironment,
-          backend.impacts,
+          impacts,
           backendUsageBuilder),
       backend.nativeResolutionEnqueuerForTesting,
       compiler.deferredLoadTask,
       backend.kernelTask);
-  return [listener, backendUsageBuilder, interceptorDataBuilder];
+  return [
+    listener,
+    backendUsageBuilder,
+    interceptorDataBuilder,
+    rtiNeedBuilder
+  ];
 }
 
 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();
 }