Split backend implementation of EnqueuerListener

pkg/compiler/lib/src/js_backend/backend_usage.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.
 
 import '../common.dart';
 import '../common/resolution.dart' show Resolution;
 import '../core_types.dart';
 import '../elements/elements.dart';
 import '../elements/resolution_types.dart';
 import '../universe/selector.dart';
 import '../universe/use.dart';
 import '../universe/world_impact.dart'
     show WorldImpact, WorldImpactBuilder, WorldImpactBuilderImpl;
 import '../util/util.dart' show Setlet;
 import 'backend_helpers.dart';
 import 'backend_impact.dart';
 
 abstract class BackendUsage {
   bool get needToInitializeIsolateAffinityTag;
   bool get needToInitializeDispatchProperty;
   bool usedByBackend(Element element);
   Iterable<Element> get globalDependencies;
+
+  /// `true` if a core-library function requires the preamble file to function.
+  bool get requiresPreamble;
+
+  /// `true` if [BackendHelpers.invokeOnMethod] is used.
+  bool get isInvokeOnUsed;
+
+  /// `true` of `Object.runtimeType` is used.
+  bool get isRuntimeTypeUsed;
+
+  /// `true` if the `dart:isolate` library is in use.
+  bool get isIsolateInUse;
+
+  /// `true` if `Function.apply` is used.
+  bool get isFunctionApplyUsed;
 }
 
 abstract class BackendUsageBuilder {
   Element registerBackendUse(Element element);
   void registerGlobalDependency(Element element);
   void registerBackendImpact(
       WorldImpactBuilder worldImpact, BackendImpact backendImpact);
   void registerBackendStaticUse(
       WorldImpactBuilder worldImpact, MethodElement element,
       {bool isGlobal: false});
   void registerBackendInstantiation(
       WorldImpactBuilder worldImpact, ClassElement cls,
       {bool isGlobal: false});
   WorldImpact createImpactFor(BackendImpact impact);
   void registerUsedMember(MemberElement member);
+
+  /// `true` of `Object.runtimeType` is used.
+  bool isRuntimeTypeUsed;
+
+  /// `true` if the `dart:isolate` library is in use.
+  bool isIsolateInUse;
+
+  /// `true` if `Function.apply` is used.
+  bool isFunctionApplyUsed;
 }
 
 class BackendUsageImpl implements BackendUsage, BackendUsageBuilder {
   final CommonElements _commonElements;
   final BackendHelpers _helpers;
   final Resolution _resolution;
   // TODO(johnniwinther): Remove the need for this.
   Setlet<Element> _globalDependencies;
 
   /// List of elements that the backend may use.
   final Set<Element> _helpersUsed = new Set<Element>();
 
   bool _needToInitializeIsolateAffinityTag = false;
   bool _needToInitializeDispatchProperty = false;
 
+  /// `true` if a core-library function requires the preamble file to function.
+  bool requiresPreamble = false;
+
+  /// `true` if [BackendHelpers.invokeOnMethod] is used.
+  bool isInvokeOnUsed = false;
+
+  /// `true` of `Object.runtimeType` is used.
+  bool isRuntimeTypeUsed = false;
+
+  /// `true` if the `dart:isolate` library is in use.
+  bool isIsolateInUse = false;
+
+  /// `true` if `Function.apply` is used.
+  bool isFunctionApplyUsed = false;
+
   BackendUsageImpl(this._commonElements, this._helpers, this._resolution);
 
   bool get needToInitializeIsolateAffinityTag =>
       _needToInitializeIsolateAffinityTag;
   bool get needToInitializeDispatchProperty =>
       _needToInitializeDispatchProperty;
 
   /// The backend must *always* call this method when enqueuing an
   /// element. Calls done by the backend are not seen by global
   /// optimizations, so they would make these optimizations unsound.
@@ skipping 126 matching lines @@
         case BackendFeature.needToInitializeIsolateAffinityTag:
           _needToInitializeIsolateAffinityTag = true;
           break;
       }
     }
   }
 
   void registerUsedMember(MemberElement member) {
     if (member == _helpers.getIsolateAffinityTagMarker) {
       _needToInitializeIsolateAffinityTag = true;
+    } else if (member == _helpers.requiresPreambleMarker) {
+      requiresPreamble = true;
+    } else if (member == _helpers.invokeOnMethod) {
+      isInvokeOnUsed = true;
+    } else if (_commonElements.isFunctionApplyMethod(member)) {
+      isFunctionApplyUsed = true;
     }
   }
 
   void registerGlobalDependency(Element element) {
     if (element == null) return;
     if (_globalDependencies == null) {
       _globalDependencies = new Setlet<Element>();
     }
     _globalDependencies.add(element.implementation);
   }
 
   Iterable<Element> get globalDependencies => _globalDependencies;
 }