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 access to [BackendHelpers.invokeOnMethod] is supported.
+  bool get hasInvokeOnSupport;

[Siggi Cherem (dart-lang), 2017/02/17 23:05:08]

Let's rename a lot of these properties.

Reading the changes throughout the CL I felt that it was really odd to ask a
`backendUsage` about whether or not something is supported :).  Then I realized
that this is not about something being supported (all of these features are
always supported) but about whether some features are used and therefore we must
reason about them elsewhere.

Here is a proposal for new names:
- hasInvokeOnSupport => isInvokeOnUsed
- hasRuntimeTypeSupport => isRuntimeTypeUsed
- hasIsolateSupport => isIsolateInUse
- hasFunctionApplySupport => isFunctionApplyUsed

I'm OK doing this as a follow up change if you prefer.

[Johnni Winther, 2017/02/20 11:37:42]

Done.

+
+  /// `true` of `Object.runtimeType` is supported.
+  bool get hasRuntimeTypeSupport;
+
+  /// `true` of use of the `dart:isolate` library is supported.
+  bool get hasIsolateSupport;
+
+  /// `true` of `Function.apply` is supported.
+  bool get hasFunctionApplySupport;
 }
 
 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);
+
+  bool hasRuntimeTypeSupport;
+
+  /// `true` of use of the `dart:isolate` library is supported.
+  bool hasIsolateSupport;
+
+  /// `true` of `Function.apply` is supported.
+  bool hasFunctionApplySupport;
 }
 
 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 access to [BackendHelpers.invokeOnMethod] is supported.
+  bool hasInvokeOnSupport = false;
+
+  /// `true` of `Object.runtimeType` is supported.
+  bool hasRuntimeTypeSupport = false;
+
+  /// `true` of use of the `dart:isolate` library is supported.
+  bool hasIsolateSupport = false;
+
+  /// `true` of `Function.apply` is supported.
+  bool hasFunctionApplySupport = 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) {
+      hasInvokeOnSupport = true;
+    } else if (_commonElements.isFunctionApplyMethod(member)) {
+      hasFunctionApplySupport = 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;
 }