Reapply "Tweak public APIs and use them in patch_sdk, dart2js, and kernel-service.""

pkg/front_end/lib/src/fasta/testing/kernel_chain.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.md file.
 
 // TODO(ahe): Copied from closure_conversion branch of kernel, remove this file
 // when closure_conversion is merged with master.
 
 library fasta.testing.kernel_chain;
 
 import 'dart:async' show Future;
@@ skipping 10 matching lines @@
 
 import 'package:kernel/ast.dart' show Library, Program;
 
 import '../kernel/verifier.dart' show verifyProgram;
 
 import 'package:kernel/binary/ast_to_binary.dart' show BinaryPrinter;
 
 import 'package:kernel/binary/ast_from_binary.dart' show BinaryBuilder;
 
 import 'package:testing/testing.dart'
-    show ChainContext, Result, StdioProcess, Step;
+    show ChainContext, Result, StdioProcess, Step, TestDescription;
 
 import 'package:kernel/ast.dart' show Program;
 
+import 'package:front_end/front_end.dart';
+
+import 'patched_sdk_location.dart' show computePatchedSdk;
+
 class Print extends Step<Program, Program, ChainContext> {
   const Print();
 
   String get name => "print";
 
   Future<Result<Program>> run(Program program, _) async {
     StringBuffer sb = new StringBuffer();
     for (Library library in program.libraries) {
       Printer printer = new Printer(sb);
       if (library.importUri.scheme != "dart" &&
@@ skipping 118 matching lines @@
   Future<Result<Program>> run(Program program, _) async {
     BytesCollector sink = new BytesCollector();
     new BinaryPrinter(sink).writeProgramFile(program);
     program.unbindCanonicalNames();
     Uint8List bytes = sink.collect();
     new BinaryBuilder(bytes).readProgram(program);
     return pass(program);
   }
 }
 
+/// A `package:testing` step that runs the `package:front_end` compiler to
+/// generate a kernel program for an individual file.
+///
+/// Most options are hard-coded, but if necessary they could be moved to the
+/// [CompileContext] object in the future.
+class Compile extends Step<TestDescription, Program, CompileContext> {
+  const Compile();
+
+  String get name => "fasta compilation";
+
+  Future<Result<Program>> run(
+      TestDescription description, CompileContext context) async {
+    Result<Program> result;
+    reportError(CompilationError error) {
+      result ??= fail(null, error.message);
+    }
+
+    Uri sdk = await computePatchedSdk();
+    Program p = await kernelForProgram(
+        description.uri,
+        new CompilerOptions()
+          ..sdkRoot = sdk
+          ..packagesFileUri = Uri.base.resolve('.packages')
+          ..strongMode = context.strongMode
+          ..linkedDependencies = [sdk.resolve('platform.dill')]
+          ..onError = reportError);
+    return result ??= pass(p);
+  }
+}
+
+abstract class CompileContext implements ChainContext {
+  bool get strongMode;
+}
+
 class BytesCollector implements Sink<List<int>> {
   final List<List<int>> lists = <List<int>>[];
 
   int length = 0;
 
   void add(List<int> data) {
     lists.add(data);
     length += data.length;
   }
 
@@ skipping 20 matching lines @@
 
 Future openWrite(Uri uri, f(IOSink sink)) async {
   IOSink sink = new File.fromUri(uri).openWrite();
   try {
     await f(sink);
   } finally {
     await sink.close();
   }
   print("Wrote $uri");
 }