Add support for compiling Dart via the FE in dart2js.

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 'dart:io' show Platform;
+
+import 'package:front_end/front_end.dart' as fe;
+import 'package:kernel/ast.dart' as ir;
+import 'package:kernel/binary/ast_from_binary.dart' show BinaryBuilder;
+import 'package:kernel/kernel.dart' hide LibraryDependency, Combinator;
+import 'package:kernel/target/targets.dart';
+
+import '../compiler_new.dart' as api;
+import 'kernel/front_end_adapter.dart';
+import 'kernel/dart2js_target.dart' show Dart2jsTarget;
 
 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,
@@ skipping 14 matching lines @@
 import 'environment.dart';
 import 'io/source_file.dart' show Binary;
 import 'kernel/element_map_impl.dart' show KernelToElementMapForImpactImpl;
 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 745 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 {
+/// A loader that builds a kernel IR representation of the program (or set of
+/// libraries).
+///
+/// It supports loading both .dart source files or pre-compiled .dill files.
+/// When given .dart source files, it invokes the shared frontend
+/// (`package:front_end`) to produce the corresponding kernel IR representation.
+// TODO(sigmund): move this class to a new file under src/kernel/.
+class KernelLibraryLoaderTask 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;
+  final api.CompilerInput compilerInput;
 
   /// Holds the mapping of Kernel IR to KElements that is constructed as a
   /// result of loading a program.
   final KernelToElementMapForImpactImpl _elementMap;
 
   List<LibraryEntity> _allLoadedLibraries;
 
-  DillLibraryLoaderTask(this._elementMap, this.uriTranslator, this.scriptLoader,
-      this.reporter, Measurer measurer)
+  KernelLibraryLoaderTask(
+      this._elementMap, this.compilerInput, 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 actually 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'),
-        'Invalid uri: $resolvedUri');
-    Uri readableUri = uriTranslator.translate(null, resolvedUri, null);
     return measure(() async {
-      Binary binary = await scriptLoader.readBinary(readableUri, null);
-      ir.Program program = new ir.Program();
-      new BinaryBuilder(binary.data).readProgram(program);
-      return measure(() {
-        return createLoadedLibraries(program);
-      });
+      var isDill = resolvedUri.path.endsWith('.dill');
+      ir.Program program;
+      if (isDill) {
+        api.Input input = await compilerInput.readFromUri(resolvedUri,
+            inputKind: api.InputKind.binary);
+        program = new ir.Program();
+        new BinaryBuilder(input.data).readProgram(program);
+      } else {
+        var options = new fe.CompilerOptions()
+          ..fileSystem = new CompilerFileSystem(compilerInput)
+          ..target = new Dart2jsTarget(new TargetFlags())
+          ..compileSdk = true
+          ..linkedDependencies = [
+            // TODO(sigmund): infer the location of platform.dill
+            // once it is shipped as part of the sdk.
+            new Uri.file(Platform.resolvedExecutable)
+                .resolve('patched_dart2js_sdk/platform.dill')
+          ]
+          ..onError = (e) => reportFrontEndMessage(reporter, e);
+
+        program = await fe.kernelForProgram(resolvedUri, options);
+      }
+      if (program == null) return null;
+      return createLoadedLibraries(program);
     });
   }
 
+  // Only visible for unit testing.
   LoadedLibraries createLoadedLibraries(ir.Program program) {
     _elementMap.addProgram(program);
     program.libraries.forEach((ir.Library library) =>
         _allLoadedLibraries.add(_elementMap.lookupLibrary(library.importUri)));
     LibraryEntity rootLibrary = null;
     if (program.mainMethod != null) {
       rootLibrary = _elementMap
           .lookupLibrary(program.mainMethod.enclosingLibrary.importUri);
     }
     return new _LoadedLibrariesAdapter(
         rootLibrary, _allLoadedLibraries, _elementMap);
   }
 
   KernelToElementMapForImpactImpl get elementMap => _elementMap;
 
   void reset({bool reuseLibrary(LibraryElement library)}) {
-    throw new UnimplementedError('DillLibraryLoaderTask.reset');
+    throw new UnimplementedError('KernelLibraryLoaderTask.reset');
   }
 
   Future resetAsync(Future<bool> reuseLibrary(LibraryElement library)) {
-    throw new UnimplementedError('DillLibraryLoaderTask.resetAsync');
+    throw new UnimplementedError('KernelLibraryLoaderTask.resetAsync');
   }
 
   Iterable<LibraryEntity> get libraries => _allLoadedLibraries;
 
   LibraryEntity lookupLibrary(Uri canonicalUri) {
     return _elementMap?.lookupLibrary(canonicalUri);
   }
 
   Future<Null> resetLibraries(ReuseLibrariesFunction reuseLibraries) {
-    throw new UnimplementedError('DillLibraryLoaderTask.reuseLibraries');
+    throw new UnimplementedError('KernelLibraryLoaderTask.reuseLibraries');
   }
 
   void registerDeferredAction(DeferredAction action) {
     throw new UnimplementedError(
-        'DillLibraryLoaderTask.registerDeferredAction');
+        'KernelLibraryLoaderTask.registerDeferredAction');
   }
 
   Iterable<DeferredAction> pullDeferredActions() => const <DeferredAction>[];
 }
 
 /// A state machine for checking script tags come in the correct order.
 class TagState {
   /// Initial state.
   static const int NO_TAG_SEEN = 0;
 
@@ skipping 769 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";