Unifying compiler context

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;
 
 import 'dart:io' show Directory, File, IOSink;
 
 import 'dart:typed_data' show Uint8List;
 
 import 'package:kernel/kernel.dart' show loadProgramFromBinary;
 
 import 'package:kernel/target/targets.dart' show Target;
 
 import 'package:kernel/text/ast_to_text.dart' show Printer;
 
 import 'package:testing/testing.dart' show Result, StdioProcess, Step;
 
 import 'package:kernel/ast.dart' show Library, Program;
 
 import '../kernel/verifier.dart' show verifyProgram;
 
-import '../compiler_command_line.dart';
+import '../compiler_context.dart';
 
 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, TestDescription;
 
 import 'package:kernel/ast.dart' show Program;
 
 import 'package:front_end/front_end.dart';
 
+import 'package:front_end/src/base/processed_options.dart'
+    show ProcessedOptions;
+
 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" &&
           library.importUri.scheme != "package") {
         printer.writeLibraryFile(library);
       }
     }
     print("$sb");
     return pass(program);
   }
 }
 
 class Verify extends Step<Program, Program, ChainContext> {
   final bool fullCompile;
 
   const Verify(this.fullCompile);
 
   String get name => "verify";
 
   Future<Result<Program>> run(Program program, ChainContext context) async {
-    return await CompilerCommandLine.withGlobalOptions("", [""], (_) async {
+    var options =
+        new ProcessedOptions(new CompilerOptions()..throwOnErrors = false);
+    return await CompilerContext.runWithOptions(options, (_) async {
       var errors = verifyProgram(program, isOutline: !fullCompile);
       if (errors.isEmpty) {
         return pass(program);
       } else {
         return new Result<Program>(
             null, context.expectationSet["VerificationError"], errors, null);
       }
     });
   }
 }
@@ skipping 103 matching lines @@
 /// 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) {
+    reportError(CompilationMessage error) {
       result ??= fail(null, error.message);
     }
 
     Uri sdk = await computePatchedSdk();
     var options = new CompilerOptions()
       ..sdkRoot = sdk
       ..compileSdk = true
       ..packagesFileUri = Uri.base.resolve('.packages')
       ..strongMode = context.strongMode
       ..onError = reportError;
@@ skipping 48 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");
 }