Revert "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(
-          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);
+      ResolvedUriTranslator uriTranslator,
+      ScriptLoader scriptLoader,
+      ElementScanner scriptScanner,
+      LibraryDeserializer deserializer,
+      PatchResolverFunction patchResolverFunc,
+      PatchParserTask patchParser,
+      Environment environment,
+      DiagnosticReporter reporter,
+      Measurer measurer) = _LibraryLoaderTask;
 
   /// Returns all libraries that have been loaded.
-  Iterable<LibraryEntity> get libraries;
+  Iterable<LibraryElement> 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 49 matching lines @@
     if (patchLocation == null) return null;
     return platformConfigUri.resolve(patchLocation);
   }
 }
 
 /// 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].
-  LibraryEntity lookupLibrary(Uri canonicalUri);
+  LibraryElement 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<LibraryEntity> get libraries => libraryCanonicalUriMap.values;
+  Iterable<LibraryElement> get libraries => libraryCanonicalUriMap.values;
 
-  LibraryEntity lookupLibrary(Uri canonicalUri) {
+  LibraryElement 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);
+          return new _LoadedLibraries(library, handler.newLibraries, this);
         });
       });
     });
   }
 
   /**
    * 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 318 matching lines @@
     _deferredActions.add(action);
   }
 
   Iterable<DeferredAction> pullDeferredActions() {
     Iterable<DeferredAction> actions = _deferredActions.toList();
     _deferredActions.clear();
     return actions;
   }
 }
 
-/// 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;
 
   /// The state after the first library declaration.
@@ skipping 551 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].
-  LibraryEntity get rootLibrary;
+  LibraryElement 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.
-  LibraryEntity getLibrary(Uri uri);
+  LibraryElement getLibrary(Uri uri);
 
   /// Applies all libraries in this bulk to [f].
-  void forEachLibrary(f(LibraryEntity library));
+  void forEachLibrary(f(LibraryElement 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) {
+  _LoadedLibraries(this.rootLibrary, this._newLibraries, this.task) {
     _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";