Use messages for (some) public API errors

pkg/front_end/lib/src/kernel_generator_impl.dart

 // Copyright (c) 2017, 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_impl;
 
 import 'dart:async' show Future;
 import 'dart:async';
 
 import 'package:kernel/kernel.dart' show Program, CanonicalName;
 
 import 'base/processed_options.dart';
+import 'fasta/compiler_command_line.dart';
 import 'fasta/dill/dill_target.dart' show DillTarget;
 import 'fasta/deprecated_problems.dart' show deprecated_InputError, reportCrash;
 import 'fasta/kernel/kernel_outline_shaker.dart';
 import 'fasta/kernel/kernel_target.dart' show KernelTarget;
+import 'fasta/kernel/utils.dart';
 import 'fasta/kernel/verifier.dart';
-import 'fasta/kernel/utils.dart';
-import 'fasta/compiler_command_line.dart';
 import 'fasta/translate_uri.dart' show TranslateUri;
 
 /// Implementation for the `package:front_end/kernel_generator.dart` and
 /// `package:front_end/summary_generator.dart` APIs.
 Future<CompilerResult> generateKernel(ProcessedOptions options,
     {bool buildSummary: false,
     bool buildProgram: true,
     bool trimDependencies: false}) async {
   // TODO(sigmund): Replace CompilerCommandLine and instead simply use a
   // CompilerContext that directly uses the ProcessedOptions throught the
@@ skipping 72 matching lines @@
         // program is destructive, so if we are emitting summaries and the
         // program in a single API call, we would need to clone the program here
         // to avoid deleting pieces that are needed by kernelTarget.buildProgram
         // below.
         assert(!buildProgram);
         var excluded =
             dillTarget.loader.libraries.map((lib) => lib.importUri).toSet();
         trimProgram(summaryProgram, (uri) => !excluded.contains(uri));
       }
       if (options.verify) {
-        verifyProgram(summaryProgram).forEach((e) => options.reportError('$e'));
+        verifyProgram(summaryProgram).forEach(options.reportMessage);
       }
       if (options.debugDump) {
         printProgramText(summaryProgram,
             libraryFilter: kernelTarget.isSourceLibrary);
       }
       if (kernelTarget.errors.isEmpty) {
         summary = serializeProgram(summaryProgram, excludeUriToSource: true);
       }
       options.ticker.logMs("Generated outline");
     }
 
     Program program;
     if (buildProgram && kernelTarget.errors.isEmpty) {
       program = await kernelTarget.buildProgram(verify: options.verify);
       if (trimDependencies) {
         var excluded =
             dillTarget.loader.libraries.map((lib) => lib.importUri).toSet();
         trimProgram(program, (uri) => !excluded.contains(uri));
       }
       if (options.debugDump) {
         printProgramText(program, libraryFilter: kernelTarget.isSourceLibrary);
       }
       options.ticker.logMs("Generated program");
     }
 
     if (kernelTarget.errors.isNotEmpty) {
-      kernelTarget.errors.forEach(options.reportError);
+      kernelTarget.errors.forEach(options.deprecated_reportError);
       return null;
     }
 
     return new CompilerResult(
         summary: summary,
         program: program,
         deps: kernelTarget.loader.getDependencies());
   } on deprecated_InputError catch (e) {
-    options.reportError(e.deprecated_format());
+    options.deprecated_reportError(e.deprecated_format());
     return null;
   } catch (e, t) {
     return reportCrash(e, t);
   }
 }
 
 /// Result object of [generateKernel].
 class CompilerResult {
   /// The generated summary bytes, if it was requested.
   final List<int> summary;
 
   /// The generated program, if it was requested.
   final Program program;
 
   /// Dependencies traversed by the compiler. Used only for generating
   /// dependency .GN files in the dart-sdk build system.
   /// Note this might be removed when we switch to compute depencencies without
   /// using the compiler itself.
   final List<Uri> deps;
 
   CompilerResult({this.summary, this.program, this.deps});
 }