Create ResolutionEnqueuer after library loading.

pkg/compiler/lib/src/library_loader.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.library_loader;
 
 import 'dart:async';
 
 import 'common/names.dart' show Uris;
 import 'common/tasks.dart' show CompilerTask, Measurer;
 import 'common.dart';
 import 'elements/elements.dart'
     show
         CompilationUnitElement,
         Element,
         ImportElement,
         ExportElement,
         LibraryElement;
 import 'elements/modelx.dart'
     show
         CompilationUnitElementX,
         DeferredLoaderGetterElementX,
         ErroneousElementX,
         ExportElementX,
         ImportElementX,
         LibraryElementX,
         LibraryDependencyElementX,
         PrefixElementX,
         SyntheticImportElement;
+import 'enqueue.dart' show DeferredAction;

[Siggi Cherem (dart-lang), 2017/03/14 05:27:55]

consider moving Deferred action under util/deferred_action.dart or something
else to make it clear there is no actual dependency with the enqueuer here.

[Johnni Winther, 2017/03/15 12:46:53]

Will do in a later CL.

 import 'environment.dart';
 import 'resolved_uri_translator.dart';
 import 'script.dart';
 import 'serialization/serialization.dart' show LibraryDeserializer;
 import 'tree/tree.dart';
 import 'util/util.dart' show Link, LinkBuilder;
 
 typedef Future<Iterable<LibraryElement>> ReuseLibrariesFunction(
     Iterable<LibraryElement> libraries);
 
@@ skipping 124 matching lines @@
   ///
   /// This method is used for incremental compilation.
   void reset({bool reuseLibrary(LibraryElement library)});
 
   /// Asynchronous version of [reset].
   Future resetAsync(Future<bool> reuseLibrary(LibraryElement library));
 
   /// Similar to [resetAsync] but [reuseLibrary] maps all libraries to a list
   /// of libraries that can be reused.
   Future<Null> resetLibraries(ReuseLibrariesFunction reuseLibraries);
+
+  /// Register a deferred action to be performed during resolution.
+  void registerDeferredAction(DeferredAction action);
+
+  /// Returns the deferred actions registered since the last call to
+  /// [pullDeferredActions].
+  Iterable<DeferredAction> pullDeferredActions();
 }
 
 /// Interface for an entity that provide libraries. For instance from normal
 /// library loading or from deserialization.
 // TODO(johnniwinther): Use this to integrate deserialized libraries better.
 abstract class LibraryProvider {
   /// Looks up the library with the [canonicalUri].
   LibraryElement lookupLibrary(Uri canonicalUri);
 }
 
@@ skipping 111 matching lines @@
   final LibraryDeserializer deserializer;
 
   /// Hooks to inform others about progress done by this loader.
   // TODO(sigmund): move away from this.
   final LibraryLoaderListener listener;
 
   /// Definitions provided via the `-D` command line flags. Used to resolve
   /// conditional imports.
   final Environment environment;
 
+  List<DeferredAction> _deferredActions = <DeferredAction>[];
+
   final DiagnosticReporter reporter;
 
   _LibraryLoaderTask(
       this.uriTranslator,
       this.scriptLoader,
       this.scanner,
       this.deserializer,
       this.listener,
       this.environment,
       this.reporter,
@@ skipping 438 matching lines @@
   CompilationUnitElement createUnitSync(Script script, LibraryElement library) {
     CompilationUnitElementX unit = new CompilationUnitElementX(script, library);
     reporter.withCurrentElement(unit, () {
       scanner.scanUnit(unit);
       if (unit.partTag == null && !script.isSynthesized) {
         reporter.reportErrorMessage(unit, MessageKind.MISSING_PART_OF_TAG);
       }
     });
     return unit;
   }
+
+  void registerDeferredAction(DeferredAction action) {
+    _deferredActions.add(action);
+  }
+
+  Iterable<DeferredAction> pullDeferredActions() {
+    Iterable<DeferredAction> actions = _deferredActions.toList();
+    _deferredActions.clear();
+    return actions;
+  }
 }
 
 /// A state machine for checking script tags come in the correct order.
 class TagState {
   /// Initial state.
   static const int NO_TAG_SEEN = 0;
 
   /// Passed to [checkTag] when a library declaration (the syntax "library
   /// name;") has been seen. Not an actual state.
   static const int LIBRARY = 1;
@@ skipping 745 matching lines @@
   Future onLibrariesLoaded(LoadedLibraries results);
 
   /// Called whenever a library element is created.
   void onLibraryCreated(LibraryElement library);
 
   /// Called whenever a library is scanned from a script file.
   Future onLibraryScanned(LibraryElement library, LibraryLoader loader);
 }
 
 const _reuseLibrarySubtaskName = "Reuse library";