Late creation of CodegenEnqueuer

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 134 matching lines @@
   DietParserTask dietParser;
   ParserTask parser;
   PatchParserTask patchParser;
   LibraryLoaderTask libraryLoader;
   SerializationTask serialization;
   ResolverTask resolver;
   closureMapping.ClosureTask closureToClassMapper;
   TypeCheckerTask checker;
   GlobalTypeInferenceTask globalInference;
   JavaScriptBackend backend;
+  CodegenWorldBuilder _codegenWorldBuilder;
 
   GenericTask selfTask;
 
   /// The constant environment for the frontend interpretation of compile-time
   /// constants.
   ConstantEnvironment constants;
 
   EnqueueTask enqueuer;
   DeferredLoadTask deferredLoadTask;
   MirrorUsageAnalyzerTask mirrorUsageAnalyzerTask;
@@ skipping 108 matching lines @@
 
   /// Creates the resolver task.
   ///
   /// Override this to mock the resolver for testing.
   ResolverTask createResolverTask() {
     return new ResolverTask(resolution, backend.constantCompilerTask, measurer);
   }
 
   ResolutionWorldBuilder get resolutionWorldBuilder =>
       enqueuer.resolution.worldBuilder;
-  CodegenWorldBuilder get codegenWorldBuilder => enqueuer.codegen.worldBuilder;
+  CodegenWorldBuilder get codegenWorldBuilder {
+    assert(invariant(NO_LOCATION_SPANNABLE, _codegenWorldBuilder != null,
+        message: "CodegenWorldBuilder has not been created yet."));
+    return _codegenWorldBuilder;
+  }
 
   bool get analyzeAll => options.analyzeAll || compileAll;
 
   bool get compileAll => false;
 
   bool get disableTypeInference =>
       options.disableTypeInference || compilationFailed;
 
   // TODO(het): remove this from here. Either inline at all use sites or add it
   // to Reporter.
@@ skipping 381 matching lines @@
         globalInference.runGlobalTypeInference(
             mainFunction, closedWorld, closedWorldRefiner);
 
         if (stopAfterTypeInference) return;
 
         backend.onTypeInferenceComplete();
 
         reporter.log('Compiling...');
         phase = PHASE_COMPILING;
 
-        codegenWorldBuilder.open(closedWorld);
-        enqueuer.codegen.applyImpact(backend.onCodegenStart(closedWorld));
+        Enqueuer codegenEnqueuer = enqueuer.createCodegenEnqueuer(closedWorld);
+        _codegenWorldBuilder = codegenEnqueuer.worldBuilder;
+        _codegenWorldBuilder.open(closedWorld);
+        codegenEnqueuer.applyImpact(
+            backend.onCodegenStart(closedWorld, _codegenWorldBuilder));
         if (compileAll) {
           libraryLoader.libraries.forEach((LibraryElement library) {
-            enqueuer.codegen.applyImpact(computeImpactForLibrary(library));
+            codegenEnqueuer.applyImpact(computeImpactForLibrary(library));
           });
         }
-        processQueue(enqueuer.codegen, mainMethod, libraryLoader.libraries,
+        processQueue(codegenEnqueuer, mainMethod, libraryLoader.libraries,
             onProgress: showCodegenProgress);
-        enqueuer.codegen.logSummary(reporter.log);
+        codegenEnqueuer.logSummary(reporter.log);
 
         int programSize = backend.assembleProgram(closedWorld);
 
         if (options.dumpInfo) {
           dumpInfoTask.reportSize(programSize);
           dumpInfoTask.dumpInfo(closedWorld);
         }
 
         backend.onCodegenEnd();
 
-        checkQueues();
+        checkQueues(enqueuer.resolution, 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 69 matching lines @@
         for (MetadataAnnotation metadata in library.metadata) {
           metadata.ensureResolved(resolution);
         }
       }
     }
   }
 
   /**
    * Empty the [enqueuer] queue.
    */
