Fix an issue with duplicate reported analysis errors.

pkg/analyzer_cli/lib/src/analyzer_impl.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.analyzer_impl;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:io';
 
@@ skipping 48 matching lines @@
   /// specified on the command line as though it is reached via a "package:"
   /// URI, but avoid suppressing its output in the event that the user has not
   /// specified the "--package-warnings" option.
   String _selfPackageName;
 
   AnalyzerImpl(this.analysisOptions, this.context, this.analysisDriver,
       this.librarySource, this.options, this.stats, this.startTime);
 
   /// Returns the maximal [ErrorSeverity] of the recorded errors.
   ErrorSeverity get maxErrorSeverity {
-    var status = ErrorSeverity.NONE;
+    ErrorSeverity status = ErrorSeverity.NONE;
     for (AnalysisErrorInfo errorInfo in errorInfos) {
       for (AnalysisError error in errorInfo.errors) {
-        if (_processError(error) == null) {
+        if (_defaultSeverityProcessor(error) == null) {
           continue;
         }
-        var severity = computeSeverity(error, options);
+        ErrorSeverity severity = computeSeverity(error, options);
         status = status.max(severity);
       }
     }
     return status;
   }
 
   void addCompilationUnitSource(
       CompilationUnitElement unit, Set<CompilationUnitElement> units) {
     if (unit == null || !units.add(unit)) {
       return;
@@ skipping 25 matching lines @@
     for (LibraryElement child in library.exportedLibraries) {
       addLibrarySources(child, libraries, units);
     }
   }
 
   /// Treats the [sourcePath] as the top level library and analyzes it using
   /// the analysis engine. If [printMode] is `0`, then no error or performance
   /// information is printed. If [printMode] is `1`, then errors will be printed.
   /// If [printMode] is `2`, then performance information will be printed, and
   /// it will be marked as being for a cold VM.
-  Future<ErrorSeverity> analyze({int printMode: 1}) async {
+  Future<ErrorSeverity> analyze(ErrorFormatter formatter,
+      {int printMode: 1}) async {
     setupForAnalysis();
-    return await _analyze(printMode);
+    return await _analyze(printMode, formatter);
   }
 
   /// Fills [errorInfos] using [sources].
   Future<Null> prepareErrors() async {
     PerformanceTag previous = _prepareErrorsTag.makeCurrent();
     try {
       for (Source source in sources) {
         if (analysisDriver != null) {
           String path = source.fullName;
           ErrorsResult errorsResult = await analysisDriver.getErrors(path);
@@ skipping 19 matching lines @@
   /// Setup local fields such as the analysis context for analysis.
   void setupForAnalysis() {
     sources.clear();
     errorInfos.clear();
     Uri libraryUri = librarySource.uri;
     if (libraryUri.scheme == 'package' && libraryUri.pathSegments.length > 0) {
       _selfPackageName = libraryUri.pathSegments[0];
     }
   }
 
-  Future<ErrorSeverity> _analyze(int printMode) async {
+  Future<ErrorSeverity> _analyze(
+      int printMode, ErrorFormatter formatter) async {
     // Don't try to analyze parts.
     String path = librarySource.fullName;
     SourceKind librarySourceKind = analysisDriver != null
         ? await analysisDriver.getSourceKind(path)
         : context.computeKindOf(librarySource);
     if (librarySourceKind == SourceKind.PART) {
       stderr.writeln("Only libraries can be analyzed.");
       stderr.writeln("${path} is a part and can not be analyzed.");
       return ErrorSeverity.ERROR;
     }
 
     LibraryElement libraryElement = await _resolveLibrary();
     prepareSources(libraryElement);
     await prepareErrors();
 
     // Print errors and performance numbers.
     if (printMode == 1) {
-      _printErrors();
+      formatter.formatErrors(errorInfos);
     } else if (printMode == 2) {
       _printColdPerf();
     }
 
     // Compute max severity and set exitCode.
     ErrorSeverity status = maxErrorSeverity;
     if (status == ErrorSeverity.WARNING && options.warningsAreFatal) {
       status = ErrorSeverity.ERROR;
     }
     return status;
@@ skipping 41 matching lines @@
       if (tag != PerformanceTag.UNKNOWN) {
         int tagTime = tag.elapsedMs;
         outSink.writeln('${tag.label}-cold:$tagTime');
         otherTime -= tagTime;
       }
     }
     outSink.writeln('other-cold:$otherTime');
     outSink.writeln("total-cold:$totalTime");
   }
 
-  void _printErrors() {
-    // The following is a hack. We currently print out to stderr to ensure that
-    // when in batch mode we print to stderr, this is because the prints from
-    // batch are made to stderr. The reason that options.shouldBatch isn't used
-    // is because when the argument flags are constructed in BatchRunner and
-    // passed in from batch mode which removes the batch flag to prevent the
-    // "cannot have the batch flag and source file" error message.
-    StringSink sink = options.machineFormat ? errorSink : outSink;
-
-    // Print errors.
-    ErrorFormatter formatter =
-        new ErrorFormatter(sink, options, stats, _processError);
-    formatter.formatErrors(errorInfos);
-  }
-
-  ProcessedSeverity _processError(AnalysisError error) =>
-      processError(error, options, analysisOptions);
+  ProcessedSeverity _defaultSeverityProcessor(AnalysisError error) =>
+      determineProcessedSeverity(error, options, analysisOptions);
 
   Future<LibraryElement> _resolveLibrary() async {
     PerformanceTag previous = _resolveLibraryTag.makeCurrent();
     try {
       if (analysisDriver != null) {
         String path = librarySource.fullName;
         analysisDriver.priorityFiles = [path];
         UnitElementResult elementResult =
             await analysisDriver.getUnitElement(path);
         return elementResult.element.library;
@@ skipping 51 matching lines @@
   }
 
   @override
   void logInformation(String message, [CaughtException exception]) {
     outSink.writeln(message);
     if (exception != null) {
       outSink.writeln(exception);
     }
   }
 }