Add FrontEndStrategy, ResolutionFrontEndStrategy and KernelFrontEndStrategy

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;
@@ skipping 123 matching lines @@
  * that these imports
  *
  *     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);
-
   /// Returns all libraries that have been loaded.
   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,
@@ skipping 148 matching lines @@
  * A list of combinators represented as a list of element names to exclude.
  */
 class HideFilter extends CombinatorFilter {
   final Set<String> excludedNames;
 
   HideFilter(this.excludedNames);
 
   bool exclude(Element element) => excludedNames.contains(element.name);
 }
 
-/// Implementation class for [LibraryLoaderTask]. The distinction between
-/// [LibraryLoaderTask] and [_LibraryLoaderTask] is made to hide internal
-/// members from the [LibraryLoaderTask] interface.
-class _LibraryLoaderTask extends CompilerTask implements LibraryLoaderTask {
+/// Implementation class for [LibraryLoaderTask]. This library loader loads
+/// '.dart' files into the [Element] model with AST nodes which are resolved
+/// by the resolver.
+class ResolutionLibraryLoaderTask extends CompilerTask
+    implements LibraryLoaderTask {
   /// Translates internal uris (like dart:core) to a disk location.
   final ResolvedUriTranslator uriTranslator;
 
   /// Loads the contents of a script file (a .dart file). Used when loading
   /// libraries from source.
   final ScriptLoader scriptLoader;
 
   /// Provides a diet element model from a script file containing information
   /// about imports and exports. Used when loading libraries from source.
   final ElementScanner scanner;
@@ skipping 12 matching lines @@
   /// Function that accepts the string name of a library and returns the
   /// path to the corresponding patch file. This is a function that is passed in
   /// because our test mock_compiler subclasses compiler.
   // TODO(efortuna): Refactor mock_compiler to not do this.
   final PatchResolverFunction _patchResolverFunc;
 
   List<DeferredAction> _deferredActions = <DeferredAction>[];
 
   final DiagnosticReporter reporter;
 
-  _LibraryLoaderTask(
+  ResolutionLibraryLoaderTask(
       this.uriTranslator,
       this.scriptLoader,
       this.scanner,
       this.deserializer,
       this._patchResolverFunc,
       this._patchParserTask,
       this.environment,
       this.reporter,
       Measurer measurer)
       : super(measurer);
@@ skipping 442 matching lines @@
   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 {
+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;
+  final KernelWorldBuilder _worldBuilder;
 
   List<LibraryEntity> _allLoadedLibraries;
 
-  _DillLibraryLoaderTask(
-      this.uriTranslator, this.scriptLoader, this.reporter, Measurer measurer)
+  DillLibraryLoaderTask(this._worldBuilder, 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);
+        _worldBuilder.addProgram(program);
         program.libraries.forEach((ir.Library library) => _allLoadedLibraries
             .add(_worldBuilder.lookupLibrary(library.importUri)));
         LibraryEntity rootLibrary = null;
         if (program.mainMethod != null) {
           rootLibrary = _worldBuilder
               .lookupLibrary(program.mainMethod.enclosingLibrary.importUri);
         }
         return new _LoadedLibrariesAdapter(
             rootLibrary, _allLoadedLibraries, _worldBuilder);
       });
     });
   }
 
   KernelWorldBuilder get worldBuilder => _worldBuilder;
 
   void reset({bool reuseLibrary(LibraryElement library)}) {
-    throw new UnimplementedError('_DillLibraryLoaderTask.reset');
+    throw new UnimplementedError('DillLibraryLoaderTask.reset');
   }
 
   Future resetAsync(Future<bool> reuseLibrary(LibraryElement library)) {
-    throw new UnimplementedError('_DillLibraryLoaderTask.resetAsync');
+    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');
+    throw new UnimplementedError('DillLibraryLoaderTask.reuseLibraries');
   }
 
   void registerDeferredAction(DeferredAction action) {
     throw new UnimplementedError(
-        '_DillLibraryLoaderTask.registerDeferredAction');
+        'DillLibraryLoaderTask.registerDeferredAction');
   }
 
   Iterable<DeferredAction> pullDeferredActions() {
-    throw new UnimplementedError('_DillLibraryLoaderTask.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.
@@ skipping 423 matching lines @@
 
 /**
  * Helper class used for computing the possibly cyclic import/export scopes of
  * a set of libraries.
  *
  * This class is used by [ScannerTask.scanLibrary] to collect all newly loaded
  * libraries and to compute their import/export scopes through a fixed-point
  * algorithm.
  */
 class LibraryDependencyHandler implements LibraryLoader {
-  final _LibraryLoaderTask task;
+  final ResolutionLibraryLoaderTask task;
   final List<LibraryElement> _newLibraries = <LibraryElement>[];
 
   /**
    * Newly loaded libraries and their corresponding node in the library
    * dependency graph. Libraries that have already been fully loaded are not
    * part of the dependency graph of this handler since their export scopes have
    * already been computed.
    */
   Map<LibraryElement, LibraryDependencyNode> nodeMap =
       new Map<LibraryElement, LibraryDependencyNode>();
@@ skipping 310 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";