Allow suppressing individual diagnostics.

Extend DiagnosticState to track per-diagnostic desired behaviors,
allowing users of the APIs to individually suppress diagnostics.

Author: milseman

include/swift/AST/DiagnosticEngine.h

@@ -384,7 +384,7 @@ namespace swift {
   class DiagnosticState {
   public:
     /// \brief Describes the current behavior to take with a diagnostic
-    enum class Behavior {
+    enum class Behavior : uint8_t {
       Unspecified,
       Ignore,
       Note,
@@ -410,11 +410,15 @@ namespace swift {
     /// \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() {}
+    DiagnosticState();
 
-    /// \brief Figure out the Behavior for the given diagnostic
-    Behavior getBehavior(const Diagnostic &);
+    /// \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; }
@@ -432,10 +436,12 @@ namespace swift {
       fatalErrorOccurred = false;
     }
 
-  private:
-    /// \returns true if diagnostic is marked as fatal.
-    bool isDiagnosticFatal(DiagID ID) const;
+    /// 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;
@@ -497,6 +503,10 @@ namespace swift {
       return state.getIgnoreAllWarnings();
     }
 
+    void ignoreDiagnostic(DiagID id) {
+      state.setDiagnosticBehavior(id, DiagnosticState::Behavior::Ignore);
+    }
+
     void resetHadAnyError() {
       state.resetHadAnyError();
     }

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::Err;
+#define WARNING(ID, Category, Options, Text, Signature)                        \
+  perDiagnosticState[LocalDiagID::ID] = Behavior::Warn;
+#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 DiagnosticState::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,13 +456,29 @@ 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);
   }
 }
 
-DiagnosticState::Behavior DiagnosticState::getBehavior(const Diagnostic &diag) {
+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::Err:
+  case DiagnosticState::Behavior::Fatal:
+    return DiagnosticKind::Error;
+  case DiagnosticState::Behavior::Note:
+    return DiagnosticKind::Note;
+  case DiagnosticState::Behavior::Warn:
+    return DiagnosticKind::Warning;
+  }
+}
+
+DiagnosticState::Behavior DiagnosticState::determineBehavior(DiagID id) {
   auto set = [this](DiagnosticState::Behavior lvl) {
     if (lvl == Behavior::Fatal) {
       fatalErrorOccurred = true;
@@ -462,33 +491,26 @@ DiagnosticState::Behavior DiagnosticState::getBehavior(const Diagnostic &diag) {
     return lvl;
   };
 
-  auto diagKind = StoredDiagnosticInfos[(unsigned)diag.getID()].Kind;
+  auto behavior = perDiagnosticState[(unsigned)id];
 
   // Notes relating to ignored diagnostics should also be ignored
-  if (previousBehavior == Behavior::Ignore && diagKind == DiagnosticKind::Note)
+  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 ||
-                       (diagKind == DiagnosticKind::Note &&
+                       (behavior == Behavior::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);
-  }
+  if (behavior == Behavior::Warn && ignoreAllWarnings)
+    return set(Behavior::Ignore);
+
+  return set(behavior);
 }
 
 void DiagnosticEngine::flushActiveDiagnostic() {
@@ -509,13 +531,10 @@ void DiagnosticEngine::emitTentativeDiagnostics() {
 }
 
 void DiagnosticEngine::emitDiagnostic(const Diagnostic &diagnostic) {
-  auto behavior = state.getBehavior(diagnostic);
+  auto behavior = state.determineBehavior(diagnostic.getID());
   if (behavior == DiagnosticState::Behavior::Ignore)
     return;
 
-  const StoredDiagnosticInfo &StoredInfo
-    = StoredDiagnosticInfos[(unsigned)diagnostic.getID()];
-
   // Figure out the source location.
   SourceLoc loc = diagnostic.getLoc();
   if (loc.isInvalid() && diagnostic.getDecl()) {
@@ -634,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.
@@ -643,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);
   }
 }