Improve error messages.

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 'dart:io' show File;
 
@@ skipping 91 matching lines @@
   KernelTarget(
       this.fileSystem, DillTarget dillTarget, TranslateUri uriTranslator,
       [Map<String, Source> uriToSource])
       : dillTarget = dillTarget,
         uriToSource = uriToSource ?? CompilerContext.current.uriToSource,
         super(dillTarget.ticker, uriTranslator, dillTarget.backendTarget) {
     resetCrashReporting();
     loader = createLoader();
   }
 
+  bool get hasErrors {
+    return errors.isNotEmpty || loader.collectCompileTimeErrors().isNotEmpty;
+  }
+
   void addError(file, int charOffset, String message) {
     Uri uri = file is String ? Uri.parse(file) : file;
     InputError error = new InputError(uri, charOffset, message);
     String formatterMessage = error.format();
     print(formatterMessage);
     errors.add(formatterMessage);
   }
 
   SourceLoader<Library> createLoader() =>
       new SourceLoader<Library>(fileSystem, this);
@@ skipping 152 matching lines @@
       handleInputError(null,
           isFullProgram: true, trimDependencies: trimDependencies);
       return program;
     }
 
     try {
       await loader.buildBodies();
       loader.finishStaticInvocations();
       finishAllConstructors();
       loader.finishNativeMethods();
-      runBuildTransformations();
+      if (!hasErrors) {
+        runBuildTransformations();

[ahe, 2017/06/09 08:13:14]

The parser reports a recoverable error on code like this:

class C {
  foo() async;
}

Fasta treats this as an abstract method and doesn't discard the async modifier.
The async transformer isn't prepared for that, so it crashes when it tries to
visit the null function body of C.foo above.

Before we would throw an InputError and never get as far as running
transformations.

+      }
 
       if (verify) this.verify();
       errors.addAll(loader.collectCompileTimeErrors().map((e) => e.format()));
       if (errors.isNotEmpty) {
         handleInputError(null,
             isFullProgram: true, trimDependencies: trimDependencies);
       }
     } on InputError catch (e) {
       handleInputError(e,
           isFullProgram: true, trimDependencies: trimDependencies);
@@ skipping 405 matching lines @@
   }
   for (Constructor constructor in superclass.constructors) {
     if (constructor.name.name.isEmpty) {
       return constructor.function.requiredParameterCount == 0
           ? constructor
           : null;
     }
   }
   return null;
 }