[Basic] Introduce active dummy DiagnosticBuilder

[nik]

Summary

...which does not emit anything.

This dummy is useful for filtering. Code expecting a DiagnosticBuilder
object can get a dummy and report further details, without
knowing/checking whether this is needed at all.

[gribozavr]

Is this patch still needed?

[nik]

In D61486#1532272, @gribozavr wrote:

Is this patch still needed?

Nope, abandoning it now.

include/clang/Basic/Diagnostic.h

class DiagnosticBuilder {
 
   /// Status variable indicating if this diagnostic is still active.
   ///
   // NOTE: This field is redundant with DiagObj (IsActive iff (DiagObj == 0)),
   // but LLVM is not currently smart enough to eliminate the null check that
   // Emit() would end up with if we used that as our status variable.
   mutable bool IsActive = false;
 
+  /// Flag indicating an active dummy builder that will not emit anything.
+  mutable bool IsDummy = false;
+
   /// Flag indicating that this diagnostic is being emitted via a
   /// call to ForceEmit.
   mutable bool IsForceEmit = false;
 
   DiagnosticBuilder() = default;
 
   explicit DiagnosticBuilder(DiagnosticsEngine *diagObj)
       : DiagObj(diagObj), IsActive(true) {
     assert(diagObj && "DiagnosticBuilder requires a valid DiagnosticsEngine!");
     diagObj->DiagRanges.clear();
     diagObj->DiagFixItHints.clear();
   }
 
 protected:
   void FlushCounts() {
     DiagObj->NumDiagArgs = NumArgs;
   }
 
   /// Clear out the current diagnostic.
   void Clear() const {
     DiagObj = nullptr;
     IsActive = false;
+    IsDummy = false;
     IsForceEmit = false;
   }
 
   /// Determine whether this diagnostic is still active.
   bool isActive() const { return IsActive; }
 
   /// Force the diagnostic builder to emit the diagnostic now.
   ///
   /// Once this function has been called, the DiagnosticBuilder object
   /// should not be used again before it is destroyed.
   ///
   /// \returns true if a diagnostic was emitted, false if the
   /// diagnostic was suppressed.
   bool Emit() {
     // If this diagnostic is inactive, then its soul was stolen by the copy ctor
     // (or by a subclass, as in SemaDiagnosticBuilder).
     if (!isActive()) return false;
 
+    if (IsDummy) {
+      DiagObj->Clear();
+      Clear();
+      return false;
+    }
+
     // When emitting diagnostics, we set the final argument count into
     // the DiagnosticsEngine object.
     FlushCounts();
 
     // Process the diagnostic.
     bool Result = DiagObj->EmitCurrentDiagnostic(IsForceEmit);
 
     // This diagnostic is dead.
     Clear();
 
     return Result;
   }
 
 public:
   /// Copy constructor.  When copied, this "takes" the diagnostic info from the
   /// input and neuters it.
   DiagnosticBuilder(const DiagnosticBuilder &D) {
     DiagObj = D.DiagObj;
     IsActive = D.IsActive;
+    IsDummy = D.IsDummy;
     IsForceEmit = D.IsForceEmit;
     D.Clear();
     NumArgs = D.NumArgs;
   }
 
   DiagnosticBuilder &operator=(const DiagnosticBuilder &) = delete;
 
   /// Emits the diagnostic.
   ~DiagnosticBuilder() {
     Emit();
   }
 
   /// Retrieve an empty diagnostic builder.
   static DiagnosticBuilder getEmpty() {
     return {};
   }
 
+  /// Retrieve an active diagnostic builder that will not emit anything.
+  static DiagnosticBuilder getDummy(DiagnosticsEngine *diagObj) {
+    DiagnosticBuilder D(diagObj);
+    D.IsDummy = true;
+    return D;
+  }
+
   /// Forces the diagnostic to be emitted.
   const DiagnosticBuilder &setForceEmit() const {
     IsForceEmit = true;
     return *this;
   }
 
   /// Conversion of DiagnosticBuilder to bool always returns \c true.
   ///