-  void emptyQueue(Enqueuer enqueuer, {void onProgress()}) {
+  void emptyQueue(Enqueuer enqueuer, {void onProgress(Enqueuer enqueuer)}) {
     selfTask.measureSubtask("Compiler.emptyQueue", () {
       enqueuer.forEach((WorkItem work) {
         if (onProgress != null) {
-          onProgress();
+          onProgress(enqueuer);
         }
         reporter.withCurrentElement(
             work.element,
             () => selfTask.measureSubtask("world.applyImpact", () {
                   enqueuer.applyImpact(
                       selfTask.measureSubtask("work.run", () => work.run()),
                       impactSource: work.element);
                 }));
       });
     });
   }
 
   void processQueue(Enqueuer enqueuer, MethodElement mainMethod,
       Iterable<LibraryEntity> libraries,
-      {void onProgress()}) {
+      {void onProgress(Enqueuer enqueuer)}) {
     selfTask.measureSubtask("Compiler.processQueue", () {
       enqueuer.open(impactStrategy, mainMethod, libraries);
       if (options.verbose) {
         progress.reset();
       }
       emptyQueue(enqueuer, onProgress: onProgress);
       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());
     });
   }
 
   /**
    * 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 enqueuer in [enqueuer.resolution, enqueuer.codegen]) {
+  checkQueues(Enqueuer resolutionEnqueuer, Enqueuer codegenEnqueuer) {
+    for (Enqueuer enqueuer in [resolutionEnqueuer, codegenEnqueuer]) {
       enqueuer.checkQueueIsEmpty();
     }
     if (!REPORT_EXCESS_RESOLUTION) return;
-    var resolved = new Set.from(enqueuer.resolution.processedEntities);
-    for (Element e in enqueuer.codegen.processedEntities) {
+    var resolved = new Set.from(resolutionEnqueuer.processedEntities);
+    for (Element e in codegenEnqueuer.processedEntities) {
       resolved.remove(e);
     }
     for (Element e in new Set.from(resolved)) {
       if (e.isClass ||
           e.isField ||
           e.isTypeVariable ||
           e.isTypedef ||
           identical(e.kind, ElementKind.ABSTRACT_FIELD)) {
         resolved.remove(e);
       }
       if (identical(e.kind, ElementKind.GENERATIVE_CONSTRUCTOR)) {
         resolved.remove(e);
       }
       if (backend.isTargetSpecificLibrary(e.library)) {
         resolved.remove(e);
       }
     }
     reporter.log('Excess resolution work: ${resolved.length}.');
     for (Element e in resolved) {
       reporter.reportWarningMessage(e, MessageKind.GENERIC,
           {'text': 'Warning: $e resolved but not compiled.'});
     }
   }
 
-  void showResolutionProgress() {
+  void showResolutionProgress(Enqueuer enqueuer) {
     if (shouldPrintProgress) {
       // TODO(ahe): Add structured diagnostics to the compiler API and
       // use it to separate this from the --verbose option.
       assert(phase == PHASE_RESOLVING);
-      reporter.log('Resolved ${enqueuer.resolution.processedEntities.length} '
+      reporter.log('Resolved ${enqueuer.processedEntities.length} '
           'elements.');
       progress.reset();
     }
   }
 
-  void showCodegenProgress() {
+  void showCodegenProgress(Enqueuer enqueuer) {
     if (shouldPrintProgress) {
       // TODO(ahe): Add structured diagnostics to the compiler API and
       // use it to separate this from the --verbose option.
-      reporter.log(
-          'Compiled ${enqueuer.codegen.processedEntities.length} methods.');
+      reporter.log('Compiled ${enqueuer.processedEntities.length} methods.');
       progress.reset();
     }
   }
 
   void reportDiagnostic(DiagnosticMessage message,
       List<DiagnosticMessage> infos, api.Diagnostic kind);
 
   void reportCrashInUserCode(String message, exception, stackTrace) {
     reporter.onCrashInUserCode(message, exception, stackTrace);
   }
@@ skipping 923 matching lines @@
         }
         return transformResolutionImpact(element, resolutionImpact);
       });
     });
   }
 
   @override
   WorldImpact transformResolutionImpact(
       Element element, ResolutionImpact resolutionImpact) {
     WorldImpact worldImpact = _compiler.backend.impactTransformer
-        .transformResolutionImpact(
-            _compiler.enqueuer.resolution, resolutionImpact);
+        .transformResolutionImpact(enqueuer, resolutionImpact);
     _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 196 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;
   }
 }