Prepare for late creation of ResolutionEnqueuer

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 'closure.dart' as closureMapping show ClosureTask;
@@ skipping 567 matching lines @@
       enqueuer.resolution.applyImpact(computeImpactForLibrary(library));
       emptyQueue(enqueuer.resolution, onProgress: showResolutionProgress);
       enqueuer.resolution.logSummary(reporter.log);
       return library;
     });
   }
 
   /// Performs the compilation when all libraries have been loaded.
   void compileLoadedLibraries() =>
       selfTask.measureSubtask("Compiler.compileLoadedLibraries", () {
+        Enqueuer resolutionEnqueuer = enqueuer.createResolutionEnqueuer();
         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 = backend.createImpactStrategy(
             supportDeferredLoad: deferredLoadTask.isProgramSplit,
             supportDumpInfo: options.dumpInfo,
             supportSerialization: serialization.supportSerialization);
 
         phase = PHASE_RESOLVING;
-        enqueuer.resolution.applyImpact(mainImpact);
+        resolutionEnqueuer.applyImpact(mainImpact);
         if (options.resolveOnly) {
           libraryLoader.libraries.where((LibraryElement library) {
             return !serialization.isDeserialized(library);
           }).forEach((LibraryElement library) {
             reporter.log('Enqueuing ${library.canonicalUri}');
-            enqueuer.resolution.applyImpact(computeImpactForLibrary(library));
+            resolutionEnqueuer.applyImpact(computeImpactForLibrary(library));
           });
         } else if (analyzeAll) {
           libraryLoader.libraries.forEach((LibraryElement library) {
             reporter.log('Enqueuing ${library.canonicalUri}');
-            enqueuer.resolution.applyImpact(computeImpactForLibrary(library));
+            resolutionEnqueuer.applyImpact(computeImpactForLibrary(library));
           });
         } else if (options.analyzeMain) {
           if (mainApp != null) {
-            enqueuer.resolution.applyImpact(computeImpactForLibrary(mainApp));
+            resolutionEnqueuer.applyImpact(computeImpactForLibrary(mainApp));
           }
           if (librariesToAnalyzeWhenRun != null) {
             for (Uri libraryUri in librariesToAnalyzeWhenRun) {
-              enqueuer.resolution.applyImpact(computeImpactForLibrary(
+              resolutionEnqueuer.applyImpact(computeImpactForLibrary(
                   libraryLoader.lookupLibrary(libraryUri)));
             }
           }
         }
         if (deferredLoadTask.isProgramSplit) {
-          enqueuer.resolution
+          resolutionEnqueuer
               .applyImpact(backend.computeDeferredLoadingImpact());
         }
         resolveLibraryMetadata();
         reporter.log('Resolving...');
         MethodElement mainMethod;
         if (mainFunction != null && !mainFunction.isMalformed) {
           mainFunction.computeType(resolution);
           mainMethod = mainFunction;
         }
 
-        processQueue(enqueuer.resolution, mainMethod, libraryLoader.libraries,
+        processQueue(resolutionEnqueuer, mainMethod, libraryLoader.libraries,
             onProgress: showResolutionProgress);
-        enqueuer.resolution.logSummary(reporter.log);
+        resolutionEnqueuer.logSummary(reporter.log);
 
         _reporter.reportSuppressedMessagesSummary();
 
         if (compilationFailed) {
           if (!options.generateCodeWithCompileTimeErrors) return;
           if (!backend
               .enableCodegenWithErrorsIfSupported(NO_LOCATION_SPANNABLE)) {
             return;
           }
         }
@@ skipping 50 matching lines @@
 
         int programSize = backend.assembleProgram(closedWorld);
 
         if (options.dumpInfo) {
           dumpInfoTask.reportSize(programSize);
           dumpInfoTask.dumpInfo(closedWorld);
         }
 
         backend.onCodegenEnd();
 
-        checkQueues(enqueuer.resolution, codegenEnqueuer);
+        checkQueues(resolutionEnqueuer, codegenEnqueuer);
       });
 
   /// Perform the steps needed to fully end the resolution phase.
   ClosedWorldRefiner closeResolution() {
     phase = PHASE_DONE_RESOLVING;
 
     ClosedWorldImpl world = resolutionWorldBuilder.closeWorld(reporter);
     // Compute whole-program-knowledge that the backend needs. (This might
     // require the information computed in [world.closeWorld].)
     backend.onResolutionComplete(world, world);
@@ skipping 1319 matching lines @@
     if (library != null && library.isSynthesized) {
       return null;
     }
     if (library == null && required) {
       throw new SpannableAssertionFailure(
           library, "The library '${uri}' was not found.");
     }
     return library;
   }
 }