Unifying compiler context

utils/kernel-service/kernel-service.dart

Index: utils/kernel-service/kernel-service.dart
diff --git a/utils/kernel-service/kernel-service.dart b/utils/kernel-service/kernel-service.dart
index 5b7ca5031c378a729bd9740d5777ef6e21fe4d27..d50a481b1d6b9b95c038af657e985e33fe82f60d 100644
--- a/utils/kernel-service/kernel-service.dart
+++ b/utils/kernel-service/kernel-service.dart
@@ -70,7 +70,7 @@ Future _processLoadRequest(request) async {
     print("DFE: sdkSummary: ${sdkSummary}");
   }
 
-  var errors = <String>[];
+  bool hasErrors = false;
   var options = new CompilerOptions()
     ..strongMode = strongMode
     ..fileSystem = fileSystem
@@ -78,13 +78,21 @@ Future _processLoadRequest(request) async {
     ..packagesFileUri = packagesUri
     ..sdkSummary = sdkSummary
     ..verbose = verbose
-    ..onError = (CompilationError e) => errors.add(e.message);
+    ..reportMessages = true
+    ..onError = (CompilationMessage e) {
+      if (e.severity == Severity.error) {
+        hasErrors = true;
+      }
+    };
 
   CompilationResult result;
   try {
     Program program = await kernelForProgram(script, options);
-    if (errors.isNotEmpty) {
-      result = new CompilationResult.errors(errors);
+    if (hasErrors) {

[ahe, 2017/07/18 16:54:37]

Something has regressed here, and I think we need to restore the old behavior
(soon, but not in this CL).

Previously, the list of errors would be extracted from KernelTarget, and it
would only be errors that couldn't be handled by generating an inline "throw
CompileTimeError".

This meant that we would be exercising the compile-time error handling much
better by actually running the code.

[Siggi Cherem (dart-lang), 2017/07/18 22:50:44]

I see, let's talk on our next sync up about this. I want to make sure we are on
the same page on where this fits in our planning and the overall move to 2.0.
Added a TODO here for now.

In terms of implementation:
 - since now all errors are conflated together, we need some way to tell them
apart. One option here could be to model it as yet another category/severity:
unhandledError vs handledError?
 - we should have a flag "emitWithErrors" to enable this behavior. My
understanding is that with the move to 2.0, the default behavior will be to have
this flag off? maybe some clients (e.g. hot-reload) might be interested in
turning it on? let's chat more.

+      // Note: the compiler prints errors to the console, so we don't print
+      // those messages again here.
+      result =
+          new CompilationResult.error("Compile-time errors found in $script");
     } else {
       // We serialize the program excluding platform.dill because the VM has
       // these sources built-in. Everything loaded as a summary in
@@ -185,7 +193,7 @@ abstract class CompilationResult {
 
   factory CompilationResult.ok(Uint8List bytes) = _CompilationOk;
 
-  factory CompilationResult.errors(List<String> errors) = _CompilationError;
+  factory CompilationResult.error(String error) = _CompilationError;
 
   factory CompilationResult.crash(Object exception, StackTrace stack) =
       _CompilationCrash;
@@ -221,16 +229,14 @@ abstract class _CompilationFail extends CompilationResult {
 }
 
 class _CompilationError extends _CompilationFail {
-  final List<String> errors;
+  @override
+  final String errorString;
 
-  _CompilationError(this.errors);
+  _CompilationError(this.errorString);
 
   @override
   Status get status => Status.error;
 
-  @override
-  String get errorString => errors.take(10).join('\n');
-
   String toString() => "_CompilationError(${errorString})";
 }