Refactor enqueuers

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 65 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, Registry registry);
+  void enqueueHelpers(ResolutionEnqueuer world);
 
   /// Creates an [Enqueuer] for code generation specific to this backend.
   Enqueuer createCodegenEnqueuer(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(world) {
     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(Spannable node, Registry registry);
+  bool enableDeferredLoadingIfSupported(
+      ResolutionEnqueuer enqueuer, Spannable node);
 
   /// 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, Registry registry) {}
+  void registerInstantiatedClass(ClassElement cls, Enqueuer enqueuer) {}
 
   /// Called to notify to the backend that a class is implemented by an
   /// instantiated class.
-  void registerImplementedClass(
-      ClassElement cls, Enqueuer enqueuer, Registry registry) {}
+  void registerImplementedClass(ClassElement cls, Enqueuer enqueuer) {}
 
   /// Called to instruct to the backend register [type] as instantiated on
   /// [enqueuer].
-  void registerInstantiatedType(
-      InterfaceType type, Enqueuer enqueuer, Registry registry,
-      {bool mirrorUsage: false}) {
-    registry.registerDependency(type.element);
-    enqueuer.registerInstantiatedType(type, mirrorUsage: mirrorUsage);
-  }
+  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, Registry registry) {}
+      Element callMethod, Enqueuer enqueuer) {}
 
   /// 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, Registry registry) {}
+      Element closure, Enqueuer enqueuer) {}
 
   /// Call this to register that a member has been closurized.
   void registerBoundClosure(Enqueuer enqueuer) {}
 
   /// Call this to register that a static function has been closurized.
   void registerGetOfStaticFunction(Enqueuer enqueuer) {}
 
   /**
    * Call this to register that the [:runtimeType:] property has been accessed.
    */
-  void registerRuntimeType(Enqueuer enqueuer, Registry registry) {}
+  void registerRuntimeType(Enqueuer enqueuer) {}
 
   /// Call this to register a `noSuchMethod` implementation.
   void registerNoSuchMethod(FunctionElement noSuchMethodElement) {}
 
   /// Call this method to enable support for `noSuchMethod`.
   void enableNoSuchMethod(Enqueuer enqueuer) {}
 
   /// Returns whether or not `noSuchMethod` support has been enabled.
   bool get enabledNoSuchMethod => false;
 
@@ skipping 23 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(Element element, {bool forResolution}) {}
+  void registerStaticUse(Enqueuer enqueuer, Element element) {}
 
   /// 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 134 matching lines @@
   void registerInstantiatedType(InterfaceType type);
 
   /// Resolves [typeName] to a type in the context of [node].
   DartType resolveTypeFromString(Node node, String typeName);
 }
 
 /// Backend transformation methods for the world impacts.
 class ImpactTransformer {
   /// Transform the [ResolutionImpact] into a [WorldImpact] adding the
   /// backend dependencies for features used in [worldImpact].
-  WorldImpact transformResolutionImpact(ResolutionImpact worldImpact) {
+  WorldImpact transformResolutionImpact(
+      ResolutionEnqueuer enqueuer, ResolutionImpact worldImpact) {
     return worldImpact;
   }
 
   /// Transform the [CodegenImpact] into a [WorldImpact] adding the
   /// backend dependencies for features used in [worldImpact].
   WorldImpact transformCodegenImpact(CodegenImpact worldImpact) {
     return worldImpact;
   }
 }
 
@@ skipping 21 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;
 }