Unifying compiler context

utils/kernel-service/kernel-service.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.
 
 /// This is an interface to the Dart Kernel parser and Kernel binary generator.
 ///
 /// It is used by the kernel-isolate to load Dart source code and generate
 /// Kernel binary format.
 ///
 /// This is either invoked as the root script of the Kernel isolate when used
@@ skipping 52 matching lines @@
       .resolve('platform.dill');
 
   if (verbose) {
     print("DFE: scriptUri: ${script}");
     print("DFE: Platform.packageConfig: ${Platform.packageConfig}");
     print("DFE: packagesUri: ${packagesUri}");
     print("DFE: Platform.resolvedExecutable: ${Platform.resolvedExecutable}");
     print("DFE: sdkSummary: ${sdkSummary}");
   }
 
-  var errors = <String>[];
+  bool hasErrors = false;
   var options = new CompilerOptions()
     ..strongMode = strongMode
     ..fileSystem = fileSystem
     ..target = new VmFastaTarget(new TargetFlags(strongMode: strongMode))
     ..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
       // [kernelForProgram] is marked `external`, so we can use that bit to
       // decide what to excluce.
       // TODO(sigmund): remove the following line (Issue #30111)
       program.libraries.forEach((e) => e.isExternal = false);
       result = new CompilationResult.ok(
           serializeProgram(program, filter: (lib) => !lib.isExternal));
     }
@@ skipping 80 matching lines @@
 
   /// Compiler crashed.
   crash,
 }
 
 abstract class CompilationResult {
   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;
 
   Status get status;
 
   get payload;
 
   List toResponse() => [status.index, payload];
 }
@@ skipping 15 matching lines @@
 abstract class _CompilationFail extends CompilationResult {
   _CompilationFail() : super._();
 
   String get errorString;
 
   @override
   get payload => errorString;
 }
 
 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})";
 }
 
 class _CompilationCrash extends _CompilationFail {
   final Object exception;
   final StackTrace stack;
 
   _CompilationCrash(this.exception, this.stack);
 
   @override
   Status get status => Status.crash;
 
   @override
   String get errorString => "${exception}\n${stack}";
 
   String toString() => "_CompilationCrash(${errorString})";
 }