Track errors

Author: David Ungar

include/swift/AST/DiagnosticConsumer.h

@@ -162,7 +162,7 @@ class FileSpecificDiagnosticConsumer : public DiagnosticConsumer {
   /// This allows diagnostics to be emitted before files are actually opened,
   /// as long as they don't have source locations.
   ///
-  /// \see #consumerForLocation
+  /// \see #consumerSpecificInformationForLocation
   SmallVector<ConsumerSpecificInformation, 4> ConsumersOrderedByRange;
 
   /// Indicates which consumer to send Note diagnostics too.
@@ -172,7 +172,8 @@ class FileSpecificDiagnosticConsumer : public DiagnosticConsumer {
   ///
   /// If None, Note diagnostics are sent to every consumer.
   /// If null, diagnostics are suppressed.
-  Optional<DiagnosticConsumer *> ConsumerForSubsequentNotes = None;
+  Optional<ConsumerSpecificInformation *>
+      ConsumerSpecificInfoForSubsequentNotes = None;
 
   bool WasAnErrorSuppressed = false;
 
@@ -200,8 +201,9 @@ class FileSpecificDiagnosticConsumer : public DiagnosticConsumer {
   /// Returns nullptr if diagnostic is to be suppressed,
   /// None if diagnostic is to be distributed to every consumer,
   /// a particular consumer if diagnostic goes there.
-  Optional<DiagnosticConsumer *> consumerForLocation(SourceManager &SM,
-                                                     SourceLoc loc) const;
+  Optional<ConsumerSpecificInformation *>
+  consumerSpecificInformationForLocation(SourceManager &SM,
+                                         SourceLoc loc) const;
 };
 
 } // end namespace swift

lib/AST/DiagnosticConsumer.cpp

@@ -101,16 +101,9 @@ void FileSpecificDiagnosticConsumer::computeConsumersOrderedByRange(
          "overlapping ranges despite having distinct files");
 }
 
-Optional<DiagnosticConsumer *>
-FileSpecificDiagnosticConsumer::consumerForLocation(SourceManager &SM,
-                                                    SourceLoc loc) const {
-  // If there's only one consumer, we'll use it no matter what, because...
-  // - ...all diagnostics within the file will go to that consumer.
-  // - ...all diagnostics not within the file will not be claimed by any
-  //   consumer, and so will go to all (one) consumers.
-  if (SubConsumers.size() == 1)
-    return SubConsumers.front().second.get();
-
+Optional<FileSpecificDiagnosticConsumer::ConsumerSpecificInformation *>
+FileSpecificDiagnosticConsumer::consumerSpecificInformationForLocation(
+    SourceManager &SM, SourceLoc loc) const {
   // Diagnostics with invalid locations always go to every consumer.
   if (loc.isInvalid())
     return None;
@@ -141,17 +134,19 @@ FileSpecificDiagnosticConsumer::consumerForLocation(SourceManager &SM,
   // that /might/ contain 'loc'. Specifically, since the ranges are sorted
   // by end location, it's looking for the first range where the end location
   // is greater than or equal to 'loc'.
-  auto possiblyContainingRangeIter = std::lower_bound(
-      ConsumersOrderedByRange.begin(), ConsumersOrderedByRange.end(), loc,
-      [](const ConsumerSpecificInformation &entry, SourceLoc loc) -> bool {
-        auto compare = std::less<const char *>();
-        return compare(getRawLoc(entry.range.getEnd()).getPointer(),
-                       getRawLoc(loc).getPointer());
-      });
+  const ConsumerSpecificInformation *possiblyContainingRangeIter =
+      std::lower_bound(
+          ConsumersOrderedByRange.begin(), ConsumersOrderedByRange.end(), loc,
+          [](const ConsumerSpecificInformation &entry, SourceLoc loc) -> bool {
+            auto compare = std::less<const char *>();
+            return compare(getRawLoc(entry.range.getEnd()).getPointer(),
+                           getRawLoc(loc).getPointer());
+          });
 
   if (possiblyContainingRangeIter != ConsumersOrderedByRange.end() &&
       possiblyContainingRangeIter->range.contains(loc)) {
-    return possiblyContainingRangeIter->consumer;
+    return const_cast<ConsumerSpecificInformation *>(
+        possiblyContainingRangeIter);
   }
 
   return None;
@@ -162,31 +157,36 @@ void FileSpecificDiagnosticConsumer::handleDiagnostic(
     StringRef FormatString, ArrayRef<DiagnosticArgument> FormatArgs,
     const DiagnosticInfo &Info) {
 
-  Optional<DiagnosticConsumer *> specificConsumer;
+  Optional<ConsumerSpecificInformation *> consumerSpecificInfo;
   switch (Kind) {
   case DiagnosticKind::Error:
   case DiagnosticKind::Warning:
   case DiagnosticKind::Remark:
-    specificConsumer = consumerForLocation(SM, Loc);
-    ConsumerForSubsequentNotes = specificConsumer;
+    consumerSpecificInfo = consumerSpecificInformationForLocation(SM, Loc);
+    ConsumerSpecificInfoForSubsequentNotes = consumerSpecificInfo;
     break;
   case DiagnosticKind::Note:
-    specificConsumer = ConsumerForSubsequentNotes;
+    consumerSpecificInfo = ConsumerSpecificInfoForSubsequentNotes;
     break;
   }
-
-  if (!specificConsumer.hasValue()) {
+  if (!consumerSpecificInfo.hasValue()) {
     for (auto &subConsumer : SubConsumers) {
       if (subConsumer.second) {
         subConsumer.second->handleDiagnostic(SM, Loc, Kind, FormatString,
                                              FormatArgs, Info);
       }
     }
-  } else if (DiagnosticConsumer *c = specificConsumer.getValue())
-    c->handleDiagnostic(SM, Loc, Kind, FormatString, FormatArgs, Info);
-  else
+    return;
+  }
+  if (!consumerSpecificInfo.getValue()->consumer) {
     WasAnErrorSuppressed =
         true; // Suppress non-primary diagnostic in batch mode.
+    return;
+  }
+  consumerSpecificInfo.getValue()->consumer->handleDiagnostic(
+      SM, Loc, Kind, FormatString, FormatArgs, Info);
+  consumerSpecificInfo.getValue()->hasAnErrorBeenEmitted |=
+      Kind == DiagnosticKind::Error;
 }
 
 bool FileSpecificDiagnosticConsumer::finishProcessing(SourceManager &SM) {

test/Misc/serialized-diagnostics-batch-mode-nonspecific-error.swift

@@ -16,9 +16,10 @@
 
 // Ensure the error is in the serialized diagnostics:
 
-// RUN: %FileCheck -check-prefix=NONSPECIFIC-ERROR %s <%t.main.txt
+// RUN: %FileCheck -check-prefix=NO-NONSPECIFIC-ERROR %s <%t.main.txt
 // RUN: %FileCheck -check-prefix=NONSPECIFIC-ERROR %s <%t.empty.txt
 // NONSPECIFIC-ERROR: error: some error occured in a file that was used by this one
+// NO-NONSPECIFIC-ERROR-NOT: error: some error occured in a file that was used by this one
 
 func test(x: SomeType) {
   nonexistent()