Refactor enqueuers

- limit use of globalDepencies
- remove mirrorDependencies
- compute native class through WorldImpact
- decouple reflectable elements analysis from enqueuers
- prepare for creating multiple enqueuers for closed world tests

R=het@google.com

Review URL: https://codereview.chromium.org/2494093002 .

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

@@ -83,7 +83,7 @@ abstract class Backend extends Target {
 
   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);
@@ -117,7 +117,8 @@ abstract class Backend extends Target {
 
   /// 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,
@@ -126,22 +127,15 @@ abstract class Backend extends Target {
   /// 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].
@@ -153,12 +147,12 @@ abstract class Backend extends Target {
    * 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) {}
@@ -169,7 +163,7 @@ abstract class Backend extends Target {
   /**
    * 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) {}
@@ -213,7 +207,7 @@ abstract class Backend extends Target {
     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.
@@ -368,7 +362,8 @@ abstract class ForeignResolver {
 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;
   }
 

pkg/compiler/lib/src/compiler.dart

@@ -76,7 +76,8 @@ import 'universe/selector.dart' show Selector;
 import 'universe/world_builder.dart'
     show ResolutionWorldBuilder, CodegenWorldBuilder;
 import 'universe/use.dart' show StaticUse;
-import 'universe/world_impact.dart' show ImpactStrategy, WorldImpact;
+import 'universe/world_impact.dart'
+    show ImpactStrategy, WorldImpact, WorldImpactBuilderImpl;
 import 'util/util.dart' show Link, Setlet;
 import 'world.dart' show ClosedWorld, ClosedWorldRefiner, OpenWorld, WorldImpl;
 
@@ -114,16 +115,6 @@ abstract class Compiler implements LibraryLoaderListener {
    */
   GlobalDependencyRegistry globalDependencies;
 
-  /**
-   * Dependencies that are only included due to mirrors.
-   *
-   * We should get rid of this and ensure that all dependencies are
-   * associated with a particular element.
-   */
-  // TODO(johnniwinther): This should not be a [ResolutionRegistry].
-  final Registry mirrorDependencies =
-      new ResolutionRegistry(null, new TreeElementMapping(null));
-
   /// Options provided from command-line arguments.
   final CompilerOptions options;
 
@@ -687,7 +678,7 @@ abstract class Compiler implements LibraryLoaderListener {
         }
         // Elements required by enqueueHelpers are global dependencies
         // that are not pulled in by a particular element.
-        backend.enqueueHelpers(enqueuer.resolution, globalDependencies);
+        backend.enqueueHelpers(enqueuer.resolution);
         resolveLibraryMetadata();
         reporter.log('Resolving...');
         processQueue(enqueuer.resolution, mainFunction);
@@ -737,7 +728,6 @@ abstract class Compiler implements LibraryLoaderListener {
         reporter.log('Compiling...');
         phase = PHASE_COMPILING;
         backend.onCodegenStart();
-        // TODO(johnniwinther): Move these to [CodegenEnqueuer].
         if (hasIsolateSupport) {
           backend.enableIsolateSupport(enqueuer.codegen);
         }
@@ -817,7 +807,7 @@ abstract class Compiler implements LibraryLoaderListener {
       ClassElement cls = element;
       cls.ensureResolved(resolution);
       cls.forEachLocalMember(enqueuer.resolution.addToWorkList);
-      backend.registerInstantiatedType(cls.rawType, world, globalDependencies);
+      world.registerInstantiatedType(cls.rawType);
     } else {
       world.addToWorkList(element);
     }
@@ -853,43 +843,42 @@ abstract class Compiler implements LibraryLoaderListener {
         });
       });
 
-  void processQueue(Enqueuer world, Element main) =>
-      selfTask.measureSubtask("Compiler.processQueue", () {
-        world.nativeEnqueuer.processNativeClasses(libraryLoader.libraries);
-        if (main != null && !main.isMalformed) {
-          FunctionElement mainMethod = main;
-          mainMethod.computeType(resolution);
-          if (mainMethod.functionSignature.parameterCount != 0) {
-            // The first argument could be a list of strings.
-            backend.backendClasses.listImplementation
-                .ensureResolved(resolution);
-            backend.registerInstantiatedType(
-                backend.backendClasses.listImplementation.rawType,
-                world,
-                globalDependencies);
-            backend.backendClasses.stringImplementation
-                .ensureResolved(resolution);
-            backend.registerInstantiatedType(
-                backend.backendClasses.stringImplementation.rawType,
-                world,
-                globalDependencies);
-
-            backend.registerMainHasArguments(world);
-          }
-          world.addToWorkList(main);
+  void processQueue(Enqueuer enqueuer, Element main) {
+    selfTask.measureSubtask("Compiler.processQueue", () {
+      WorldImpactBuilderImpl nativeImpact = new WorldImpactBuilderImpl();
+      enqueuer.nativeEnqueuer
+          .processNativeClasses(nativeImpact, libraryLoader.libraries);
+      enqueuer.applyImpact(nativeImpact);
+      if (main != null && !main.isMalformed) {
+        FunctionElement mainMethod = main;
+        mainMethod.computeType(resolution);
+        if (mainMethod.functionSignature.parameterCount != 0) {
+          // The first argument could be a list of strings.
+          backend.backendClasses.listImplementation.ensureResolved(resolution);
+          enqueuer.registerInstantiatedType(
+              backend.backendClasses.listImplementation.rawType);
+          backend.backendClasses.stringImplementation
+              .ensureResolved(resolution);
+          enqueuer.registerInstantiatedType(
+              backend.backendClasses.stringImplementation.rawType);
+
+          backend.registerMainHasArguments(enqueuer);
         }
-        if (options.verbose) {
-          progress.reset();
-        }
-        emptyQueue(world);
-        world.queueIsClosed = true;
-        // Notify the impact strategy impacts are no longer needed for this
-        // enqueuer.
-        impactStrategy.onImpactUsed(world.impactUse);
-        backend.onQueueClosed();
-        assert(
-            compilationFailed || world.checkNoEnqueuedInvokedInstanceMethods());
-      });
+        enqueuer.addToWorkList(main);
+      }
+      if (options.verbose) {
+        progress.reset();
+      }
+      emptyQueue(enqueuer);
+      enqueuer.queueIsClosed = true;
+      // Notify the impact strategy impacts are no longer needed for this
+      // enqueuer.
+      impactStrategy.onImpactUsed(enqueuer.impactUse);
+      backend.onQueueClosed();
+      assert(compilationFailed ||
+          enqueuer.checkNoEnqueuedInvokedInstanceMethods());
+    });
+  }
 
   /**
    * Perform various checks of the queues. This includes checking that
@@ -2150,7 +2139,8 @@ class _CompilerResolution implements Resolution {
   WorldImpact transformResolutionImpact(
       Element element, ResolutionImpact resolutionImpact) {
     WorldImpact worldImpact = compiler.backend.impactTransformer
-        .transformResolutionImpact(resolutionImpact);
+        .transformResolutionImpact(
+            compiler.enqueuer.resolution, resolutionImpact);
     _worldImpactCache[element] = worldImpact;
     return worldImpact;
   }

pkg/compiler/lib/src/deferred_load.dart

@@ -346,6 +346,8 @@ class DeferredLoadTask extends CompilerTask {
                   }
                   break;
                 case TypeUseKind.INSTANTIATION:
+                case TypeUseKind.MIRROR_INSTANTIATION:
+                case TypeUseKind.NATIVE_INSTANTIATION:
                 case TypeUseKind.IS_CHECK:
                 case TypeUseKind.AS_CAST:
                 case TypeUseKind.CATCH_TYPE:
@@ -842,7 +844,7 @@ class DeferredLoadTask extends CompilerTask {
     }
     if (isProgramSplit) {
       isProgramSplit = compiler.backend.enableDeferredLoadingIfSupported(
-          lastDeferred, compiler.globalDependencies);
+          compiler.enqueuer.resolution, lastDeferred);
     }
   }