contrib/llvm/tools/clang/include/clang/Basic/PartialDiagnostic.h

   1 //===--- PartialDiagnostic.h - Diagnostic "closures" ------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 ///
  10 /// \file
  11 /// \brief Implements a partial diagnostic that can be emitted anwyhere
  12 /// in a DiagnosticBuilder stream.
  13 ///
  14 //===----------------------------------------------------------------------===//
  15
  16 #ifndef LLVM_CLANG_PARTIALDIAGNOSTIC_H
  17 #define LLVM_CLANG_PARTIALDIAGNOSTIC_H
  18
  19 #include "clang/Basic/Diagnostic.h"
  20 #include "clang/Basic/SourceLocation.h"
  21 #include "llvm/ADT/STLExtras.h"
  22 #include "llvm/Support/Compiler.h"
  23 #include "llvm/Support/DataTypes.h"
  24 #include <cassert>
  25
  26 namespace clang {
  27
  28 class PartialDiagnostic {
  29 public:
  30   enum {
  31       // The MaxArguments and MaxFixItHints member enum values from
  32       // DiagnosticsEngine are private but DiagnosticsEngine declares
  33       // PartialDiagnostic a friend.  These enum values are redeclared
  34       // here so that the nested Storage class below can access them.
  35       MaxArguments = DiagnosticsEngine::MaxArguments
  36   };
  37
  38   struct Storage {
  39     Storage() : NumDiagArgs(0), NumDiagRanges(0) { }
  40
  41     enum {
  42         /// \brief The maximum number of arguments we can hold. We
  43         /// currently only support up to 10 arguments (%0-%9).
  44         ///
  45         /// A single diagnostic with more than that almost certainly has to
  46         /// be simplified anyway.
  47         MaxArguments = PartialDiagnostic::MaxArguments
  48     };
  49
  50     /// \brief The number of entries in Arguments.
  51     unsigned char NumDiagArgs;
  52
  53     /// \brief This is the number of ranges in the DiagRanges array.
  54     unsigned char NumDiagRanges;
  55
  56     /// \brief Specifies for each argument whether it is in DiagArgumentsStr
  57     /// or in DiagArguments.
  58     unsigned char DiagArgumentsKind[MaxArguments];
  59
  60     /// \brief The values for the various substitution positions.
  61     ///
  62     /// This is used when the argument is not an std::string. The specific value
  63     /// is mangled into an intptr_t and the interpretation depends on exactly
  64     /// what sort of argument kind it is.
  65     intptr_t DiagArgumentsVal[MaxArguments];
  66
  67     /// \brief The values for the various substitution positions that have
  68     /// string arguments.
  69     std::string DiagArgumentsStr[MaxArguments];
  70
  71     /// \brief The list of ranges added to this diagnostic.
  72     ///
  73     /// It currently only support 10 ranges, could easily be extended if needed.
  74     CharSourceRange DiagRanges[10];
  75
  76     /// \brief If valid, provides a hint with some code to insert, remove, or
  77     /// modify at a particular position.
  78     SmallVector<FixItHint, 6>  FixItHints;
  79   };
  80
  81   /// \brief An allocator for Storage objects, which uses a small cache to
  82   /// objects, used to reduce malloc()/free() traffic for partial diagnostics.
  83   class StorageAllocator {
  84     static const unsigned NumCached = 16;
  85     Storage Cached[NumCached];
  86     Storage *FreeList[NumCached];
  87     unsigned NumFreeListEntries;
  88
  89   public:
  90     StorageAllocator();
  91     ~StorageAllocator();
  92
  93     /// \brief Allocate new storage.
  94     Storage *Allocate() {
  95       if (NumFreeListEntries == 0)
  96         return new Storage;
  97
  98       Storage *Result = FreeList[--NumFreeListEntries];
  99       Result->NumDiagArgs = 0;
 100       Result->NumDiagRanges = 0;
 101       Result->FixItHints.clear();
 102       return Result;
 103     }
 104
 105     /// \brief Free the given storage object.
 106     void Deallocate(Storage *S) {
 107       if (S >= Cached && S <= Cached + NumCached) {
 108         FreeList[NumFreeListEntries++] = S;
 109         return;
 110       }
 111
 112       delete S;
 113     }
 114   };
 115
 116 private:
 117   // NOTE: Sema assumes that PartialDiagnostic is location-invariant
 118   // in the sense that its bits can be safely memcpy'ed and destructed
 119   // in the new location.
 120
 121   /// \brief The diagnostic ID.
 122   mutable unsigned DiagID;
 123
 124   /// \brief Storage for args and ranges.
 125   mutable Storage *DiagStorage;
 126
 127   /// \brief Allocator used to allocate storage for this diagnostic.
 128   StorageAllocator *Allocator;
 129
 130   /// \brief Retrieve storage for this particular diagnostic.
 131   Storage *getStorage() const {
 132     if (DiagStorage)
 133       return DiagStorage;
 134
 135     if (Allocator)
 136       DiagStorage = Allocator->Allocate();
 137     else {
 138       assert(Allocator != reinterpret_cast<StorageAllocator *>(~uintptr_t(0)));
 139       DiagStorage = new Storage;
 140     }
 141     return DiagStorage;
 142   }
 143
 144   void freeStorage() {
 145     if (!DiagStorage)
 146       return;
 147
 148     // The hot path for PartialDiagnostic is when we just used it to wrap an ID
 149     // (typically so we have the flexibility of passing a more complex
 150     // diagnostic into the callee, but that does not commonly occur).
 151     //
 152     // Split this out into a slow function for silly compilers (*cough*) which
 153     // can't do decent partial inlining.
 154     freeStorageSlow();
 155   }
 156
 157   void freeStorageSlow() {
 158     if (Allocator)
 159       Allocator->Deallocate(DiagStorage);
 160     else if (Allocator != reinterpret_cast<StorageAllocator *>(~uintptr_t(0)))
 161       delete DiagStorage;
 162     DiagStorage = 0;
 163   }
 164
 165   void AddSourceRange(const CharSourceRange &R) const {
 166     if (!DiagStorage)
 167       DiagStorage = getStorage();
 168
 169     assert(DiagStorage->NumDiagRanges <
 170            llvm::array_lengthof(DiagStorage->DiagRanges) &&
 171            "Too many arguments to diagnostic!");
 172     DiagStorage->DiagRanges[DiagStorage->NumDiagRanges++] = R;
 173   }
 174
 175   void AddFixItHint(const FixItHint &Hint) const {
 176     if (Hint.isNull())
 177       return;
 178
 179     if (!DiagStorage)
 180       DiagStorage = getStorage();
 181
 182     DiagStorage->FixItHints.push_back(Hint);
 183   }
 184
 185 public:
 186   struct NullDiagnostic {};
 187   /// \brief Create a null partial diagnostic, which cannot carry a payload,
 188   /// and only exists to be swapped with a real partial diagnostic.
 189   PartialDiagnostic(NullDiagnostic)
 190     : DiagID(0), DiagStorage(0), Allocator(0) { }
 191
 192   PartialDiagnostic(unsigned DiagID, StorageAllocator &Allocator)
 193     : DiagID(DiagID), DiagStorage(0), Allocator(&Allocator) { }
 194
 195   PartialDiagnostic(const PartialDiagnostic &Other)
 196     : DiagID(Other.DiagID), DiagStorage(0), Allocator(Other.Allocator)
 197   {
 198     if (Other.DiagStorage) {
 199       DiagStorage = getStorage();
 200       *DiagStorage = *Other.DiagStorage;
 201     }
 202   }
 203
 204 #if LLVM_HAS_RVALUE_REFERENCES
 205   PartialDiagnostic(PartialDiagnostic &&Other)
 206     : DiagID(Other.DiagID), DiagStorage(Other.DiagStorage),
 207       Allocator(Other.Allocator) {
 208     Other.DiagStorage = 0;
 209   }
 210 #endif
 211
 212   PartialDiagnostic(const PartialDiagnostic &Other, Storage *DiagStorage)
 213     : DiagID(Other.DiagID), DiagStorage(DiagStorage),
 214       Allocator(reinterpret_cast<StorageAllocator *>(~uintptr_t(0)))
 215   {
 216     if (Other.DiagStorage)
 217       *this->DiagStorage = *Other.DiagStorage;
 218   }
 219
 220   PartialDiagnostic(const Diagnostic &Other, StorageAllocator &Allocator)
 221     : DiagID(Other.getID()), DiagStorage(0), Allocator(&Allocator)
 222   {
 223     // Copy arguments.
 224     for (unsigned I = 0, N = Other.getNumArgs(); I != N; ++I) {
 225       if (Other.getArgKind(I) == DiagnosticsEngine::ak_std_string)
 226         AddString(Other.getArgStdStr(I));
 227       else
 228         AddTaggedVal(Other.getRawArg(I), Other.getArgKind(I));
 229     }
 230
 231     // Copy source ranges.
 232     for (unsigned I = 0, N = Other.getNumRanges(); I != N; ++I)
 233       AddSourceRange(Other.getRange(I));
 234
 235     // Copy fix-its.
 236     for (unsigned I = 0, N = Other.getNumFixItHints(); I != N; ++I)
 237       AddFixItHint(Other.getFixItHint(I));
 238   }
 239
 240   PartialDiagnostic &operator=(const PartialDiagnostic &Other) {
 241     DiagID = Other.DiagID;
 242     if (Other.DiagStorage) {
 243       if (!DiagStorage)
 244         DiagStorage = getStorage();
 245
 246       *DiagStorage = *Other.DiagStorage;
 247     } else {
 248       freeStorage();
 249     }
 250
 251     return *this;
 252   }
 253
 254 #if LLVM_HAS_RVALUE_REFERENCES
 255   PartialDiagnostic &operator=(PartialDiagnostic &&Other) {
 256     freeStorage();
 257
 258     DiagID = Other.DiagID;
 259     DiagStorage = Other.DiagStorage;
 260     Allocator = Other.Allocator;
 261
 262     Other.DiagStorage = 0;
 263     return *this;
 264   }
 265 #endif
 266
 267   ~PartialDiagnostic() {
 268     freeStorage();
 269   }
 270
 271   void swap(PartialDiagnostic &PD) {
 272     std::swap(DiagID, PD.DiagID);
 273     std::swap(DiagStorage, PD.DiagStorage);
 274     std::swap(Allocator, PD.Allocator);
 275   }
 276
 277   unsigned getDiagID() const { return DiagID; }
 278
 279   void AddTaggedVal(intptr_t V, DiagnosticsEngine::ArgumentKind Kind) const {
 280     if (!DiagStorage)
 281       DiagStorage = getStorage();
 282
 283     assert(DiagStorage->NumDiagArgs < Storage::MaxArguments &&
 284            "Too many arguments to diagnostic!");
 285     DiagStorage->DiagArgumentsKind[DiagStorage->NumDiagArgs] = Kind;
 286     DiagStorage->DiagArgumentsVal[DiagStorage->NumDiagArgs++] = V;
 287   }
 288
 289   void AddString(StringRef V) const {
 290     if (!DiagStorage)
 291       DiagStorage = getStorage();
 292
 293     assert(DiagStorage->NumDiagArgs < Storage::MaxArguments &&
 294            "Too many arguments to diagnostic!");
 295     DiagStorage->DiagArgumentsKind[DiagStorage->NumDiagArgs]
 296       = DiagnosticsEngine::ak_std_string;
 297     DiagStorage->DiagArgumentsStr[DiagStorage->NumDiagArgs++] = V;
 298   }
 299
 300   void Emit(const DiagnosticBuilder &DB) const {
 301     if (!DiagStorage)
 302       return;
 303
 304     // Add all arguments.
 305     for (unsigned i = 0, e = DiagStorage->NumDiagArgs; i != e; ++i) {
 306       if ((DiagnosticsEngine::ArgumentKind)DiagStorage->DiagArgumentsKind[i]
 307             == DiagnosticsEngine::ak_std_string)
 308         DB.AddString(DiagStorage->DiagArgumentsStr[i]);
 309       else
 310         DB.AddTaggedVal(DiagStorage->DiagArgumentsVal[i],
 311             (DiagnosticsEngine::ArgumentKind)DiagStorage->DiagArgumentsKind[i]);
 312     }
 313
 314     // Add all ranges.
 315     for (unsigned i = 0, e = DiagStorage->NumDiagRanges; i != e; ++i)
 316       DB.AddSourceRange(DiagStorage->DiagRanges[i]);
 317
 318     // Add all fix-its.
 319     for (unsigned i = 0, e = DiagStorage->FixItHints.size(); i != e; ++i)
 320       DB.AddFixItHint(DiagStorage->FixItHints[i]);
 321   }
 322
 323   void EmitToString(DiagnosticsEngine &Diags,
 324                     SmallVectorImpl<char> &Buf) const {
 325     // FIXME: It should be possible to render a diagnostic to a string without
 326     //        messing with the state of the diagnostics engine.
 327     DiagnosticBuilder DB(Diags.Report(getDiagID()));
 328     Emit(DB);
 329     DB.FlushCounts();
 330     Diagnostic(&Diags).FormatDiagnostic(Buf);
 331     DB.Clear();
 332     Diags.Clear();
 333   }
 334
 335   /// \brief Clear out this partial diagnostic, giving it a new diagnostic ID
 336   /// and removing all of its arguments, ranges, and fix-it hints.
 337   void Reset(unsigned DiagID = 0) {
 338     this->DiagID = DiagID;
 339     freeStorage();
 340   }
 341
 342   bool hasStorage() const { return DiagStorage != 0; }
 343
 344   friend const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
 345                                              unsigned I) {
 346     PD.AddTaggedVal(I, DiagnosticsEngine::ak_uint);
 347     return PD;
 348   }
 349
 350   friend const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
 351                                              int I) {
 352     PD.AddTaggedVal(I, DiagnosticsEngine::ak_sint);
 353     return PD;
 354   }
 355
 356   friend inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
 357                                                     const char *S) {
 358     PD.AddTaggedVal(reinterpret_cast<intptr_t>(S),
 359                     DiagnosticsEngine::ak_c_string);
 360     return PD;
 361   }
 362
 363   friend inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
 364                                                     StringRef S) {
 365
 366     PD.AddString(S);
 367     return PD;
 368   }
 369
 370   friend inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
 371                                                     const SourceRange &R) {
 372     PD.AddSourceRange(CharSourceRange::getTokenRange(R));
 373     return PD;
 374   }
 375
 376   friend inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
 377                                                     const CharSourceRange &R) {
 378     PD.AddSourceRange(R);
 379     return PD;
 380   }
 381
 382   friend const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
 383                                              const FixItHint &Hint) {
 384     PD.AddFixItHint(Hint);
 385     return PD;
 386   }
 387
 388 };
 389
 390 inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
 391                                            const PartialDiagnostic &PD) {
 392   PD.Emit(DB);
 393   return DB;
 394 }
 395
 396 /// \brief A partial diagnostic along with the source location where this
 397 /// diagnostic occurs.
 398 typedef std::pair<SourceLocation, PartialDiagnostic> PartialDiagnosticAt;
 399
 400 }  // end namespace clang
 401 #endif