Unifying compiler context

pkg/front_end/lib/src/fasta/command_line_reporting.dart

 // Copyright (c) 2017, 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.
 
 /// Provides a default implementation of the report and format methods of
 /// [CompilerContext] that are suitable for command-line tools. The methods in
 /// this library aren't intended to be called directly, instead, one should use
 /// [CompilerContext].
 library fasta.command_line_reporting;
 
@@ skipping 16 matching lines @@
 import 'severity.dart' show Severity;
 
 import 'util/relativize.dart' show relativizeUri;
 
 const bool hideWarnings = false;
 
 /// Formats [message] as a string that is suitable for output from a
 /// command-line tool. This includes source snippets and different colors based
 /// on [severity].
 ///
-/// It is a assumed that a formatted message is reported to a user, so
-/// [exitCode] is also set depending on the value of
-/// `CompilerContext.current.options.setExitCodeOnProblem`.
-///
 /// This is shared implementation used by methods below, and isn't intended to
 /// be called directly.
 String formatInternal(Message message, Severity severity, Uri uri, int offset) {
-  if (CompilerContext.current.options.setExitCodeOnProblem) {
-    exitCode = 1;
-  }
   String text =
       "${severityName(severity, capitalized: true)}: ${message.message}";
   if (message.tip != null) {
     text += "\n${message.tip}";
   }
   if (CompilerContext.enableColors) {
     switch (severity) {
       case Severity.error:
       case Severity.internalProblem:
         text = red(text);
@@ skipping 43 matching lines @@
       return hideWarnings;
   }
   return unhandled("$severity", "isHidden", -1, null);
 }
 
 /// Are problems of [severity] fatal? That is, should the compiler terminate
 /// immediately?
 bool isFatal(Severity severity) {
   switch (severity) {
     case Severity.error:
-      return CompilerContext.current.options.errorsAreFatal;
+      return CompilerContext.current.options.throwOnErrors;
 
     case Severity.internalProblem:
       return true;
 
     case Severity.nit:
-      return CompilerContext.current.options.nitsAreFatal;
+      return CompilerContext.current.options.throwOnNits;
 
     case Severity.warning:
-      return CompilerContext.current.options.warningsAreFatal;
+      return CompilerContext.current.options.throwOnWarnings;
   }
   return unhandled("$severity", "isFatal", -1, null);
 }
 
 /// Convert [severity] to a name that can be used to prefix a message.
 String severityName(Severity severity, {bool capitalized: false}) {
   switch (severity) {
     case Severity.error:
       return capitalized ? "Error" : "error";
 
     case Severity.internalProblem:
       return capitalized ? "Internal problem" : "internal problem";
 
     case Severity.nit:
       return capitalized ? "Nit" : "nit";
 
     case Severity.warning:
       return capitalized ? "Warning" : "warning";
   }
   return unhandled("$severity", "severityName", -1, null);
 }
 
+/// Print a formatted message and throw when errors are treated as fatal.
+/// Also set [exitCode] depending on the value of
+/// `CompilerContext.current.options.setExitCodeOnProblem`.
 void _printAndThrowIfFatal(
     String text, Severity severity, Uri uri, int charOffset) {
+  // I believe we should only set it if we are reporting something, if we are
+  // formatting to embed the error in the program, then we probably don't want
+  // to do it in format.
+  // Note: I also want to limit dependencies to dart:io for when we use the FE
+  // outside of the VM. This default reporting is likely not going to be used in
+  // that context, but the default formatter is.
+  if (CompilerContext.current.options.setExitCodeOnProblem) {
+    exitCode = 1;
+  }
   print(text);
   if (isFatal(severity)) {
     if (isVerbose) print(StackTrace.current);
+    // TODO(sigmund,ahe): ensure there is no circularity when InputError is
+    // handled.
     throw new deprecated_InputError(uri, charOffset,
         "Compilation aborted due to fatal ${severityName(severity)}.");
   }
 }
 
 /// Report [message] unless [severity] is suppressed (see [isHidden]). Throws
 /// an exception if [severity] is fatal (see [isFatal]).
 ///
 /// This method isn't intended to be called directly. Use
 /// [CompilerContext.report] instead.
@@ skipping 22 matching lines @@
       message.messageObject, severity, message.uri, message.charOffset);
 }
 
 /// Formats [message] as described in [formatInternal].
 ///
 /// This method isn't intended to be called directly. Use
 /// [CompilerContext.formatWithoutLocation] instead.
 String formatWithoutLocation(Message message, Severity severity) {
   return formatInternal(message, severity, null, -1);
 }