Add "load from .dill" file capability and run a white-box test.

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/entities.dart' show LibraryEntity;
 import 'elements/modelx.dart'
     show
         CompilationUnitElementX,
         DeferredLoaderGetterElementX,
         ErroneousElementX,
         ExportElementX,
         ImportElementX,
         LibraryElementX,
         LibraryDependencyElementX,
         PrefixElementX,
         SyntheticImportElement;
 import 'enqueue.dart' show DeferredAction;
 import 'environment.dart';
+import 'kernel/world_builder.dart' show KernelWorldBuilder;
 import 'patch_parser.dart' show PatchParserTask;
 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;
 
+import 'package:kernel/ast.dart' as ir;
+import 'package:kernel/binary/ast_from_binary.dart' show BinaryBuilder;
+
 typedef Future<Iterable<LibraryElement>> ReuseLibrariesFunction(
     Iterable<LibraryElement> libraries);
 
 typedef Uri PatchResolverFunction(String dartLibraryPath);
 
 /**
  * [CompilerTask] for loading libraries and setting up the import/export scopes.
  *
  * The library loader uses four different kinds of URIs in different parts of
  * the loading process.
@@ skipping 81 matching lines @@
  *
  *     import 'package:foo.dart' as a;
  *     import 'packages/foo.dart' as b;
  *
  * do _not_ resolve to the same library when the package root URI happens to
  * point to the 'packages' folder.
  *
  */
 abstract class LibraryLoaderTask implements LibraryProvider, CompilerTask {
   factory LibraryLoaderTask(
-      ResolvedUriTranslator uriTranslator,
-      ScriptLoader scriptLoader,
-      ElementScanner scriptScanner,
-      LibraryDeserializer deserializer,
-      PatchResolverFunction patchResolverFunc,
-      PatchParserTask patchParser,
-      Environment environment,
-      DiagnosticReporter reporter,
-      Measurer measurer) = _LibraryLoaderTask;
+          bool loadFromDillFile,
+          ResolvedUriTranslator uriTranslator,
+          ScriptLoader scriptLoader,
+          ElementScanner scriptScanner,
+          LibraryDeserializer deserializer,
+          PatchResolverFunction patchResolverFunc,
+          PatchParserTask patchParser,
+          Environment environment,
+          DiagnosticReporter reporter,
+          Measurer measurer) =>
+      loadFromDillFile
+          ? new _DillLibraryLoaderTask(
+              uriTranslator, scriptLoader, reporter, measurer)
+          : new _LibraryLoaderTask(
+              uriTranslator,
+              scriptLoader,
+              scriptScanner,
+              deserializer,
+              patchResolverFunc,
+              patchParser,
+              environment,
+              reporter,
+              measurer);
 
   /// Returns all libraries that have been loaded.
-  Iterable<LibraryElement> get libraries;
+  Iterable<LibraryEntity> get libraries;
 
   /// Loads the library specified by the [resolvedUri] and returns the
   /// [LoadedLibraries] that were loaded to load the specified uri. The
   /// [LibraryElement] itself can be found by calling
   /// `loadedLibraries.rootLibrary`.
   ///
   /// If the library is not already loaded, the method creates the
   /// [LibraryElement] for the library and computes the import/export scope,
   /// loading and computing the import/export scopes of all required libraries
   /// in the process. The method handles cyclic dependency between libraries.
@@ skipping 42 matching lines @@
 
   /// Returns the location of the patch-file associated with [libraryName]
   /// resolved from [plaformConfigUri].
   ///
   /// Returns null if there is none.
   static Uri resolvePatchUri(String libraryName, Uri platformConfigUri) {
     String patchLocation = _patchLocations[libraryName];
     if (patchLocation == null) return null;
     return platformConfigUri.resolve(patchLocation);
   }
+
+  /// This is horrible temporary addition to the API that is only useful if we
+  /// are loading kernel files. Otherwise this returns null.
+  KernelWorldBuilder get worldBuilder;
 }
 
 /// 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);
