Merge pull request #938 from milseman/suppress_warnings_api

API to suppress warnings

Author: DougGregor

include/swift/AST/DiagnosticEngine.h

@@ -378,6 +378,77 @@ 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 : uint8_t {
+      Unspecified,
+      Ignore,
+      Note,
+      Warning,
+      Error,
+      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;
+
+    /// \brief Track settable, per-diagnostic state that we store
+    std::vector<Behavior> perDiagnosticState;
+
+  public:
+    DiagnosticState();
+
+    /// \brief Figure out the Behavior for the given diagnostic, taking current
+    /// state such as fatality into account.
+    Behavior determineBehavior(DiagID);
+
+    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;
+    }
+
+    /// Set per-diagnostic behavior
+    void setDiagnosticBehavior(DiagID id, Behavior behavior) {
+      perDiagnosticState[(unsigned)id] = behavior;
+    }
+
+  private:
+    // 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 +461,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 +483,32 @@ namespace swift {
 
   public:
     explicit DiagnosticEngine(SourceManager &SourceMgr)
-      : SourceMgr(SourceMgr), HadAnyError(false), ActiveDiagnostic() {
+      : SourceMgr(SourceMgr), 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 ignoreDiagnostic(DiagID id) {
+      state.setDiagnosticBehavior(id, DiagnosticState::Behavior::Ignore);
     }
 
     void resetHadAnyError() {
-      HadAnyError = false;
-      FatalState = FatalErrorState::None;
+      state.resetHadAnyError();
     }
 
     /// \brief Add an additional DiagnosticConsumer to receive diagnostics.
@@ -572,10 +638,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

@@ -28,8 +28,10 @@
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/raw_ostream.h"
+
 using namespace swift;
 
+namespace {
 enum class DiagnosticOptions {
   /// No options.
   none,
@@ -46,29 +48,48 @@ enum class DiagnosticOptions {
   Fatal,
 };
 
-struct StoredDiagnosticInfo {
-  /// \brief The kind of diagnostic we're dealing with.
-  DiagnosticKind Kind;
-
-  DiagnosticOptions Options;
+// Reproduce the DiagIDs, as we want both the size and access to the raw ids
+// themselves.
+enum LocalDiagID : uint32_t {
+#define DIAG(KIND, ID, Category, Options, Text, Signature) ID,
+#include "swift/AST/DiagnosticsAll.def"
+  NumDiags
+};
+}
 
-  // FIXME: Category
-  
-  /// \brief Text associated with the diagnostic
-  const char *Text;
+static const char *DiagnosticStrings[] = {
+#define ERROR(ID, Category, Options, Text, Signature) Text,
+#define WARNING(ID, Category, Options, Text, Signature) Text,
+#define NOTE(ID, Category, Options, Text, Signature) Text,
+#include "swift/AST/DiagnosticsAll.def"
+    "<not a diagnostic>",
 };
 
-static StoredDiagnosticInfo StoredDiagnosticInfos[] = {
-#define ERROR(ID,Category,Options,Text,Signature) \
-  { DiagnosticKind::Error, DiagnosticOptions::Options, Text },
-#define WARNING(ID,Category,Options,Text,Signature) \
-  { DiagnosticKind::Warning, DiagnosticOptions::Options, Text },
-#define NOTE(ID,Category,Options,Text,Signature) \
-  { DiagnosticKind::Note, DiagnosticOptions::Options, Text },
+static bool DiagnosticPointsToFirstBadToken[] = {
+#define ERROR(ID, Category, Options, Text, Signature)                          \
+  DiagnosticOptions::Options == DiagnosticOptions::PointsToFirstBadToken,
+#define WARNING(ID, Category, Options, Text, Signature)                        \
+  DiagnosticOptions::Options == DiagnosticOptions::PointsToFirstBadToken,
+#define NOTE(ID, Category, Options, Text, Signature)                           \
+  DiagnosticOptions::Options == DiagnosticOptions::PointsToFirstBadToken,
 #include "swift/AST/DiagnosticsAll.def"
-  { DiagnosticKind::Error, DiagnosticOptions::none, "<not a diagnostic>" }
+    "<not a diagnostic>",
 };
 
+DiagnosticState::DiagnosticState() {
+  // Initialize our per-diagnostic state to the default
+  perDiagnosticState.resize(LocalDiagID::NumDiags);
+#define ERROR(ID, Category, Options, Text, Signature)                          \
+  perDiagnosticState[LocalDiagID::ID] =                                        \
+      DiagnosticOptions::Options == DiagnosticOptions::Fatal ? Behavior::Fatal \
+                                                             : Behavior::Error;
+#define WARNING(ID, Category, Options, Text, Signature)                        \
+  perDiagnosticState[LocalDiagID::ID] = Behavior::Warning;
+#define NOTE(ID, Category, Options, Text, Signature)                           \
+  perDiagnosticState[LocalDiagID::ID] = Behavior::Note;
+#include "swift/AST/DiagnosticsAll.def"
+}
+
 static CharSourceRange toCharSourceRange(SourceManager &SM, SourceRange SR) {
   return CharSourceRange(SM, SR.Start, Lexer::getLocForEndOfToken(SM, SR.End));
 }
@@ -175,15 +196,7 @@ void InFlightDiagnostic::flush() {
 }
 
 bool DiagnosticEngine::isDiagnosticPointsToFirstBadToken(DiagID ID) const {
-  const StoredDiagnosticInfo &StoredInfo =
-      StoredDiagnosticInfos[(unsigned) ID];
-  return StoredInfo.Options == DiagnosticOptions::PointsToFirstBadToken;
-}
-
-bool DiagnosticEngine::isDiagnosticFatal(DiagID ID) const {
-  const StoredDiagnosticInfo &StoredInfo =
-      StoredDiagnosticInfos[(unsigned) ID];
-  return StoredInfo.Options == DiagnosticOptions::Fatal;
+  return DiagnosticPointsToFirstBadToken[(unsigned)ID];
 }
 
 /// \brief Skip forward to one of the given delimiters.
@@ -443,12 +456,63 @@ static void formatDiagnosticText(StringRef InText,
     (void)Result;
     assert(ArgIndex < Args.size() && "Out-of-range argument index");
     InText = InText.substr(Length);
-    
+
     // Convert the argument to a string.
     formatDiagnosticArgument(Modifier, ModifierArguments, Args, ArgIndex, Out);
   }
 }
 
+static DiagnosticKind toDiagnosticKind(DiagnosticState::Behavior behavior) {
+  switch (behavior) {
+  case DiagnosticState::Behavior::Unspecified:
+    llvm_unreachable("unspecified behavior");
+  case DiagnosticState::Behavior::Ignore:
+    llvm_unreachable("trying to map an ignored diagnostic");
+  case DiagnosticState::Behavior::Error:
+  case DiagnosticState::Behavior::Fatal:
+    return DiagnosticKind::Error;
+  case DiagnosticState::Behavior::Note:
+    return DiagnosticKind::Note;
+  case DiagnosticState::Behavior::Warning:
+    return DiagnosticKind::Warning;
+  }
+}
+
+DiagnosticState::Behavior DiagnosticState::determineBehavior(DiagID id) {
+  auto set = [this](DiagnosticState::Behavior lvl) {
+    if (lvl == Behavior::Fatal) {
+      fatalErrorOccurred = true;
+      anyErrorOccurred = true;
+    } else if (lvl == Behavior::Error) {
+      anyErrorOccurred = true;
+    }
+
+    previousBehavior = lvl;
+    return lvl;
+  };
+
+  auto behavior = perDiagnosticState[(unsigned)id];
+
+  // Notes relating to ignored diagnostics should also be ignored
+  if (previousBehavior == Behavior::Ignore && behavior == Behavior::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 ||
+                       (behavior == Behavior::Note &&
+                        previousBehavior != Behavior::Ignore);
+    if (!emitAnyways)
+      return set(Behavior::Ignore);
+  }
+
+  if (behavior == Behavior::Warning && ignoreAllWarnings)
+    return set(Behavior::Ignore);
+
+  return set(behavior);
+}
+
 void DiagnosticEngine::flushActiveDiagnostic() {
   assert(ActiveDiagnostic && "No active diagnostic to flush");
   if (TransactionCount == 0) {
@@ -467,33 +531,9 @@ void DiagnosticEngine::emitTentativeDiagnostics() {
 }
 
 void DiagnosticEngine::emitDiagnostic(const Diagnostic &diagnostic) {
-  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;
-  }
+  auto behavior = state.determineBehavior(diagnostic.getID());
+  if (behavior == DiagnosticState::Behavior::Ignore)
+    return;
 
   // Figure out the source location.
   SourceLoc loc = diagnostic.getLoc();
@@ -613,7 +653,7 @@ void DiagnosticEngine::emitDiagnostic(const Diagnostic &diagnostic) {
   llvm::SmallString<256> Text;
   {
     llvm::raw_svector_ostream Out(Text);
-    formatDiagnosticText(StoredInfo.Text, diagnostic.getArgs(), Out);
+    formatDiagnosticText(DiagnosticStrings[(unsigned)diagnostic.getID()], diagnostic.getArgs(), Out);
   }
 
   // Pass the diagnostic off to the consumer.
@@ -622,7 +662,7 @@ void DiagnosticEngine::emitDiagnostic(const Diagnostic &diagnostic) {
   Info.Ranges = diagnostic.getRanges();
   Info.FixIts = diagnostic.getFixIts();
   for (auto &Consumer : Consumers) {
-    Consumer->handleDiagnostic(SourceMgr, loc, StoredInfo.Kind, Text, Info);
+    Consumer->handleDiagnostic(SourceMgr, loc, toDiagnosticKind(behavior), Text, Info);
   }
 }