Refactor enqueuers

pkg/compiler/lib/src/compiler.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.compiler_base;
 
 import 'dart:async' show EventSink, Future;
 
 import '../compiler_new.dart' as api;
 import 'cache_strategy.dart' show CacheStrategy;
@@ skipping 58 matching lines @@
 import 'tokens/token_map.dart' show TokenMap;
 import 'tracer.dart' show Tracer;
 import 'tree/tree.dart' show Node, TypeAnnotation;
 import 'typechecker.dart' show TypeCheckerTask;
 import 'types/types.dart' show GlobalTypeInferenceTask;
 import 'types/masks.dart' show CommonMasks;
 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;
 
 typedef Backend MakeBackendFuncion(Compiler compiler);
 
 typedef CompilerDiagnosticReporter MakeReporterFunction(
     Compiler compiler, CompilerOptions options);
 
 abstract class Compiler implements LibraryLoaderListener {
   Measurer get measurer;
@@ skipping 17 matching lines @@
 
   /**
    * Records global dependencies, that is, dependencies that don't
    * correspond to a particular element.
    *
    * We should get rid of this and ensure that all dependencies are
    * associated with a particular element.
    */
   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;
 
   /**
    * If true, stop compilation after type inference is complete. Used for
    * debugging and testing purposes only.
    */
   bool stopAfterTypeInference = false;
 
   /// Output provider from user of Compiler API.
@@ skipping 543 matching lines @@
           }
           if (librariesToAnalyzeWhenRun != null) {
             for (Uri libraryUri in librariesToAnalyzeWhenRun) {
               fullyEnqueueLibrary(
                   libraryLoader.lookupLibrary(libraryUri), enqueuer.resolution);
             }
           }
         }
         // 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);
         enqueuer.resolution.logSummary(reporter.log);
 
         _reporter.reportSuppressedMessagesSummary();
 
         if (compilationFailed) {
           if (!options.generateCodeWithCompileTimeErrors) return;
           if (!backend
@@ skipping 29 matching lines @@
         reporter.log('Inferring types...');
         globalInference.runGlobalTypeInference(mainFunction);
 
         if (stopAfterTypeInference) return;
 
         backend.onTypeInferenceComplete();
 
         reporter.log('Compiling...');
         phase = PHASE_COMPILING;
         backend.onCodegenStart();
-        // TODO(johnniwinther): Move these to [CodegenEnqueuer].
         if (hasIsolateSupport) {
           backend.enableIsolateSupport(enqueuer.codegen);
         }
         if (compileAll) {
           libraryLoader.libraries.forEach((LibraryElement library) {
             fullyEnqueueLibrary(library, enqueuer.codegen);
           });
         }
         processQueue(enqueuer.codegen, mainFunction);
         enqueuer.codegen.logSummary(reporter.log);
@@ skipping 59 matching lines @@
         }
       });
     }
   }
 
   void fullyEnqueueTopLevelElement(Element element, Enqueuer world) {
     if (element.isClass) {
       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);
     }
   }
 
   // Resolves metadata on library elements.  This is necessary in order to
   // resolve metadata classes referenced only from metadata on library tags.
   // TODO(ahe): Figure out how to do this lazily.
   void resolveLibraryMetadata() {
     for (LibraryElement library in libraryLoader.libraries) {
@@ skipping 15 matching lines @@
               work.element,
               () => selfTask.measureSubtask("world.applyImpact", () {
                     world.applyImpact(
                         selfTask.measureSubtask(
                             "work.run", () => work.run(this, world)),
                         impactSource: work.element);
                   }));
         });
       });
 
-  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);
+  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(world);
-          }
-          world.addToWorkList(main);
+          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
    * the queues are empty (nothing was added after we stopped
    * processing the queues). Also compute the number of methods that
    * were resolved, but not compiled (aka excess resolution).
    */
   checkQueues() {
     for (Enqueuer world in [enqueuer.resolution, enqueuer.codegen]) {
       world.forEach((WorkItem work) {
@@ skipping 1240 matching lines @@
         compiler.checker.check(element);
       }
       return transformResolutionImpact(element, resolutionImpact);
     });
   }
 
   @override
   WorldImpact transformResolutionImpact(
       Element element, ResolutionImpact resolutionImpact) {
     WorldImpact worldImpact = compiler.backend.impactTransformer
-        .transformResolutionImpact(resolutionImpact);
+        .transformResolutionImpact(compiler.enqueuer.resolution, resolutionImpact);

[Harry Terkelsen, 2016/11/11 21:24:27]

dartfmt

[Johnni Winther, 2016/11/14 09:08:36]

Done.

     _worldImpactCache[element] = worldImpact;
     return worldImpact;
   }
 
   @override
   void uncacheWorldImpact(Element element) {
     assert(invariant(element, element.isDeclaration,
         message: "Element $element must be the declaration."));
     if (retainCachesForTesting) return;
     if (compiler.serialization.isDeserialized(element)) return;
@@ skipping 92 matching lines @@
   _ElementScanner(this.scanner);
   void scanLibrary(LibraryElement library) => scanner.scanLibrary(library);
   void scanUnit(CompilationUnitElement unit) => scanner.scan(unit);
 }
 
 class _EmptyEnvironment implements Environment {
   const _EmptyEnvironment();
 
   String valueOf(String key) => null;
 }