Introduce DiagnosticState to track how we should handle diagnostics

Refactor DiagnosticEngine to separate out diagnostic state
tracking. This allows gives us a base from which to add further
refinements, e.g. warning suppression.

Author: milseman

include/swift/AST/DiagnosticEngine.h

@@ -378,6 +378,70 @@ namespace swift {
       return fixItReplaceChars(Start, End, {});
     }
   };
+
+  /// \brief Class to track, map, and remap diagnostic severity and fatality
+  ///
+  class DiagnosticState {
+  public:
+    /// \brief Describes the current behavior to take with a diagnostic
+    enum class Behavior {
+      Unspecified,
+      Ignore,
+      Note,
+      Warn,
+      Err,
+      Fatal,
+    };
+
+  private:
+    /// \brief Whether we should continue to emit diagnostics, even after a
+    /// fatal error
+    bool showDiagnosticsAfterFatalError = 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;
+
+  public:
+    DiagnosticState() {}
+
+    /// \brief Figure out the Behavior for the given diagnostic
+    Behavior getBehavior(const Diagnostic &);
+
+    bool hadAnyError() const { return anyErrorOccurred; }
+    bool hasFatalErrorOccurred() const {
+      return fatalState != FatalErrorState::None;
+    }
+
+    void setShowDiagnosticsAfterFatalError(bool val = true) {
+      showDiagnosticsAfterFatalError = val;
+    }
+
+    void resetHadAnyError() {
+      anyErrorOccurred = false;
+      fatalState = FatalErrorState::None;
+    }
+
+  private:
+    /// \returns true if diagnostic is marked as fatal.
+    bool isDiagnosticFatal(DiagID ID) const;
+
+    // Make the state movable only
+    DiagnosticState(const DiagnosticState &) = delete;
+    const DiagnosticState &operator=(const DiagnosticState &) = delete;
+
+    DiagnosticState(DiagnosticState &&) = default;
+    DiagnosticState &operator=(DiagnosticState &&) = default;
+  };
 
   /// \brief Class responsible for formatting diagnostics and presenting them
   /// to the user.
@@ -390,19 +454,7 @@ namespace swift {
     /// emitting diagnostics.
     SmallVector<DiagnosticConsumer *, 2> Consumers;
 
-    /// HadAnyError - True if any error diagnostics have been emitted.
-    bool HadAnyError;
-
-    enum class FatalErrorState {
-      None,
-      JustEmitted,
-      Fatal
-    };
-
-    /// Sticky flag set to \c true when a fatal error is emitted.
-    FatalErrorState FatalState = FatalErrorState::None;
-
-    bool ShowDiagnosticsAfterFatalError = false;
+    DiagnosticState state;
 
     /// \brief The currently active diagnostic, if there is one.
     Optional<Diagnostic> ActiveDiagnostic;
@@ -424,25 +476,22 @@ namespace swift {
 
   public:
     explicit DiagnosticEngine(SourceManager &SourceMgr)
-      : SourceMgr(SourceMgr), HadAnyError(false), ActiveDiagnostic() {
+      : SourceMgr(SourceMgr), state(), ActiveDiagnostic() {
     }
 
     /// hadAnyError - return true if any *error* diagnostics have been emitted.
-    bool hadAnyError() const {
-      return HadAnyError;
-    }
+    bool hadAnyError() const { return state.hadAnyError(); }
 
     bool hasFatalErrorOccurred() const {
-      return FatalState != FatalErrorState::None;
+      return state.hasFatalErrorOccurred();
     }
 
-    void setShowDiagnosticsAfterFatalError(bool Val = true) {
-      ShowDiagnosticsAfterFatalError = Val;
+    void setShowDiagnosticsAfterFatalError(bool val = true) {
+      state.setShowDiagnosticsAfterFatalError(val);
     }
 
     void resetHadAnyError() {
-      HadAnyError = false;
-      FatalState = FatalErrorState::None;
+      state.resetHadAnyError();
     }
 
     /// \brief Add an additional DiagnosticConsumer to receive diagnostics.
@@ -572,10 +621,7 @@ namespace swift {
 
     /// \returns true if diagnostic is marked with PointsToFirstBadToken
     /// option.
-    bool isDiagnosticPointsToFirstBadToken(DiagID ID) const;
-
-    /// \returns true if diagnostic is marked as fatal.
-    bool isDiagnosticFatal(DiagID ID) const;
+    bool isDiagnosticPointsToFirstBadToken(DiagID id) const;
 
   private:
     /// \brief Flush the active diagnostic.

lib/AST/DiagnosticEngine.cpp

@@ -180,7 +180,7 @@ bool DiagnosticEngine::isDiagnosticPointsToFirstBadToken(DiagID ID) const {
   return StoredInfo.Options == DiagnosticOptions::PointsToFirstBadToken;
 }
 
-bool DiagnosticEngine::isDiagnosticFatal(DiagID ID) const {
+bool DiagnosticState::isDiagnosticFatal(DiagID ID) const {
   const StoredDiagnosticInfo &StoredInfo =
       StoredDiagnosticInfos[(unsigned) ID];
   return StoredInfo.Options == DiagnosticOptions::Fatal;
@@ -449,6 +449,45 @@ 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;
+      anyErrorOccurred = true;
+    } else if (lvl == Behavior::Err) {
+      anyErrorOccurred = true;
+    }
+    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) {
+      return set(Behavior::Ignore);
+    }
+  }
+
+  if (isDiagnosticFatal(diag.getID()))
+    return set(Behavior::Fatal);
+
+  // Re-map as appropriate
+  switch (diagKind) {
+  case DiagnosticKind::Error:
+    return set(Behavior::Err);
+  case DiagnosticKind::Warning:
+    return set(Behavior::Warn);
+  case DiagnosticKind::Note:
+    return set(Behavior::Note);
+  }
+}
+
 void DiagnosticEngine::flushActiveDiagnostic() {
   assert(ActiveDiagnostic && "No active diagnostic to flush");
   if (TransactionCount == 0) {
@@ -467,34 +506,13 @@ void DiagnosticEngine::emitTentativeDiagnostics() {
 }
 
 void DiagnosticEngine::emitDiagnostic(const Diagnostic &diagnostic) {
+  auto behavior = state.getBehavior(diagnostic);
+  if (behavior == DiagnosticState::Behavior::Ignore)
+    return;
+
   const StoredDiagnosticInfo &StoredInfo
     = StoredDiagnosticInfos[(unsigned)diagnostic.getID()];
 
-  if (FatalState != FatalErrorState::None) {
-    bool shouldIgnore = true;
-    if (StoredInfo.Kind == DiagnosticKind::Note)
-      shouldIgnore = (FatalState == FatalErrorState::Fatal);
-    else
-      FatalState = FatalErrorState::Fatal;
-
-    if (shouldIgnore && !ShowDiagnosticsAfterFatalError) {
-      return;
-    }
-  }
-
-  // Check whether this is an error.
-  switch (StoredInfo.Kind) {
-  case DiagnosticKind::Error:
-    HadAnyError = true;
-    if (isDiagnosticFatal(diagnostic.getID()))
-      FatalState = FatalErrorState::JustEmitted;
-    break;
-    
-  case DiagnosticKind::Note:
-  case DiagnosticKind::Warning:
-    break;
-  }
-
   // Figure out the source location.
   SourceLoc loc = diagnostic.getLoc();
   if (loc.isInvalid() && diagnostic.getDecl()) {