Merge remote-tracking branch 'milseman/suppress_warnings_api'

Author: milseman

include/swift/AST/DiagnosticEngine.h

@@ -378,6 +378,71 @@ 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 Don't emit any warnings
+    bool ignoreAllWarnings = false;
+
+    /// \brief Whether a fatal error has occurred
+    bool fatalErrorOccurred = false;
+
+    /// \brief Whether any error diagnostics have been emitted.
+    bool anyErrorOccurred = false;
+
+    /// \brief Track the previous emitted Behavior, useful for notes
+    Behavior previousBehavior = Behavior::Unspecified;
+
+  public:
+    DiagnosticState() {}
+
+    /// \brief Figure out the Behavior for the given diagnostic
+    Behavior getBehavior(const Diagnostic &);
+
+    bool hadAnyError() const { return anyErrorOccurred; }
+    bool hasFatalErrorOccurred() const { return fatalErrorOccurred; }
+
+    void setShowDiagnosticsAfterFatalError(bool val = true) {
+      showDiagnosticsAfterFatalError = val;
+    }
+
+    /// \brief Whether to skip emitting warnings
+    void setIgnoreAllWarnings(bool val) { ignoreAllWarnings = val; }
+    bool getIgnoreAllWarnings() const { return ignoreAllWarnings; }
+
+    void resetHadAnyError() {
+      anyErrorOccurred = false;
+      fatalErrorOccurred = false;
+    }
+
+  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 +455,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 +477,28 @@ 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);
+    }
+
+    /// \brief Whether to skip emitting warnings
+    void setIgnoreAllWarnings(bool val) { state.setIgnoreAllWarnings(val); }
+    bool getIgnoreAllWarnings() const {
+      return state.getIgnoreAllWarnings();
     }
 
     void resetHadAnyError() {
-      HadAnyError = false;
-      FatalState = FatalErrorState::None;
+      state.resetHadAnyError();
     }
 
     /// \brief Add an additional DiagnosticConsumer to receive diagnostics.
@@ -572,10 +628,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,48 @@ static void formatDiagnosticText(StringRef InText,
   }
 }
 
+DiagnosticState::Behavior DiagnosticState::getBehavior(const Diagnostic &diag) {
+  auto set = [this](DiagnosticState::Behavior lvl) {
+    if (lvl == Behavior::Fatal) {
+      fatalErrorOccurred = true;
+      anyErrorOccurred = true;
+    } else if (lvl == Behavior::Err) {
+      anyErrorOccurred = true;
+    }
+
+    previousBehavior = lvl;
+    return lvl;
+  };
+
+  auto diagKind = StoredDiagnosticInfos[(unsigned)diag.getID()].Kind;
+
+  // 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);
+  } else 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(ignoreAllWarnings ? Behavior::Ignore : Behavior::Warn);
+  case DiagnosticKind::Note:
+    return set(Behavior::Note);
+  }
+}
+
 void DiagnosticEngine::flushActiveDiagnostic() {
   assert(ActiveDiagnostic && "No active diagnostic to flush");
   if (TransactionCount == 0) {
@@ -467,34 +509,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()) {