Move tools to tool folder.

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 79 matching lines @@
       return !isVerbose;
 
     case Severity.warning:
       return hideWarnings;
   }
   return unhandled("$severity", "isHidden", -1, null);
 }
 
 /// Are problems of [severity] fatal? That is, should the compiler terminate
 /// immediately?
-bool isFatal(Severity severity) {
+bool shouldThrowOn(Severity severity) {
   switch (severity) {
     case Severity.error:
-      return CompilerContext.current.options.throwOnErrors;
+      return CompilerContext.current.options.throwOnErrorsForDebugging;
 
     case Severity.internalProblem:
       return true;
 
     case Severity.nit:
-      return CompilerContext.current.options.throwOnNits;
+      return CompilerContext.current.options.throwOnNitsForDebugging;
 
     case Severity.warning:
-      return CompilerContext.current.options.throwOnWarnings;
+      return CompilerContext.current.options.throwOnWarningsForDebugging;
   }
-  return unhandled("$severity", "isFatal", -1, null);
+  return unhandled("$severity", "shouldThrowOn", -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(
+void _printAndThrowIfDebugging(
     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 (shouldThrowOn(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.
 void report(LocatedMessage message, Severity severity) {
   if (isHidden(severity)) return;
-  _printAndThrowIfFatal(
+  _printAndThrowIfDebugging(
       format(message, severity), severity, message.uri, message.charOffset);
 }
 
 /// Similar to [report].
 ///
 /// This method isn't intended to be called directly. Use
 /// [CompilerContext.reportWithoutLocation] instead.
 void reportWithoutLocation(Message message, Severity severity) {
   if (isHidden(severity)) return;
-  _printAndThrowIfFatal(
+  _printAndThrowIfDebugging(
       formatWithoutLocation(message, severity), severity, null, -1);
 }
 
 /// Formats [message] as described in [formatInternal].
 ///
 /// This method isn't intended to be called directly. Use
 /// [CompilerContext.format] instead.
 String format(LocatedMessage message, Severity severity) {
   return formatInternal(
       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);
 }