Fix `analyzer_cli` error overrides (#24452).

pkg/analyzer_cli/lib/src/error_formatter.dart

 // Copyright (c) 2015, 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.
 
 library analyzer_cli.src.error_formatter;
 
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/source.dart';
-import 'package:analyzer_cli/src/analyzer_impl.dart';
 import 'package:analyzer_cli/src/options.dart';
 
-/// Allows any [AnalysisError].
-bool _anyError(AnalysisError error) => true;
+/// Returns the given error's severity.
+ProcessedSeverity _identity(AnalysisError error) =>
+    new ProcessedSeverity(error.errorCode.errorSeverity);
 
-/// Returns `true` if [AnalysisError] should be printed.
-typedef bool _ErrorFilter(AnalysisError error);
+/// Returns desired severity for the given [error] (or `null` if it's to be
+/// suppressed).
+typedef ProcessedSeverity _SeverityProcessor(AnalysisError error);
 
 /// Helper for formatting [AnalysisError]s.
-/// The two format options are a user consumable format and a machine consumable format.
+/// The two format options are a user consumable format and a machine consumable
+/// format.
 class ErrorFormatter {
   final StringSink out;
   final CommandLineOptions options;
-  final _ErrorFilter errorFilter;
+  final _SeverityProcessor processSeverity;
 
-  ErrorFormatter(this.out, this.options, [this.errorFilter = _anyError]);
+  ErrorFormatter(this.out, this.options, [this.processSeverity = _identity]);
+
+  /// Compute the severity for this [error] or `null` if this error should be
+  /// filtered.
+  ErrorSeverity computeSeverity(AnalysisError error) =>
+      processSeverity(error)?.severity;
 
   void formatError(
       Map<AnalysisError, LineInfo> errorToLine, AnalysisError error) {
     Source source = error.source;
     LineInfo_Location location = errorToLine[error].getLocation(error.offset);
     int length = error.length;
-    ErrorSeverity severity =
-        AnalyzerImpl.computeSeverity(error, options);
+
+    ProcessedSeverity processedSeverity = processSeverity(error);
+    ErrorSeverity severity = processedSeverity.severity;
+
     if (options.machineFormat) {
-      if (severity == ErrorSeverity.WARNING && options.warningsAreFatal) {
-        severity = ErrorSeverity.ERROR;
+      if (!processedSeverity.overridden) {
+        if (severity == ErrorSeverity.WARNING && options.warningsAreFatal) {
+          severity = ErrorSeverity.ERROR;
+        }
       }
       out.write(severity);
       out.write('|');
       out.write(error.errorCode.type);
       out.write('|');
       out.write(error.errorCode.name);
       out.write('|');
       out.write(escapePipe(source.fullName));
       out.write('|');
       out.write(location.lineNumber);
       out.write('|');
       out.write(location.columnNumber);
       out.write('|');
       out.write(length);
       out.write('|');
       out.write(escapePipe(error.message));
     } else {
+      // Get display name.
       String errorType = severity.displayName;
-      if (error.errorCode.type == ErrorType.HINT ||
-          error.errorCode.type == ErrorType.LINT) {
-        errorType = error.errorCode.type.displayName;
+
+      // Translate INFOs into LINTS and HINTS.
+      if (severity == ErrorSeverity.INFO) {
+        if (error.errorCode.type == ErrorType.HINT ||
+            error.errorCode.type == ErrorType.LINT) {
+          errorType = error.errorCode.type.displayName;
+        }
       }
+
       // [warning] 'foo' is not a... (/Users/.../tmp/foo.dart, line 1, col 2)
       out.write('[$errorType] ${error.message} ');
       out.write('(${source.fullName}');
       out.write(', line ${location.lineNumber}, col ${location.columnNumber})');
     }
     out.writeln();
   }
 
   void formatErrors(List<AnalysisErrorInfo> errorInfos) {
     var errors = new List<AnalysisError>();
     var errorToLine = new Map<AnalysisError, LineInfo>();
     for (AnalysisErrorInfo errorInfo in errorInfos) {
       for (AnalysisError error in errorInfo.errors) {
-        if (errorFilter(error)) {
+        if (computeSeverity(error) != null) {
           errors.add(error);
           errorToLine[error] = errorInfo.lineInfo;
         }
       }
     }
     // Sort errors.
     errors.sort((AnalysisError error1, AnalysisError error2) {
       // Severity.
-      ErrorSeverity severity1 =
-          AnalyzerImpl.computeSeverity(error1, options);
-      ErrorSeverity severity2 =
-          AnalyzerImpl.computeSeverity(error2, options);
+      ErrorSeverity severity1 = computeSeverity(error1);
+      ErrorSeverity severity2 = computeSeverity(error2);
       int compare = severity2.compareTo(severity1);
       if (compare != 0) {
         return compare;
       }
       // Path.
       compare = Comparable.compare(error1.source.fullName.toLowerCase(),
           error2.source.fullName.toLowerCase());
       if (compare != 0) {
         return compare;
       }
       // Offset.
       return error1.offset - error2.offset;
     });
     // Format errors.
     int errorCount = 0;
     int warnCount = 0;
     int hintCount = 0;
     int lintCount = 0;
     for (AnalysisError error in errors) {
-      ErrorSeverity severity =
-          AnalyzerImpl.computeSeverity(error, options);
+      ProcessedSeverity processedSeverity = processSeverity(error);
+      ErrorSeverity severity = processedSeverity.severity;
       if (severity == ErrorSeverity.ERROR) {
         errorCount++;
       } else if (severity == ErrorSeverity.WARNING) {
-        if (options.warningsAreFatal) {
+        /// Only treat a warning as an error if it's not been set by a
+        /// proccesser.
+        if (!processedSeverity.overridden && options.warningsAreFatal) {
           errorCount++;
         } else {
           warnCount++;
         }
       } else if (error.errorCode.type == ErrorType.HINT) {
         hintCount++;
       } else if (error.errorCode.type == ErrorType.LINT) {
         lintCount++;
       }
       formatError(errorToLine, error);
@@ skipping 66 matching lines @@
   }
 
   static String pluralize(String word, int count) {
     if (count == 1) {
       return word;
     } else {
       return word + "s";
     }
   }
 }
+
+/// A severity with awareness of whether it was overriden by a processor.
+class ProcessedSeverity {
+  ErrorSeverity severity;
+  bool overridden;
+  ProcessedSeverity(this.severity, [this.overridden = false]);
+}