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'));

[Siggi Cherem (dart-lang), 2017/01/27 21:55:51]

this came up in the context of my other CL where I'm running the
kernel-service.dart through the frontend. 

I thought we were going to need to pass in a list of core libraries to load, but
I'm not certain at this point that it will be needed, so I opted for this
temporary exception until we figure that out.

+  }
   // 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 = {};
+
+  String resolve(Uri patch) =>
+    options.fileSystem.context.fromUri(options.sdkRoot.resolveUri(patch));

[Siggi Cherem (dart-lang), 2017/01/27 21:55:51]

you'll see in the other CL that this is not used yet, I'm using only absolute
URIs, the reason is that none of the VM patches are shipped with the SDK today.
That needs to change in the future.

[Paul Berry, 2017/01/27 22:49:19]

Add a TODO comment here: we should switch this code over to using
ProcessedOptions so that we can resolve the URIs correctly even if the SDK root
is not directly specified (in some cases it will be automatically inferred).

You can assign the TODO to me if you want.

[Siggi Cherem (dart-lang), 2017/01/27 23:00:19]

Done.

+
+  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);
 }