Track previous diagnostic behavior

Switch from a fatal-state machine to a previous-behavior-state
machine, which is more flexible in the presence of suppressible
warnings.

Author: milseman

include/swift/AST/DiagnosticEngine.h

@@ -398,18 +398,14 @@ namespace swift {
     /// fatal error
     bool showDiagnosticsAfterFatalError = false;
 
+    /// \brief Whether a fatal error has occurred
+    bool fatalErrorOccurred = false;
+
     /// \brief Whether any error diagnostics have been emitted.
     bool anyErrorOccurred = false;
 
-    /// Fatal error tracking
-    enum class FatalErrorState {
-      None,
-      JustEmitted,
-      Fatal
-    };
-
-    /// Sticky flag set to \c true when a fatal error is emitted.
-    FatalErrorState fatalState = FatalErrorState::None;
+    /// \brief Track the previous emitted Behavior, useful for notes
+    Behavior previousBehavior = Behavior::Unspecified;
 
   public:
     DiagnosticState() {}
@@ -418,17 +414,15 @@ namespace swift {
     Behavior getBehavior(const Diagnostic &);
 
     bool hadAnyError() const { return anyErrorOccurred; }
-    bool hasFatalErrorOccurred() const {
-      return fatalState != FatalErrorState::None;
-    }
+    bool hasFatalErrorOccurred() const { return fatalErrorOccurred; }
 
     void setShowDiagnosticsAfterFatalError(bool val = true) {
       showDiagnosticsAfterFatalError = val;
     }
 
     void resetHadAnyError() {
       anyErrorOccurred = false;
-      fatalState = FatalErrorState::None;
+      fatalErrorOccurred = false;
     }
 
   private:

lib/AST/DiagnosticEngine.cpp

@@ -452,30 +452,33 @@ static void formatDiagnosticText(StringRef InText,
 DiagnosticState::Behavior DiagnosticState::getBehavior(const Diagnostic &diag) {
   auto set = [this](DiagnosticState::Behavior lvl) {
     if (lvl == Behavior::Fatal) {
-      fatalState = FatalErrorState::JustEmitted;
+      fatalErrorOccurred = true;
       anyErrorOccurred = true;
     } else if (lvl == Behavior::Err) {
       anyErrorOccurred = true;
     }
+
+    previousBehavior = lvl;
     return lvl;
   };
 
   auto diagKind = StoredDiagnosticInfos[(unsigned)diag.getID()].Kind;
 
-  if (fatalState != FatalErrorState::None) {
-    bool shouldIgnore = true;
-    if (diagKind == DiagnosticKind::Note)
-      shouldIgnore = (fatalState == FatalErrorState::Fatal);
-    else
-      fatalState = FatalErrorState::Fatal;
-
-    if (shouldIgnore && !showDiagnosticsAfterFatalError) {
+  // Notes relating to ignored diagnostics should also be ignored
+  if (previousBehavior == Behavior::Ignore && diagKind == DiagnosticKind::Note)
+    return set(Behavior::Ignore);
+
+  // Suppress diagnostics when in a fatal state, except for follow-on notes
+  // about the original fatal diag
+  if (fatalErrorOccurred) {
+    bool emitAnyways = showDiagnosticsAfterFatalError ||
+                       (diagKind == DiagnosticKind::Note &&
+                        previousBehavior != Behavior::Ignore);
+    if (!emitAnyways)
       return set(Behavior::Ignore);
-    }
-  }
-
-  if (isDiagnosticFatal(diag.getID()))
+  } else if (isDiagnosticFatal(diag.getID())) {
     return set(Behavior::Fatal);
+  }
 
   // Re-map as appropriate
   switch (diagKind) {