Remove direct access to enqueuer through use of WorldImpact

pkg/compiler/lib/src/common/backend_api.dart

 // Copyright (c) 2012, 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.backend_api;
 
 import 'dart:async' show Future;
 
 import '../common.dart';
 import '../common/codegen.dart' show CodegenImpact;
@@ skipping 64 matching lines @@
   /// Set of classes that need to be considered for reflection although not
   /// otherwise visible during resolution.
   Iterable<ClassElement> classesRequiredForReflection = const [];
 
   // Given a [FunctionElement], return a buffer with the code generated for it
   // or null if no code was generated.
   CodeBuffer codeOf(Element element) => null;
 
   void initializeHelperClasses() {}
 
-  void enqueueHelpers(ResolutionEnqueuer world);
+  /// Compute the [WorldImpact] for backend helper methods.
+  WorldImpact computeHelpersImpact();
 
   /// Creates an [Enqueuer] for code generation specific to this backend.
   Enqueuer createCodegenEnqueuer(CompilerTask task, Compiler compiler);
 
   WorldImpact codegen(CodegenWorkItem work);
 
   // The backend determines the native resolution enqueuer, with a no-op
   // default, so tools like dart2dart can ignore the native classes.
   native.NativeEnqueuer nativeResolutionEnqueuer() {
     return new native.NativeEnqueuer();
@@ skipping 13 matching lines @@
 
   bool classNeedsRti(ClassElement cls);
   bool methodNeedsRti(FunctionElement function);
 
   /// Enable compilation of code with compile time errors. Returns `true` if
   /// supported by the backend.
   bool enableCodegenWithErrorsIfSupported(Spannable node);
 
   /// Enable deferred loading. Returns `true` if the backend supports deferred
   /// loading.
-  bool enableDeferredLoadingIfSupported(
-      ResolutionEnqueuer enqueuer, Spannable node);
+  bool enableDeferredLoadingIfSupported(Spannable node);
+
+  /// Returns the [WorldImpact] of enabling deferred loading.
+  WorldImpact computeDeferredLoadingImpact() => const WorldImpact();
 
   /// Called during codegen when [constant] has been used.
   void computeImpactForCompileTimeConstant(ConstantValue constant,
       WorldImpactBuilder impactBuilder, bool isForResolution) {}
 
-  /// Called to notify to the backend that a class is being instantiated.
-  // TODO(johnniwinther): Remove this. It's only called once for each [cls] and
-  // only with [Compiler.globalDependencies] as [registry].
-  void registerInstantiatedClass(ClassElement cls, Enqueuer enqueuer) {}
+  /// Called to notify to the backend that a class is being instantiated. Any
+  /// backend specific [WorldImpact] of this is returned.
+  WorldImpact registerInstantiatedClass(ClassElement cls,
+          {bool forResolution}) =>
+      const WorldImpact();
 
   /// Called to notify to the backend that a class is implemented by an
-  /// instantiated class.
-  void registerImplementedClass(ClassElement cls, Enqueuer enqueuer) {}
+  /// instantiated class. Any backend specific [WorldImpact] of this is
+  /// returned.
+  WorldImpact registerImplementedClass(ClassElement cls,
+          {bool forResolution}) =>
+      const WorldImpact();
 
   /// Called to instruct to the backend register [type] as instantiated on
   /// [enqueuer].
   void registerInstantiatedType(InterfaceType type) {}
 
   /// Register a runtime type variable bound tests between [typeArgument] and
   /// [bound].
   void registerTypeVariableBoundsSubtypeCheck(
       DartType typeArgument, DartType bound) {}
 
-  /**
-   * Call this to register that an instantiated generic class has a call
-   * method.
-   */
-  void registerCallMethodWithFreeTypeVariables(
-      Element callMethod, Enqueuer enqueuer) {}
+  /// Called to register that an instantiated generic class has a call method.

[Harry Terkelsen, 2016/11/28 19:03:06]

is this method called even if the call method does not reference the generic
type variables?

[Johnni Winther, 2016/11/29 08:01:37]

Yes. Added a note to the comment.

+  /// Any backend specific [WorldImpact] of this is returned.
+  WorldImpact registerCallMethodWithFreeTypeVariables(Element callMethod,
+          {bool forResolution}) =>
+      const WorldImpact();
 
   /// Called to instruct the backend to register that a closure exists for a
-  /// function on an instantiated generic class.
-  void registerClosureWithFreeTypeVariables(
-      Element closure, Enqueuer enqueuer) {}
+  /// function on an instantiated generic class. Any backend specific
+  /// [WorldImpact] of this is returned.
+  WorldImpact registerClosureWithFreeTypeVariables(Element closure,
+          {bool forResolution}) =>
+      const WorldImpact();
 
-  /// Call this to register that a member has been closurized.
-  void registerBoundClosure(Enqueuer enqueuer) {}
+  /// Called to register that a member has been closurized. Any backend specific
+  /// [WorldImpact] of this is returned.
+  WorldImpact registerBoundClosure() => const WorldImpact();
 
-  /// Call this to register that a static function has been closurized.
-  void registerGetOfStaticFunction(Enqueuer enqueuer) {}
+  /// Called to register that a static function has been closurized. Any backend
+  /// specific [WorldImpact] of this is returned.
+  WorldImpact registerGetOfStaticFunction() => const WorldImpact();
 
-  /**
-   * Call this to register that the [:runtimeType:] property has been accessed.
-   */
-  void registerRuntimeType(Enqueuer enqueuer) {}
+  /// Called to register that the `runtimeType` property has been accessed. Any
+  /// backend specific [WorldImpact] of this is returned.
+  WorldImpact registerRuntimeType() => const WorldImpact();
 
-  /// Call this to register a `noSuchMethod` implementation.
+  /// Called to register a `noSuchMethod` implementation.
   void registerNoSuchMethod(FunctionElement noSuchMethodElement) {}
 
-  /// Call this method to enable support for `noSuchMethod`.
-  void enableNoSuchMethod(Enqueuer enqueuer) {}
+  /// Called to enable support for `noSuchMethod`. Any backend specific
+  /// [WorldImpact] of this is returned.
+  WorldImpact enableNoSuchMethod() => const WorldImpact();
 
   /// Returns whether or not `noSuchMethod` support has been enabled.
   bool get enabledNoSuchMethod => false;
 
-  /// Call this method to enable support for isolates.
-  void enableIsolateSupport(Enqueuer enqueuer) {}
+  /// Called to enable support for isolates. Any backend specific [WorldImpact]
+  /// of this is returned.
+  WorldImpact enableIsolateSupport({bool forResolution});
 
   void registerConstSymbol(String name) {}
 
   ClassElement defaultSuperclass(ClassElement element) {
     return compiler.coreClasses.objectClass;
   }
 
   bool isInterceptorClass(ClassElement element) => false;
 
   /// Returns `true` if [element] is implemented via typed JavaScript interop.
@@ skipping 11 matching lines @@
     // TODO(johnniwinther): Remove this when patching is only done by the
     // JavaScript backend.
     Uri canonicalUri = library.canonicalUri;
     if (canonicalUri == js_backend.BackendHelpers.DART_JS_HELPER ||
         canonicalUri == js_backend.BackendHelpers.DART_INTERCEPTORS) {
       return true;
     }
     return false;
   }
 
