Implement subtype relation for kernel based elements.

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 'package:async_helper/async_helper.dart';
 import 'package:compiler/src/closure.dart';
@@ skipping 50 matching lines @@
   if (arguments.uri != null) {
     entryPoint = arguments.uri;
     memorySourceFiles = const <String, String>{};
   } else {
     entryPoint = Uri.parse('memory:main.dart');
     memorySourceFiles = SOURCE;
   }
 
   asyncTest(() async {
     enableDebugMode();
+
+    print('---- analyze-only ------------------------------------------------');
+    Compiler compiler1 = compilerFor(
+        entryPoint: entryPoint,
+        memorySourceFiles: memorySourceFiles,
+        options: [Flags.analyzeOnly, Flags.enableAssertMessage]);
+    ElementResolutionWorldBuilder.useInstantiationMap = true;
+    compiler1.resolution.retainCachesForTesting = true;
+    await compiler1.run(entryPoint);
+    ResolutionEnqueuer enqueuer1 = compiler1.enqueuer.resolution;
+    BackendUsage backendUsage1 = compiler1.backend.backendUsage;
+    compiler1.resolutionWorldBuilder.closeWorld();
+
+    print('---- analyze-all -------------------------------------------------');
     Compiler compiler = compilerFor(
         entryPoint: entryPoint,
         memorySourceFiles: memorySourceFiles,
         options: [
           Flags.analyzeAll,
           Flags.useKernel,
           Flags.enableAssertMessage
         ]);
-    ElementResolutionWorldBuilder.useInstantiationMap = true;
-    compiler.resolution.retainCachesForTesting = true;
     await compiler.run(entryPoint);
     compiler.resolutionWorldBuilder.closeWorld();
 
+    print('---- closed world from kernel ------------------------------------');
     KernelWorldBuilder worldBuilder = new KernelWorldBuilder(
         compiler.reporter, compiler.backend.kernelTask.program);
     KernelEquivalence equivalence = new KernelEquivalence(worldBuilder);
     NativeBasicData nativeBasicData = computeNativeBasicData(worldBuilder);
     checkNativeBasicData(
         compiler.backend.nativeBasicData, nativeBasicData, equivalence);
     List list = createKernelResolutionEnqueuerListener(
         compiler.options,
         compiler.reporter,
         compiler.deferredLoadTask,
         worldBuilder,
         nativeBasicData);
     ResolutionEnqueuerListener resolutionEnqueuerListener = list[0];
-    ImpactTransformer impactTransformer = list[1];
-    ResolutionEnqueuer enqueuer = new ResolutionEnqueuer(
+    BackendUsageBuilder backendUsageBuilder2 = list[1];
+    ImpactTransformer impactTransformer = list[2];
+    ResolutionEnqueuer enqueuer2 = new ResolutionEnqueuer(
         compiler.enqueuer,
         compiler.options,
         compiler.reporter,
         const TreeShakingEnqueuerStrategy(),
         resolutionEnqueuerListener,
         new KernelResolutionWorldBuilder(
             worldBuilder.elementEnvironment,
             worldBuilder.commonElements,
             nativeBasicData,
             const OpenWorldStrategy()),
         new KernelWorkItemBuilder(worldBuilder, impactTransformer),
         'enqueuer from kelements');
-
     computeClosedWorld(
-        compiler.reporter, enqueuer, worldBuilder.elementEnvironment);
+        compiler.reporter, enqueuer2, worldBuilder.elementEnvironment);
+    BackendUsage backendUsage2 = backendUsageBuilder2.close();
+    checkBackendUsage(backendUsage1, backendUsage2, equivalence);
   });
 }
 
 List createKernelResolutionEnqueuerListener(
     CompilerOptions options,
     DiagnosticReporter reporter,
     DeferredLoadTask deferredLoadTask,
     KernelWorldBuilder worldBuilder,
     NativeBasicData nativeBasicData) {
   ElementEnvironment elementEnvironment = worldBuilder.elementEnvironment;
@@ skipping 44 matching lines @@
       options,
       elementEnvironment,
       commonElements,
       impacts,
       nativeBasicData,
       nativeResolutionEnqueuer,
       backendUsageBuilder,
       mirrorsDataBuilder,
       customElementsResolutionAnalysis,
       rtiNeedBuilder);
-  return [listener, transformer];
+  return [listener, backendUsageBuilder, transformer];
 }
 
 class RuntimeTypesNeedBuilderImpl implements RuntimeTypesNeedBuilder {
   @override
   void registerClassUsingTypeVariableExpression(ClassEntity cls) {}
 
   @override
   RuntimeTypesNeed computeRuntimeTypesNeed(
       ResolutionWorldBuilder resolutionWorldBuilder,
       ClosedWorld closedWorld,
@@ skipping 96 matching lines @@
 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);
+}