Report messages instead of just printing.

pkg/front_end/lib/src/fasta/kernel/kernel_target.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.
 
 library fasta.kernel_target;
 
 import 'dart:async' show Future;
 
 import 'package:kernel/ast.dart'
     show
         Arguments,
+        Block,
         CanonicalName,
         Class,
         Constructor,
         DartType,
         DynamicType,
         EmptyStatement,
         Expression,
         ExpressionStatement,
         Field,
         FieldInitializer,
         FunctionNode,
         Initializer,
         InvalidInitializer,
         Library,
         ListLiteral,
         Name,
         NamedExpression,
         NullLiteral,
         ProcedureKind,
         Program,
         Source,
+        Statement,
         StringLiteral,
         SuperInitializer,
         Throw,
         TypeParameter,
         VariableDeclaration,
         VariableGet,
         VoidType;
 
 import 'package:kernel/type_algebra.dart' show substitute;
 
 import '../../../file_system.dart' show FileSystem;
 
 import '../compiler_context.dart' show CompilerContext;
 
 import '../deprecated_problems.dart'
-    show
-        deprecated_formatUnexpected,
-        deprecated_InputError,
-        reportCrash,
-        resetCrashReporting;
+    show deprecated_InputError, reportCrash, resetCrashReporting;
 
 import '../dill/dill_target.dart' show DillTarget;
 
 import '../messages.dart'
     show
         LocatedMessage,
         messageConstConstructorNonFinalField,
         messageConstConstructorNonFinalFieldCause,
         templateSuperclassHasNoDefaultConstructor;
 
 import '../problems.dart' show unhandled;
 
+import '../severity.dart' show Severity;
+
 import '../source/source_class_builder.dart' show SourceClassBuilder;
 
 import '../source/source_loader.dart' show SourceLoader;
 
 import '../target_implementation.dart' show TargetImplementation;
 
 import '../uri_translator.dart' show UriTranslator;
 
 import '../util/relativize.dart' show relativizeUri;
 
@@ skipping 21 matching lines @@
 
   final DillTarget dillTarget;
 
   /// Shared with [CompilerContext].
   final Map<String, Source> uriToSource;
 
   SourceLoader<Library> loader;
 
   Program program;
 
-  final List<String> errors = <String>[];
+  final List<LocatedMessage> errors = <LocatedMessage>[];
 
   final TypeBuilder dynamicType =
       new KernelNamedTypeBuilder("dynamic", null, -1, null);
 
   bool get strongMode => backendTarget.strongMode;
 
   bool get disableTypeInference => backendTarget.disableTypeInference;
 
   KernelTarget(
       this.fileSystem, DillTarget dillTarget, UriTranslator uriTranslator,
@@ skipping 94 matching lines @@
     cls.mixedInType = null;
     builder.supertype = new KernelNamedTypeBuilder("Object", null,
         builder.charOffset, builder.fileUri ?? Uri.parse(cls.fileUri))
       ..builder = objectClassBuilder;
     builder.interfaces = null;
     builder.mixedInType = null;
   }
 
   void handleInputError(deprecated_InputError error, {bool isFullProgram}) {
     if (error != null) {
-      String message = error.deprecated_format();
-      print(message);
+      LocatedMessage message = deprecated_InputError.toMessage(error);
+      context.report(message, Severity.error);
       errors.add(message);
     }
     program = erroneousProgram(isFullProgram);
   }
 
   @override
   Future<Program> buildOutlines({CanonicalName nameRoot}) async {
     if (loader.first == null) return null;
     try {
       loader.createTypeInferenceEngine();
@@ skipping 69 matching lines @@
   /// replace [program].
   void handleRecoverableErrors(List<LocatedMessage> recoverableErrors) {
     if (recoverableErrors.isEmpty) return;
     KernelLibraryBuilder mainLibrary = loader.first;
     if (mainLibrary == null) {
       program = erroneousProgram(true);
       return;
     }
     List<Expression> expressions = <Expression>[];
     for (LocatedMessage error in recoverableErrors) {
-      String message = deprecated_formatUnexpected(
-          error.uri, error.charOffset, error.message);
-      errors.add(message);
-      expressions.add(new StringLiteral(message));
+      errors.add(error);
+      expressions.add(new StringLiteral(context.format(error, Severity.error)));
     }
     mainLibrary.library.addMember(new Field(new Name("#errors"),
         initializer: new ListLiteral(expressions, isConst: true),
         isConst: true));
   }
 
   Program erroneousProgram(bool isFullProgram) {
     Uri uri = loader.first?.uri ?? Uri.parse("error:error");
     Uri fileUri = loader.first?.fileUri ?? uri;
     KernelLibraryBuilder library =
         new KernelLibraryBuilder(uri, fileUri, loader, false);
     loader.first = library;
     if (isFullProgram) {
       // If this is an outline, we shouldn't add an executable main
       // method. Similarly considerations apply to separate compilation. It
       // could also make sense to add a way to mark .dill files as having
       // compile-time errors.
       KernelProcedureBuilder mainBuilder = new KernelProcedureBuilder(null, 0,
           null, "main", null, null, ProcedureKind.Method, library, -1, -1, -1);
       library.addBuilder(mainBuilder.name, mainBuilder, -1);
-      mainBuilder.body = new ExpressionStatement(
-          new Throw(new StringLiteral("${errors.join('\n')}")));
+      mainBuilder.body = new Block(new List<Statement>.from(errors.map(
+          (LocatedMessage message) => new ExpressionStatement(new Throw(
+              new StringLiteral(context.format(message, Severity.error)))))));
     }
     library.build(loader.coreLibrary);
     return link(<Library>[library.library]);
   }
 
   /// Creates a program by combining [libraries] with the libraries of
   /// `dillTarget.loader.program`.
   Program link(List<Library> libraries, {CanonicalName nameRoot}) {
     Map<String, Source> uriToSource =
         new Map<String, Source>.from(this.uriToSource);
@@ skipping 278 matching lines @@
   /// first time.
   void runBuildTransformations() {
     backendTarget.performModularTransformationsOnLibraries(
         loader.coreTypes, loader.hierarchy, loader.libraries,
         logger: (String msg) => ticker.logMs(msg));
     backendTarget.performGlobalTransformations(loader.coreTypes, program,
         logger: (String msg) => ticker.logMs(msg));
   }
 
   void verify() {
-    var verifyErrors = verifyProgram(program);
-    errors.addAll(verifyErrors.map((error) => error.message));
+    errors.addAll(verifyProgram(program));
     ticker.logMs("Verified program");
   }
 
   /// Return `true` if the given [library] was built by this [KernelTarget]
   /// from sources, and not loaded from a [DillTarget].
   bool isSourceLibrary(Library library) {
     return loader.libraries.contains(library);
   }
 }
 
 /// Looks for a constructor call that matches `super()` from a constructor in
 /// [cls]. Such a constructor may have optional arguments, but no required
 /// arguments.
 Constructor defaultSuperConstructor(Class cls) {
   Class superclass = cls.superclass;
   while (superclass != null && superclass.isMixinApplication) {
     superclass = superclass.superclass;
   }
   for (Constructor constructor in superclass.constructors) {
     if (constructor.name.name.isEmpty) {
       return constructor.function.requiredParameterCount == 0
           ? constructor
           : null;
     }
   }
   return null;
 }