Remove direct access to enqueuer through use of WorldImpact

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 238 matching lines @@
       backend = jsBackend;
     }
     enqueuer = backend.makeEnqueuer();
 
     if (options.dumpInfo && options.useStartupEmitter) {
       throw new ArgumentError(
           '--dump-info is not supported with the fast startup emitter');
     }
 
     tasks = [
-      dietParser =
-          new DietParserTask(idGenerator, backend, reporter, measurer),
+      dietParser = new DietParserTask(idGenerator, backend, reporter, measurer),
       scanner = createScannerTask(),
       serialization = new SerializationTask(this),
       libraryLoader = new LibraryLoaderTask(
           resolvedUriTranslator,
           options.compileOnly
               ? new _NoScriptLoader(this)
               : new _ScriptLoader(this),
           new _ElementScanner(scanner),
           serialization,
           this,
@@ skipping 275 matching lines @@
         }
         return libraryLoader.loadLibrary(uri).then((LibraryElement library) {
           mainApp = library;
         });
       }
     }).then((_) {
       compileLoadedLibraries();
     });
   }
 
-  void computeMain() {
-    if (mainApp == null) return;
+  WorldImpact computeMain() {
+    if (mainApp == null) return const WorldImpact();
 
+    WorldImpactBuilderImpl impactBuilder = new WorldImpactBuilderImpl();
     Element main = mainApp.findExported(Identifiers.main);
     ErroneousElement errorElement = null;
     if (main == null) {
       if (options.analyzeOnly) {
         if (!analyzeAll) {
           errorElement = new ErroneousElementX(MessageKind.CONSIDER_ANALYZE_ALL,
               {'main': Identifiers.main}, Identifiers.main, mainApp);
         }
       } else {
         // Compilation requires a main method.
@@ skipping 20 matching lines @@
         int index = 0;
         parameters.orderedForEachParameter((Element parameter) {
           if (index++ < 2) return;
           errorElement = new ErroneousElementX(
               MessageKind.MAIN_WITH_EXTRA_PARAMETER,
               {'main': Identifiers.main},
               Identifiers.main,
               parameter);
           mainFunction = backend.helperForMainArity();
           // Don't warn about main not being used:
-          enqueuer.resolution.registerStaticUse(new StaticUse.foreignUse(main));
+          impactBuilder.registerStaticUse(new StaticUse.foreignUse(main));
         });
       }
     }
     if (mainFunction == null) {
       if (errorElement == null && !options.analyzeOnly && !analyzeAll) {
         reporter.internalError(mainApp, "Problem with '${Identifiers.main}'.");
       } else {
         mainFunction = errorElement;
       }
     }
     if (errorElement != null &&
         errorElement.isSynthesized &&
         !mainApp.isSynthesized) {
       reporter.reportWarningMessage(errorElement, errorElement.messageKind,
           errorElement.messageArguments);
     }
+    return impactBuilder;
   }
 
   /// Analyze all members of the library in [libraryUri].
   ///
   /// If [skipLibraryWithPartOfTag] is `true`, member analysis is skipped if the
   /// library has a `part of` tag, assuming it is a part and not a library.
   ///
   /// This operation assumes an unclosed resolution queue and is only supported
   /// when the '--analyze-main' option is used.
   Future<LibraryElement> analyzeUri(Uri libraryUri,
       {bool skipLibraryWithPartOfTag: true}) {
     assert(options.analyzeMain);
     reporter.log('Analyzing $libraryUri (${options.buildId})');
     return libraryLoader
         .loadLibrary(libraryUri, skipFileWithPartOfTag: true)
         .then((LibraryElement library) {
       if (library == null) return null;
       fullyEnqueueLibrary(library, enqueuer.resolution);
       emptyQueue(enqueuer.resolution);
       enqueuer.resolution.logSummary(reporter.log);
       return library;
     });
   }
 
   /// Performs the compilation when all libraries have been loaded.
   void compileLoadedLibraries() =>
       selfTask.measureSubtask("Compiler.compileLoadedLibraries", () {
-        computeMain();
+        WorldImpact mainImpact = computeMain();
 
         mirrorUsageAnalyzerTask.analyzeUsage(mainApp);
 
         // In order to see if a library is deferred, we must compute the
         // compile-time constants that are metadata.  This means adding
         // something to the resolution queue.  So we cannot wait with
         // this until after the resolution queue is processed.
         deferredLoadTask.beforeResolution(this);
-        ImpactStrategy impactStrategy = backend.createImpactStrategy(
+        impactStrategy = backend.createImpactStrategy(
             supportDeferredLoad: deferredLoadTask.isProgramSplit,
             supportDumpInfo: options.dumpInfo,
             supportSerialization: serialization.supportSerialization);
 
         phase = PHASE_RESOLVING;
+        enqueuer.resolution.applyImpact(mainImpact);
         if (options.resolveOnly) {
           libraryLoader.libraries.where((LibraryElement library) {
             return !serialization.isDeserialized(library);
           }).forEach((LibraryElement library) {
             reporter.log('Enqueuing ${library.canonicalUri}');
             fullyEnqueueLibrary(library, enqueuer.resolution);
           });
         } else if (analyzeAll) {
           libraryLoader.libraries.forEach((LibraryElement library) {
             reporter.log('Enqueuing ${library.canonicalUri}');
             fullyEnqueueLibrary(library, enqueuer.resolution);
           });
         } else if (options.analyzeMain) {
           if (mainApp != null) {
             fullyEnqueueLibrary(mainApp, enqueuer.resolution);
           }
           if (librariesToAnalyzeWhenRun != null) {
             for (Uri libraryUri in librariesToAnalyzeWhenRun) {
               fullyEnqueueLibrary(
                   libraryLoader.lookupLibrary(libraryUri), enqueuer.resolution);
             }
           }
         }
+        if (deferredLoadTask.isProgramSplit) {
+          enqueuer.resolution
+              .applyImpact(backend.computeDeferredLoadingImpact());
+        }
         // Elements required by enqueueHelpers are global dependencies
         // that are not pulled in by a particular element.
-        backend.enqueueHelpers(enqueuer.resolution);
+        enqueuer.resolution.applyImpact(backend.computeHelpersImpact());
         resolveLibraryMetadata();
         reporter.log('Resolving...');
         if (mainFunction != null && !mainFunction.isMalformed) {
           mainFunction.computeType(resolution);
         }
 
         processQueue(enqueuer.resolution, mainFunction);
         enqueuer.resolution.logSummary(reporter.log);
 
         _reporter.reportSuppressedMessagesSummary();
@@ skipping 34 matching lines @@
         globalInference.runGlobalTypeInference(mainFunction);
 
         if (stopAfterTypeInference) return;
 
         backend.onTypeInferenceComplete();
 
         reporter.log('Compiling...');
         phase = PHASE_COMPILING;
         backend.onCodegenStart();
         if (hasIsolateSupport) {
-          backend.enableIsolateSupport(enqueuer.codegen);
+          enqueuer.codegen
+              .applyImpact(backend.enableIsolateSupport(forResolution: false));
         }
         if (compileAll) {
           libraryLoader.libraries.forEach((LibraryElement library) {
             fullyEnqueueLibrary(library, enqueuer.codegen);
           });
         }
         processQueue(enqueuer.codegen, mainFunction);
         enqueuer.codegen.logSummary(reporter.log);
 
         int programSize = backend.assembleProgram();
@@ skipping 86 matching lines @@
   /**
    * Empty the [enqueuer] queue.
    */
   void emptyQueue(Enqueuer enqueuer) {
     selfTask.measureSubtask("Compiler.emptyQueue", () {
       enqueuer.forEach((WorkItem work) {
         reporter.withCurrentElement(
             work.element,
             () => selfTask.measureSubtask("world.applyImpact", () {
                   enqueuer.applyImpact(
-                      impactStrategy,
                       selfTask.measureSubtask(
                           "work.run", () => work.run(this, enqueuer)),
                       impactSource: work.element);
                 }));
       });
     });
   }
 
   void processQueue(Enqueuer enqueuer, MethodElement mainMethod) {
     selfTask.measureSubtask("Compiler.processQueue", () {
-      enqueuer.applyImpact(
-          impactStrategy,
-          enqueuer.nativeEnqueuer
-              .processNativeClasses(libraryLoader.libraries));
+      enqueuer.open(impactStrategy);
+      enqueuer.applyImpact(enqueuer.nativeEnqueuer
+          .processNativeClasses(libraryLoader.libraries));
       if (mainMethod != null && !mainMethod.isMalformed) {
-        enqueuer.applyImpact(
-            impactStrategy, backend.computeMainImpact(enqueuer, mainMethod));
+        enqueuer.applyImpact(backend.computeMainImpact(mainMethod,
+            forResolution: enqueuer.isResolutionQueue));
       }
       if (options.verbose) {
         progress.reset();
       }
       emptyQueue(enqueuer);
       enqueuer.queueIsClosed = true;
+      enqueuer.close();
       // Notify the impact strategy impacts are no longer needed for this
       // enqueuer.
       impactStrategy.onImpactUsed(enqueuer.impactUse);
       backend.onQueueClosed();
       assert(compilationFailed ||
           enqueuer.checkNoEnqueuedInvokedInstanceMethods());
     });
   }
 
   /**
@@ skipping 1369 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;
 }