Split backend implementation of EnqueuerListener

tests/compiler/dart2js/serialization/model_test_helper.dart

 // Copyright (c) 2015, 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.
 
 library dart2js.serialization_model_test;
 
 import 'dart:async';
 import 'dart:io';
 import 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
 import 'package:compiler/src/closure.dart';
 import 'package:compiler/src/commandline_options.dart';
 import 'package:compiler/src/common.dart';
 import 'package:compiler/src/constants/values.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/elements/resolution_types.dart';
 import 'package:compiler/src/deferred_load.dart';
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/elements/entities.dart';
 import 'package:compiler/src/enqueue.dart';
 import 'package:compiler/src/filenames.dart';
 import 'package:compiler/src/js_backend/js_backend.dart';
+import 'package:compiler/src/js_backend/backend_usage.dart';
 import 'package:compiler/src/serialization/equivalence.dart';
 import 'package:compiler/src/tree/nodes.dart';
 import 'package:compiler/src/universe/class_set.dart';
 import 'package:compiler/src/universe/world_builder.dart';
 import 'package:compiler/src/util/enumset.dart';
 import 'package:compiler/src/world.dart' show ClosedWorld;
 import '../memory_compiler.dart';
 import 'helper.dart';
 import 'test_data.dart';
 import 'test_helper.dart';
@@ skipping 57 matching lines @@
         options: [Flags.analyzeOnly]);
     compilerDeserialized.resolution.retainCachesForTesting = true;
     await compilerDeserialized.run(entryPoint);
     compilerDeserialized.closeResolution();
     return compilerDeserialized;
   });
 
   return measure(title, 'check models', () async {
     checkAllImpacts(compilerNormal, compilerDeserialized, verbose: verbose);
     checkResolutionEnqueuers(
-        compilerNormal.backend,
-        compilerDeserialized.backend,
+        compilerNormal.backend.backendUsage,
+        compilerDeserialized.backend.backendUsage,
         compilerNormal.enqueuer.resolution,
         compilerDeserialized.enqueuer.resolution,
         verbose: verbose);
     checkClosedWorlds(
         compilerNormal.resolutionWorldBuilder.closedWorldForTesting,
         compilerDeserialized.resolutionWorldBuilder.closedWorldForTesting,
         verbose: verbose);
     checkBackendInfo(compilerNormal, compilerDeserialized, verbose: verbose);
   });
 }
 
 void checkResolutionEnqueuers(
-    JavaScriptBackend backend1,
-    JavaScriptBackend backend2,
+    BackendUsage backendUsage1,
+    BackendUsage backendUsage2,
     ResolutionEnqueuer enqueuer1,
     ResolutionEnqueuer enqueuer2,
     {bool typeEquivalence(ResolutionDartType a, ResolutionDartType b):
         areTypesEquivalent,
     bool elementFilter(Element element),
     bool verbose: false}) {
   checkSets(enqueuer1.processedEntities, enqueuer2.processedEntities,
       "Processed element mismatch", areElementsEquivalent,
       elementFilter: elementFilter, verbose: verbose);
 
@@ skipping 19 matching lines @@
       enqueuer1.worldBuilder.instantiatedTypes,
       enqueuer2.worldBuilder.instantiatedTypes,
       "Instantiated types mismatch",
       typeEquivalence,
       verbose: verbose);
 
   checkSets(enqueuer1.worldBuilder.isChecks, enqueuer2.worldBuilder.isChecks,
       "Is-check mismatch", typeEquivalence,
       verbose: verbose);
 
-  Expect.equals(backend1.hasInvokeOnSupport, backend2.hasInvokeOnSupport,
+  Expect.equals(backendUsage1.isInvokeOnUsed, backendUsage2.isInvokeOnUsed,
       "JavaScriptBackend.hasInvokeOnSupport mismatch");
   Expect.equals(
-      backend1.hasFunctionApplySupport,
-      backend2.hasFunctionApplySupport,
+      backendUsage1.isFunctionApplyUsed,
+      backendUsage1.isFunctionApplyUsed,
       "JavaScriptBackend.hasFunctionApplySupport mismatch");
-  Expect.equals(backend1.hasRuntimeTypeSupport, backend2.hasRuntimeTypeSupport,
+  Expect.equals(
+      backendUsage1.isRuntimeTypeUsed,
+      backendUsage2.isRuntimeTypeUsed,
       "JavaScriptBackend.hasRuntimeTypeSupport mismatch");
-  Expect.equals(backend1.hasIsolateSupport, backend2.hasIsolateSupport,
+  Expect.equals(backendUsage1.isIsolateInUse, backendUsage2.isIsolateInUse,
       "JavaScriptBackend.hasIsolateSupport mismatch");
 }
 
 void checkClosedWorlds(ClosedWorld closedWorld1, ClosedWorld closedWorld2,
     {bool verbose: false}) {
   checkClassHierarchyNodes(
       closedWorld1,
       closedWorld2,
       closedWorld1
           .getClassHierarchyNode(closedWorld1.commonElements.objectClass),
@@ skipping 271 matching lines @@
           a, b, (a, b) => areInstancesEquivalent(a, b, typeEquivalence)));
   return true;
 }
 
 bool areInstancesEquivalent(Instance instance1, Instance instance2,
     bool typeEquivalence(ResolutionDartType a, ResolutionDartType b)) {
   return typeEquivalence(instance1.type, instance2.type) &&
       instance1.kind == instance2.kind &&
       instance1.isRedirection == instance2.isRedirection;
 }