+  LibraryEntity lookupLibrary(Uri canonicalUri);
 }
 
 /// Handle for creating synthesized/patch libraries during library loading.
 abstract class LibraryLoader {
   /// This method must be called when a new synthesized/patch library has been
   /// created to ensure that [library] will part of library dependency graph
   /// used for computing import/export scopes.
   void registerNewLibrary(LibraryElement library);
 
   /// This method must be called when a new synthesized/patch library has been
@@ skipping 133 matching lines @@
 
   String get name => 'LibraryLoader';
 
   final Map<Uri, LibraryElement> libraryCanonicalUriMap =
       new Map<Uri, LibraryElement>();
   final Map<Uri, LibraryElement> libraryResourceUriMap =
       new Map<Uri, LibraryElement>();
   final Map<String, LibraryElement> libraryNames =
       new Map<String, LibraryElement>();
 
-  Iterable<LibraryElement> get libraries => libraryCanonicalUriMap.values;
+  Iterable<LibraryEntity> get libraries => libraryCanonicalUriMap.values;
 
-  LibraryElement lookupLibrary(Uri canonicalUri) {
+  LibraryEntity lookupLibrary(Uri canonicalUri) {
     return libraryCanonicalUriMap[canonicalUri];
   }
 
   void reset({bool reuseLibrary(LibraryElement library)}) {
     measure(() {
       Iterable<LibraryElement> reusedLibraries = null;
       if (reuseLibrary != null) {
         reusedLibraries = measureSubtask(_reuseLibrarySubtaskName, () {
           // Call [toList] to force eager calls to [reuseLibrary].
           return libraryCanonicalUriMap.values.where(reuseLibrary).toList();
@@ skipping 77 matching lines @@
       {bool skipFileWithPartOfTag: false}) {
     return measure(() async {
       LibraryDependencyHandler handler = new LibraryDependencyHandler(this);
       LibraryElement library = await createLibrary(
           handler, null, resolvedUri, NO_LOCATION_SPANNABLE,
           skipFileWithPartOfTag: skipFileWithPartOfTag);
       if (library == null) return null;
       return reporter.withCurrentElement(library, () {
         return measure(() {
           handler.computeExports();
-          return new _LoadedLibraries(library, handler.newLibraries, this);
+          return new _LoadedLibraries(library, handler.newLibraries);
         });
       });
     });
   }
 
   /**
    * Processes the library tags in [library].
    *
    * The imported/exported libraries are loaded and processed recursively but
    * the import/export scopes are not set up.
@@ skipping 316 matching lines @@
 
   void registerDeferredAction(DeferredAction action) {
     _deferredActions.add(action);
   }
 
   Iterable<DeferredAction> pullDeferredActions() {
     Iterable<DeferredAction> actions = _deferredActions.toList();
     _deferredActions.clear();
     return actions;
   }
+
+  KernelWorldBuilder get worldBuilder => null;
+}
+
+/// A task for loading a pre-processed .dill file into memory rather than
+/// parsing Dart source. Use of this task only makes sense when used in
+/// conjunction with --use-kernel.
+class _DillLibraryLoaderTask extends CompilerTask implements LibraryLoaderTask {
+  final DiagnosticReporter reporter;
+
+  final ResolvedUriTranslator uriTranslator;
+
+  /// Loads the contents of a script file (a .dart file). Used when loading
+  /// libraries from source.
+  final ScriptLoader scriptLoader;
+
+  /// Holds the mapping of Kernel IR to KElements that is constructed as a
+  /// result of loading a program.
+  KernelWorldBuilder _worldBuilder;
+
+  List<LibraryEntity> _allLoadedLibraries;
+
+  _DillLibraryLoaderTask(
+      this.uriTranslator, this.scriptLoader, this.reporter, Measurer measurer)
+      : _allLoadedLibraries = new List<LibraryEntity>(),
+        super(measurer);
+
+  /// Loads an entire Kernel [Program] from a file on disk (note, not just a
+  /// library, so this name is actuall a bit of a misnomer).
+  // TODO(efortuna): Rename this once the Element library loader class goes
+  // away.
+  Future<LoadedLibraries> loadLibrary(Uri resolvedUri,
+      {bool skipFileWithPartOfTag: false}) {
+    assert(resolvedUri.pathSegments.last.endsWith('.dill'));
+    Uri readableUri = uriTranslator.translate(null, resolvedUri, null);
+    return measure(() async {
+      Script script = await scriptLoader.readScript(readableUri, null);
+      ir.Program program = new ir.Program();
+      // Hack because the existing file has a terminating 0 and the
+      // BinaryBuilder doesn't expect that.
+      var bytes = new List<int>.from(script.file.slowUtf8ZeroTerminatedBytes());
+      bytes.removeLast();
+      new BinaryBuilder(bytes).readProgram(program);
+      return measure(() {
+        _worldBuilder = new KernelWorldBuilder(reporter, program);
+        program.libraries.forEach((ir.Library library) => _allLoadedLibraries
+            .add(_worldBuilder.lookupLibrary(library.importUri)));
+        // TODO(efortuna): Handle `prgram.mainMethod == null` gracefully.
+        return new _LoadedLibrariesAdapter(
+            _worldBuilder
+                .lookupLibrary(program.mainMethod.enclosingLibrary.importUri),
+            _allLoadedLibraries,
+            _worldBuilder);
+      });
+    });
+  }
+
+  KernelWorldBuilder get worldBuilder => _worldBuilder;
+
+  void reset({bool reuseLibrary(LibraryElement library)}) {
+    throw new UnimplementedError('_DillLibraryLoaderTask.reset');
+  }
+
+  Future resetAsync(Future<bool> reuseLibrary(LibraryElement library)) {
+    throw new UnimplementedError('_DillLibraryLoaderTask.resetAsync');
+  }
+
+  Iterable<LibraryEntity> get libraries => _allLoadedLibraries;
+
+  LibraryEntity lookupLibrary(Uri canonicalUri) {
+    return _worldBuilder?.lookupLibrary(canonicalUri);
+  }
+
+  Future<Null> resetLibraries(ReuseLibrariesFunction reuseLibraries) {
+    throw new UnimplementedError('_DillLibraryLoaderTask.reuseLibraries');
+  }
+
+  void registerDeferredAction(DeferredAction action) {
+    throw new UnimplementedError(
+        '_DillLibraryLoaderTask.registerDeferredAction');
+  }
+
+  Iterable<DeferredAction> pullDeferredActions() {
+    throw new UnimplementedError('_DillLibraryLoaderTask.pullDeferredActions');
+  }
 }
 
 /// 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 553 matching lines @@
   Future processLibraryTags(LibraryElement library) {
     return task.processLibraryTags(this, library);
   }
 }
 
 /// Information on the set libraries loaded as a result of a call to
 /// [LibraryLoader.loadLibrary].
 abstract class LoadedLibraries {
   /// The accesss the library object created corresponding to the library
   /// passed to [LibraryLoader.loadLibrary].
-  LibraryElement get rootLibrary;
+  LibraryEntity get rootLibrary;
 
   /// Returns `true` if a library with canonical [uri] was loaded in this bulk.
   bool containsLibrary(Uri uri);
 
   /// Returns the library with canonical [uri] that was loaded in this bulk.
-  LibraryElement getLibrary(Uri uri);
+  LibraryEntity getLibrary(Uri uri);
 
   /// Applies all libraries in this bulk to [f].
-  void forEachLibrary(f(LibraryElement library));
+  void forEachLibrary(f(LibraryEntity library));
 
   /// Applies all imports chains of [uri] in this bulk to [callback].
   ///
   /// The argument [importChainReversed] to [callback] contains the chain of
   /// imports uris that lead to importing [uri] starting in [uri] and ending in
   /// the uri that was passed in with [loadLibrary].
   ///
   /// [callback] is called once for each chain of imports leading to [uri] until
   /// [callback] returns `false`.
   void forEachImportChain(Uri uri,
       {bool callback(Link<Uri> importChainReversed)});
 }
 
 class _LoadedLibraries implements LoadedLibraries {
-  final _LibraryLoaderTask task;
   final LibraryElement rootLibrary;
   final Map<Uri, LibraryElement> loadedLibraries = <Uri, LibraryElement>{};
   final List<LibraryElement> _newLibraries;
 
-  _LoadedLibraries(this.rootLibrary, this._newLibraries, this.task) {
+  _LoadedLibraries(this.rootLibrary, this._newLibraries) {
     _newLibraries.forEach((LibraryElement loadedLibrary) {
       loadedLibraries[loadedLibrary.canonicalUri] = loadedLibrary;
     });
     assert(rootLibrary != null);
   }
 
   bool containsLibrary(Uri uri) => loadedLibraries.containsKey(uri);
 
   LibraryElement getLibrary(Uri uri) => loadedLibraries[uri];
 
@@ skipping 72 matching lines @@
       suffixChainMap[library] = suffixes;
       return;
     }
 
     computeSuffixes(rootLibrary, const Link<Uri>());
   }
 
   String toString() => 'root=$rootLibrary,libraries=${_newLibraries}';
 }
 
+/// Adapter class to mimic the behavior of LoadedLibraries for Kernel element
+/// behavior. Ultimately we'll just access worldBuilder instead.
+class _LoadedLibrariesAdapter implements LoadedLibraries {
+  final LibraryEntity rootLibrary;
+  final List<LibraryEntity> _newLibraries;
+  final KernelWorldBuilder worldBuilder;
+
+  _LoadedLibrariesAdapter(
+      this.rootLibrary, this._newLibraries, this.worldBuilder) {
+    assert(rootLibrary != null);
+  }
+
+  bool containsLibrary(Uri uri) => getLibrary(uri) != null;
+
+  LibraryEntity getLibrary(Uri uri) => worldBuilder.lookupLibrary(uri);
+
+  void forEachLibrary(f(LibraryEntity library)) => _newLibraries.forEach(f);
+
+  void forEachImportChain(Uri uri,
+      {bool callback(Link<Uri> importChainReversed)}) {
+    // Currently a no-op. This seems wrong.
+  }
+
+  String toString() => 'root=$rootLibrary,libraries=${_newLibraries}';
+}
+
 // TODO(sigmund): remove ScriptLoader & ElementScanner. Such abstraction seems
 // rather low-level. It might be more practical to split the library-loading
 // task itself.  The task would continue to do the work of recursively loading
 // dependencies, but it can delegate to a set of subloaders how to do the actual
 // loading. We would then have a list of subloaders that use different
 // implementations: in-memory cache, deserialization, scanning from files.
 //
 // For example, the API might look like this:
 //
 // /// APIs to create [LibraryElement] and [CompilationUnitElements] given it's
@@ skipping 33 matching lines @@
 }
 
 /// API used by the library loader to synchronously scan a library or
 /// compilation unit and ensure that their library tags are computed.
 abstract class ElementScanner {
   void scanLibrary(LibraryElement library);
   void scanUnit(CompilationUnitElement unit);
 }
 
 const _reuseLibrarySubtaskName = "Reuse library";