Extend front_end API to accept patch files

pkg/front_end/lib/kernel_generator.dart

 // Copyright (c) 2016, 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.
 
 /// Defines the front-end API for converting source code to Dart Kernel objects.
 library front_end.kernel_generator;
 
 import 'compilation_error.dart';
 import 'compiler_options.dart';
 import 'dart:async';
@@ skipping 19 matching lines @@
 /// code for the SDK.
 ///
 /// If summaries are provided in [options], they may be used to speed up
 /// analysis. If in addition `compileSdk` is false, this will speed up
 /// compilation, as no source of the sdk will be generated.  Note however, that
 /// summaries for application code can also speed up analysis, but they will not
 /// take the place of Dart source code (since the Dart source code is still
 /// needed to access the contents of method bodies).
 Future<Program> kernelForProgram(Uri source, CompilerOptions options) async {
   var loader = await _createLoader(options, entry: source);
+  // TODO(sigmund): delete this. At this time we have no need to explicitly list
+  // VM libraries, since they are normally found by chasing dependencies.
+  // `dart:_builtin` is an exception because it is used by the kernel
+  // transformers to inform the VM about where the main entrypoint is. This is
+  // expected to change, and we should be able to remove these lines at that
+  // point. We check for the presense of `dart:developer` in the targetPatches
+  // to ensure we only load this library while running on the VM.
+  if (options.compileSdk &&
+      options.targetPatches.containsKey(Uri.parse('dart:developer'))) {
+    loader.loadLibrary(Uri.parse('dart:_builtin'));
+  }
   // TODO(sigmund): merge what we have in loadEverything and the logic below in
   // kernelForBuildUnit so there is a single place where we crawl for
   // dependencies.
   Program program = loader.loadProgram(source, compileSdk: options.compileSdk);
   _reportErrors(loader.errors, options.onError);
   return program;
 }
 
 /// Generates a kernel representation for a build unit.
 ///
@@ skipping 74 matching lines @@
 /// Create a [DartLoader] using the provided [options].
 ///
 /// If [options] contain no configuration to resolve `.packages`, the [entry]
 /// file will be used to search for a `.packages` file.
 Future<DartLoader> _createLoader(CompilerOptions options,
     {Repository repository, Uri entry}) async {
   var kernelOptions = _convertOptions(options);
   var packages = await createPackages(
       _uriToPath(options.packagesFileUri, options),
       discoveryPath: entry?.path);
-  return new DartLoader(
+  var loader = new DartLoader(
       repository ?? new Repository(), kernelOptions, packages);
+  var patchPaths = {};
+
+  // TODO(sigmund,paulberry): use ProcessedOptions so that we can resolve the
+  // URIs correctly even if sdkRoot is inferred and not specified explicitly.
+  String resolve(Uri patch) =>
+    options.fileSystem.context.fromUri(options.sdkRoot.resolveUri(patch));
+
+  options.targetPatches.forEach((uri, patches) {
+    patchPaths['$uri'] = patches.map(resolve).toList();
+  });
+  loader.context.analysisOptions.patchPaths = patchPaths;
+  return loader;
 }
 
 DartOptions _convertOptions(CompilerOptions options) {
   return new DartOptions(
       strongMode: options.strongMode,
       sdk: _uriToPath(options.sdkRoot, options),
       // TODO(sigmund): make it possible to use summaries and still compile the
       // sdk sources.
       sdkSummary:
           options.compileSdk ? null : _uriToPath(options.sdkSummary, options),
       packagePath: _uriToPath(options.packagesFileUri, options),
+      customUriMappings: options.uriOverride,
       declaredVariables: options.declaredVariables);
 }
 
 void _reportErrors(List errors, ErrorHandler onError) {
   if (onError == null) return;
   for (var error in errors) {
     onError(new _DartkError(error));
   }
 }
 
 String _uriToPath(Uri uri, CompilerOptions options) {
   if (uri == null) return null;
   if (uri.scheme != 'file') {
     throw new StateError('Only file URIs are supported');
   }
   return options.fileSystem.context.fromUri(uri);
 }
 
 // TODO(sigmund): delete this class. Dartk should not format errors itself, we
 // should just pass them along.
 class _DartkError implements CompilationError {
   String get correction => null;
   SourceSpan get span => null;
   final String message;
   _DartkError(this.message);
 }