Improve error reporting in batch mode.

lib/src/rastask.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.
 
 library rasta.rastask;
 
 import 'dart:async' show
     Future;
 
 import 'dart:io' show
     File,
     IOSink;
 
+import 'package:compiler/compiler_new.dart' show
+    Diagnostic;
+
+import 'package:compiler/src/diagnostics/diagnostic_listener.dart' show
+    DiagnosticMessage;
+
 import 'package:compiler/src/common/tasks.dart' show
     CompilerTask;
 
 import 'package:compiler/src/elements/elements.dart' show
     CompilationUnitElement,
+    Element,
     LibraryElement;
 
 import 'package:kernel/ast.dart' as ir;
 
 import 'package:kernel/binary/ast_to_binary.dart' show
     BinaryPrinter;
 
 import 'package:kernel/text/ast_to_text.dart' show
     Printer;
 
@@ skipping 25 matching lines @@
   }
   print("Wrote $uri");
 }
 
 abstract class Rastask extends CompilerTask {
   final Stopwatch wallClock;
   final Options globalOptions;
   Duration setupDuration;
   Kernel kernel;
   ir.Library coreLibrary;
+  bool hasCompileTimeErrors = false;
 
   Rastask(CustomCompiler compiler, this.wallClock, this.globalOptions)
       : super(compiler);
 
   String get name => "rastak";
 
   CustomCompiler get compiler => super.compiler;
 
   Future run();
 
@@ skipping 12 matching lines @@
         "${(wallClock.elapsedMilliseconds).toStringAsFixed(3)}ms");
   }
 
   Future<ir.Library> loadLibrary(Uri uri) async {
     ir.Library library = await kernel.loadLibrary(uri);
     kernel.processWorkQueue();
     return library;
   }
 
   Future<ir.TreeNode> runOne(Options options) async {
+    hasCompileTimeErrors = false;
     ir.Library library = await loadLibrary(options.input);
 
     bool generateLibrary = options.generateLibrary;
     if (generateLibrary == null) {
       generateLibrary = !kernel.hasMainMethod(options.input);
     }
     if (!generateLibrary && !kernel.hasMainMethod(options.input)) {
       throw "No main method in ${options.input}.";
     }
 
@@ skipping 28 matching lines @@
     if (options.dependenciesFile != null) {
       await openWrite(options.dependenciesFile, (IOSink sink) {
         void writeCompilationUnit(CompilationUnitElement unit) {
           sink.write("${unit.script.resourceUri}\n");
         }
         kernel.forEachLibraryElement((LibraryElement library) {
           library.compilationUnits.forEach(writeCompilationUnit);
         });
       });
     }
+    Set<ir.Library> libraries = new Set<ir.Library>.from(
+        generateLibrary ? <ir.Library>[library] : program.libraries);
+    compiler.elementsWithCompileTimeErrors.forEach(
+        (Element element, List<DiagnosticMessage> messages) {
+          ir.Library library = kernel.libraries[element.library];
+          if (libraries.contains(library)) {
+            for (DiagnosticMessage diagnostic in messages) {

[kasperl, 2016/08/04 11:14:13]

Can messages be empty? Maybe move hasCompileTimeError = true out of the for-in
loop.

[ahe, 2016/08/04 11:32:45]

I'll address this in a follow-up CL.

[ahe, 2016/08/04 12:15:32]

Thank you, I've created CL 2213913002 for this.

+              hasCompileTimeErrors = true;
+              compiler.reportDiagnostic(
+                  diagnostic, const <DiagnosticMessage>[], Diagnostic.ERROR);
+            }
+          }
+        });
     return generateLibrary ? library : program;
   }
 
   static Future<Rastask> create(
       Stopwatch wallClock,
       List<String> arguments) async {
     Options options = await new OptionParser(arguments, Uri.base).parse();
     List<String> compilerOptions =
         options.isVerbose ? <String>['--verbose'] : <String>[];
     IoCompilerFactory factory = new IoCompilerFactory(
@@ skipping 11 matching lines @@
     Rastask task;
     if (options.isBatch) {
       task = new RunBatch(compiler, wallClock, options);
     } else {
       task = new RunSingle(compiler, wallClock, options);
     }
     compiler.tasks.add(task);
     return task;
   }
 }