-  void registerStaticUse(Enqueuer enqueuer, Element element) {}
+  /// Called to register that [element] is statically known to be used. Any
+  /// backend specific [WorldImpact] of this is returned.
+  WorldImpact registerStaticUse(Element element, {bool forResolution}) =>
+      const WorldImpact();
 
   /// This method is called immediately after the [LibraryElement] [library] has
   /// been created.
   void onLibraryCreated(LibraryElement library) {}
 
   /// This method is called immediately after the [library] and its parts have
   /// been scanned.
   Future onLibraryScanned(LibraryElement library, LibraryLoader loader) {
     // TODO(johnniwinther): Move this to [JavaScriptBackend].
     if (!compiler.serialization.isDeserialized(library)) {
@@ skipping 87 matching lines @@
 
   FunctionElement helperForBadMain() => null;
 
   FunctionElement helperForMissingMain() => null;
 
   FunctionElement helperForMainArity() => null;
 
   void forgetElement(Element element) {}
 
   /// Computes the [WorldImpact] of calling [mainMethod] as the entry point.
-  WorldImpact computeMainImpact(Enqueuer enqueuer, MethodElement mainMethod) {}
+  WorldImpact computeMainImpact(MethodElement mainMethod,
+          {bool forResolution}) =>
+      const WorldImpact();
 
   /// Returns the location of the patch-file associated with [libraryName]
   /// resolved from [plaformConfigUri].
   ///
   /// Returns null if there is none.
   Uri resolvePatchUri(String libraryName, Uri plaformConfigUri);
 
   /// Creates an impact strategy to use for compilation.
   ImpactStrategy createImpactStrategy(
       {bool supportDeferredLoad: true,
@@ skipping 67 matching lines @@
   ClassElement get typeImplementation;
   ClassElement get boolImplementation;
   ClassElement get nullImplementation;
   ClassElement get uint32Implementation;
   ClassElement get uint31Implementation;
   ClassElement get positiveIntImplementation;
   ClassElement get syncStarIterableImplementation;
   ClassElement get asyncFutureImplementation;
   ClassElement get asyncStarStreamImplementation;
 }