clang/lib/Analysis/PathDiagnostic.cpp

   1 //===- PathDiagnostic.cpp - Path-Specific Diagnostic Handling -------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 //  This file defines the PathDiagnostic-related interfaces.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "clang/Analysis/PathDiagnostic.h"
  14 #include "clang/AST/Decl.h"
  15 #include "clang/AST/DeclBase.h"
  16 #include "clang/AST/DeclCXX.h"
  17 #include "clang/AST/DeclObjC.h"
  18 #include "clang/AST/DeclTemplate.h"
  19 #include "clang/AST/Expr.h"
  20 #include "clang/AST/ExprCXX.h"
  21 #include "clang/AST/OperationKinds.h"
  22 #include "clang/AST/ParentMap.h"
  23 #include "clang/AST/PrettyPrinter.h"
  24 #include "clang/AST/Stmt.h"
  25 #include "clang/AST/Type.h"
  26 #include "clang/Analysis/AnalysisDeclContext.h"
  27 #include "clang/Analysis/CFG.h"
  28 #include "clang/Analysis/ProgramPoint.h"
  29 #include "clang/Basic/FileManager.h"
  30 #include "clang/Basic/LLVM.h"
  31 #include "clang/Basic/SourceLocation.h"
  32 #include "clang/Basic/SourceManager.h"
  33 #include "llvm/ADT/ArrayRef.h"
  34 #include "llvm/ADT/FoldingSet.h"
  35 #include "llvm/ADT/None.h"
  36 #include "llvm/ADT/Optional.h"
  37 #include "llvm/ADT/STLExtras.h"
  38 #include "llvm/ADT/SmallString.h"
  39 #include "llvm/ADT/SmallVector.h"
  40 #include "llvm/ADT/StringExtras.h"
  41 #include "llvm/ADT/StringRef.h"
  42 #include "llvm/Support/Casting.h"
  43 #include "llvm/Support/ErrorHandling.h"
  44 #include "llvm/Support/raw_ostream.h"
  45 #include <cassert>
  46 #include <cstring>
  47 #include <memory>
  48 #include <utility>
  49 #include <vector>
  50
  51 using namespace clang;
  52 using namespace ento;
  53
  54 static StringRef StripTrailingDots(StringRef s) {
  55   for (StringRef::size_type i = s.size(); i != 0; --i)
  56     if (s[i - 1] != '.')
  57       return s.substr(0, i);
  58   return {};
  59 }
  60
  61 PathDiagnosticPiece::PathDiagnosticPiece(StringRef s,
  62                                          Kind k, DisplayHint hint)
  63     : str(StripTrailingDots(s)), kind(k), Hint(hint) {}
  64
  65 PathDiagnosticPiece::PathDiagnosticPiece(Kind k, DisplayHint hint)
  66     : kind(k), Hint(hint) {}
  67
  68 PathDiagnosticPiece::~PathDiagnosticPiece() = default;
  69
  70 PathDiagnosticEventPiece::~PathDiagnosticEventPiece() = default;
  71
  72 PathDiagnosticCallPiece::~PathDiagnosticCallPiece() = default;
  73
  74 PathDiagnosticControlFlowPiece::~PathDiagnosticControlFlowPiece() = default;
  75
  76 PathDiagnosticMacroPiece::~PathDiagnosticMacroPiece() = default;
  77
  78 PathDiagnosticNotePiece::~PathDiagnosticNotePiece() = default;
  79
  80 PathDiagnosticPopUpPiece::~PathDiagnosticPopUpPiece() = default;
  81
  82 void PathPieces::flattenTo(PathPieces &Primary, PathPieces &Current,
  83                            bool ShouldFlattenMacros) const {
  84   for (auto &Piece : *this) {
  85     switch (Piece->getKind()) {
  86     case PathDiagnosticPiece::Call: {
  87       auto &Call = cast<PathDiagnosticCallPiece>(*Piece);
  88       if (auto CallEnter = Call.getCallEnterEvent())
  89         Current.push_back(std::move(CallEnter));
  90       Call.path.flattenTo(Primary, Primary, ShouldFlattenMacros);
  91       if (auto callExit = Call.getCallExitEvent())
  92         Current.push_back(std::move(callExit));
  93       break;
  94     }
  95     case PathDiagnosticPiece::Macro: {
  96       auto &Macro = cast<PathDiagnosticMacroPiece>(*Piece);
  97       if (ShouldFlattenMacros) {
  98         Macro.subPieces.flattenTo(Primary, Primary, ShouldFlattenMacros);
  99       } else {
 100         Current.push_back(Piece);
 101         PathPieces NewPath;
 102         Macro.subPieces.flattenTo(Primary, NewPath, ShouldFlattenMacros);
 103         // FIXME: This probably shouldn't mutate the original path piece.
 104         Macro.subPieces = NewPath;
 105       }
 106       break;
 107     }
 108     case PathDiagnosticPiece::Event:
 109     case PathDiagnosticPiece::ControlFlow:
 110     case PathDiagnosticPiece::Note:
 111     case PathDiagnosticPiece::PopUp:
 112       Current.push_back(Piece);
 113       break;
 114     }
 115   }
 116 }
 117
 118 PathDiagnostic::~PathDiagnostic() = default;
 119
 120 PathDiagnostic::PathDiagnostic(
 121     StringRef CheckerName, const Decl *declWithIssue, StringRef bugtype,
 122     StringRef verboseDesc, StringRef shortDesc, StringRef category,
 123     PathDiagnosticLocation LocationToUnique, const Decl *DeclToUnique,
 124     std::unique_ptr<FilesToLineNumsMap> ExecutedLines)
 125     : CheckerName(CheckerName), DeclWithIssue(declWithIssue),
 126       BugType(StripTrailingDots(bugtype)),
 127       VerboseDesc(StripTrailingDots(verboseDesc)),
 128       ShortDesc(StripTrailingDots(shortDesc)),
 129       Category(StripTrailingDots(category)), UniqueingLoc(LocationToUnique),
 130       UniqueingDecl(DeclToUnique), ExecutedLines(std::move(ExecutedLines)),
 131       path(pathImpl) {}
 132
 133 void PathDiagnosticConsumer::anchor() {}
 134
 135 PathDiagnosticConsumer::~PathDiagnosticConsumer() {
 136   // Delete the contents of the FoldingSet if it isn't empty already.
 137   for (auto &Diag : Diags)
 138     delete &Diag;
 139 }
 140
 141 void PathDiagnosticConsumer::HandlePathDiagnostic(
 142     std::unique_ptr<PathDiagnostic> D) {
 143   if (!D || D->path.empty())
 144     return;
 145
 146   // We need to flatten the locations (convert Stmt* to locations) because
 147   // the referenced statements may be freed by the time the diagnostics
 148   // are emitted.
 149   D->flattenLocations();
 150
 151   // If the PathDiagnosticConsumer does not support diagnostics that
 152   // cross file boundaries, prune out such diagnostics now.
 153   if (!supportsCrossFileDiagnostics()) {
 154     // Verify that the entire path is from the same FileID.
 155     FileID FID;
 156     const SourceManager &SMgr = D->path.front()->getLocation().getManager();
 157     SmallVector<const PathPieces *, 5> WorkList;
 158     WorkList.push_back(&D->path);
 159     SmallString<128> buf;
 160     llvm::raw_svector_ostream warning(buf);
 161     warning << "warning: Path diagnostic report is not generated. Current "
 162             << "output format does not support diagnostics that cross file "
 163             << "boundaries. Refer to --analyzer-output for valid output "
 164             << "formats\n";
 165
 166     while (!WorkList.empty()) {
 167       const PathPieces &path = *WorkList.pop_back_val();
 168
 169       for (const auto &I : path) {
 170         const PathDiagnosticPiece *piece = I.get();
 171         FullSourceLoc L = piece->getLocation().asLocation().getExpansionLoc();
 172
 173         if (FID.isInvalid()) {
 174           FID = SMgr.getFileID(L);
 175         } else if (SMgr.getFileID(L) != FID) {
 176           llvm::errs() << warning.str();
 177           return;
 178         }
 179
 180         // Check the source ranges.
 181         ArrayRef<SourceRange> Ranges = piece->getRanges();
 182         for (const auto &I : Ranges) {
 183           SourceLocation L = SMgr.getExpansionLoc(I.getBegin());
 184           if (!L.isFileID() || SMgr.getFileID(L) != FID) {
 185             llvm::errs() << warning.str();
 186             return;
 187           }
 188           L = SMgr.getExpansionLoc(I.getEnd());
 189           if (!L.isFileID() || SMgr.getFileID(L) != FID) {
 190             llvm::errs() << warning.str();
 191             return;
 192           }
 193         }
 194
 195         if (const auto *call = dyn_cast<PathDiagnosticCallPiece>(piece))
 196           WorkList.push_back(&call->path);
 197         else if (const auto *macro = dyn_cast<PathDiagnosticMacroPiece>(piece))
 198           WorkList.push_back(&macro->subPieces);
 199       }
 200     }
 201
 202     if (FID.isInvalid())
 203       return; // FIXME: Emit a warning?
 204   }
 205
 206   // Profile the node to see if we already have something matching it
 207   llvm::FoldingSetNodeID profile;
 208   D->Profile(profile);
 209   void *InsertPos = nullptr;
 210
 211   if (PathDiagnostic *orig = Diags.FindNodeOrInsertPos(profile, InsertPos)) {
 212     // Keep the PathDiagnostic with the shorter path.
 213     // Note, the enclosing routine is called in deterministic order, so the
 214     // results will be consistent between runs (no reason to break ties if the
 215     // size is the same).
 216     const unsigned orig_size = orig->full_size();
 217     const unsigned new_size = D->full_size();
 218     if (orig_size <= new_size)
 219       return;
 220
 221     assert(orig != D.get());
 222     Diags.RemoveNode(orig);
 223     delete orig;
 224   }
 225
 226   Diags.InsertNode(D.release());
 227 }
 228
 229 static Optional<bool> comparePath(const PathPieces &X, const PathPieces &Y);
 230
 231 static Optional<bool>
 232 compareControlFlow(const PathDiagnosticControlFlowPiece &X,
 233                    const PathDiagnosticControlFlowPiece &Y) {
 234   FullSourceLoc XSL = X.getStartLocation().asLocation();
 235   FullSourceLoc YSL = Y.getStartLocation().asLocation();
 236   if (XSL != YSL)
 237     return XSL.isBeforeInTranslationUnitThan(YSL);
 238   FullSourceLoc XEL = X.getEndLocation().asLocation();
 239   FullSourceLoc YEL = Y.getEndLocation().asLocation();
 240   if (XEL != YEL)
 241     return XEL.isBeforeInTranslationUnitThan(YEL);
 242   return None;
 243 }
 244
 245 static Optional<bool> compareMacro(const PathDiagnosticMacroPiece &X,
 246                                    const PathDiagnosticMacroPiece &Y) {
 247   return comparePath(X.subPieces, Y.subPieces);
 248 }
 249
 250 static Optional<bool> compareCall(const PathDiagnosticCallPiece &X,
 251                                   const PathDiagnosticCallPiece &Y) {
 252   FullSourceLoc X_CEL = X.callEnter.asLocation();
 253   FullSourceLoc Y_CEL = Y.callEnter.asLocation();
 254   if (X_CEL != Y_CEL)
 255     return X_CEL.isBeforeInTranslationUnitThan(Y_CEL);
 256   FullSourceLoc X_CEWL = X.callEnterWithin.asLocation();
 257   FullSourceLoc Y_CEWL = Y.callEnterWithin.asLocation();
 258   if (X_CEWL != Y_CEWL)
 259     return X_CEWL.isBeforeInTranslationUnitThan(Y_CEWL);
 260   FullSourceLoc X_CRL = X.callReturn.asLocation();
 261   FullSourceLoc Y_CRL = Y.callReturn.asLocation();
 262   if (X_CRL != Y_CRL)
 263     return X_CRL.isBeforeInTranslationUnitThan(Y_CRL);
 264   return comparePath(X.path, Y.path);
 265 }
 266
 267 static Optional<bool> comparePiece(const PathDiagnosticPiece &X,
 268                                    const PathDiagnosticPiece &Y) {
 269   if (X.getKind() != Y.getKind())
 270     return X.getKind() < Y.getKind();
 271
 272   FullSourceLoc XL = X.getLocation().asLocation();
 273   FullSourceLoc YL = Y.getLocation().asLocation();
 274   if (XL != YL)
 275     return XL.isBeforeInTranslationUnitThan(YL);
 276
 277   if (X.getString() != Y.getString())
 278     return X.getString() < Y.getString();
 279
 280   if (X.getRanges().size() != Y.getRanges().size())
 281     return X.getRanges().size() < Y.getRanges().size();
 282
 283   const SourceManager &SM = XL.getManager();
 284
 285   for (unsigned i = 0, n = X.getRanges().size(); i < n; ++i) {
 286     SourceRange XR = X.getRanges()[i];
 287     SourceRange YR = Y.getRanges()[i];
 288     if (XR != YR) {
 289       if (XR.getBegin() != YR.getBegin())
 290         return SM.isBeforeInTranslationUnit(XR.getBegin(), YR.getBegin());
 291       return SM.isBeforeInTranslationUnit(XR.getEnd(), YR.getEnd());
 292     }
 293   }
 294
 295   switch (X.getKind()) {
 296     case PathDiagnosticPiece::ControlFlow:
 297       return compareControlFlow(cast<PathDiagnosticControlFlowPiece>(X),
 298                                 cast<PathDiagnosticControlFlowPiece>(Y));
 299     case PathDiagnosticPiece::Macro:
 300       return compareMacro(cast<PathDiagnosticMacroPiece>(X),
 301                           cast<PathDiagnosticMacroPiece>(Y));
 302     case PathDiagnosticPiece::Call:
 303       return compareCall(cast<PathDiagnosticCallPiece>(X),
 304                          cast<PathDiagnosticCallPiece>(Y));
 305     case PathDiagnosticPiece::Event:
 306     case PathDiagnosticPiece::Note:
 307     case PathDiagnosticPiece::PopUp:
 308       return None;
 309   }
 310   llvm_unreachable("all cases handled");
 311 }
 312
 313 static Optional<bool> comparePath(const PathPieces &X, const PathPieces &Y) {
 314   if (X.size() != Y.size())
 315     return X.size() < Y.size();
 316
 317   PathPieces::const_iterator X_I = X.begin(), X_end = X.end();
 318   PathPieces::const_iterator Y_I = Y.begin(), Y_end = Y.end();
 319
 320   for ( ; X_I != X_end && Y_I != Y_end; ++X_I, ++Y_I) {
 321     Optional<bool> b = comparePiece(**X_I, **Y_I);
 322     if (b.hasValue())
 323       return b.getValue();
 324   }
 325
 326   return None;
 327 }
 328
 329 static bool compareCrossTUSourceLocs(FullSourceLoc XL, FullSourceLoc YL) {
 330   std::pair<FileID, unsigned> XOffs = XL.getDecomposedLoc();
 331   std::pair<FileID, unsigned> YOffs = YL.getDecomposedLoc();
 332   const SourceManager &SM = XL.getManager();
 333   std::pair<bool, bool> InSameTU = SM.isInTheSameTranslationUnit(XOffs, YOffs);
 334   if (InSameTU.first)
 335     return XL.isBeforeInTranslationUnitThan(YL);
 336   const FileEntry *XFE = SM.getFileEntryForID(XL.getSpellingLoc().getFileID());
 337   const FileEntry *YFE = SM.getFileEntryForID(YL.getSpellingLoc().getFileID());
 338   if (!XFE || !YFE)
 339     return XFE && !YFE;
 340   int NameCmp = XFE->getName().compare(YFE->getName());
 341   if (NameCmp != 0)
 342     return NameCmp == -1;
 343   // Last resort: Compare raw file IDs that are possibly expansions.
 344   return XL.getFileID() < YL.getFileID();
 345 }
 346
 347 static bool compare(const PathDiagnostic &X, const PathDiagnostic &Y) {
 348   FullSourceLoc XL = X.getLocation().asLocation();
 349   FullSourceLoc YL = Y.getLocation().asLocation();
 350   if (XL != YL)
 351     return compareCrossTUSourceLocs(XL, YL);
 352   if (X.getBugType() != Y.getBugType())
 353     return X.getBugType() < Y.getBugType();
 354   if (X.getCategory() != Y.getCategory())
 355     return X.getCategory() < Y.getCategory();
 356   if (X.getVerboseDescription() != Y.getVerboseDescription())
 357     return X.getVerboseDescription() < Y.getVerboseDescription();
 358   if (X.getShortDescription() != Y.getShortDescription())
 359     return X.getShortDescription() < Y.getShortDescription();
 360   if (X.getDeclWithIssue() != Y.getDeclWithIssue()) {
 361     const Decl *XD = X.getDeclWithIssue();
 362     if (!XD)
 363       return true;
 364     const Decl *YD = Y.getDeclWithIssue();
 365     if (!YD)
 366       return false;
 367     SourceLocation XDL = XD->getLocation();
 368     SourceLocation YDL = YD->getLocation();
 369     if (XDL != YDL) {
 370       const SourceManager &SM = XL.getManager();
 371       return compareCrossTUSourceLocs(FullSourceLoc(XDL, SM),
 372                                       FullSourceLoc(YDL, SM));
 373     }
 374   }
 375   PathDiagnostic::meta_iterator XI = X.meta_begin(), XE = X.meta_end();
 376   PathDiagnostic::meta_iterator YI = Y.meta_begin(), YE = Y.meta_end();
 377   if (XE - XI != YE - YI)
 378     return (XE - XI) < (YE - YI);
 379   for ( ; XI != XE ; ++XI, ++YI) {
 380     if (*XI != *YI)
 381       return (*XI) < (*YI);
 382   }
 383   Optional<bool> b = comparePath(X.path, Y.path);
 384   assert(b.hasValue());
 385   return b.getValue();
 386 }
 387
 388 void PathDiagnosticConsumer::FlushDiagnostics(
 389                                      PathDiagnosticConsumer::FilesMade *Files) {
 390   if (flushed)
 391     return;
 392
 393   flushed = true;
 394
 395   std::vector<const PathDiagnostic *> BatchDiags;
 396   for (const auto &D : Diags)
 397     BatchDiags.push_back(&D);
 398
 399   // Sort the diagnostics so that they are always emitted in a deterministic
 400   // order.
 401   int (*Comp)(const PathDiagnostic *const *, const PathDiagnostic *const *) =
 402       [](const PathDiagnostic *const *X, const PathDiagnostic *const *Y) {
 403         assert(*X != *Y && "PathDiagnostics not uniqued!");
 404         if (compare(**X, **Y))
 405           return -1;
 406         assert(compare(**Y, **X) && "Not a total order!");
 407         return 1;
 408       };
 409   array_pod_sort(BatchDiags.begin(), BatchDiags.end(), Comp);
 410
 411   FlushDiagnosticsImpl(BatchDiags, Files);
 412
 413   // Delete the flushed diagnostics.
 414   for (const auto D : BatchDiags)
 415     delete D;
 416
 417   // Clear out the FoldingSet.
 418   Diags.clear();
 419 }
 420
 421 PathDiagnosticConsumer::FilesMade::~FilesMade() {
 422   for (PDFileEntry &Entry : Set)
 423     Entry.~PDFileEntry();
 424 }
 425
 426 void PathDiagnosticConsumer::FilesMade::addDiagnostic(const PathDiagnostic &PD,
 427                                                       StringRef ConsumerName,
 428                                                       StringRef FileName) {
 429   llvm::FoldingSetNodeID NodeID;
 430   NodeID.Add(PD);
 431   void *InsertPos;
 432   PDFileEntry *Entry = Set.FindNodeOrInsertPos(NodeID, InsertPos);
 433   if (!Entry) {
 434     Entry = Alloc.Allocate<PDFileEntry>();
 435     Entry = new (Entry) PDFileEntry(NodeID);
 436     Set.InsertNode(Entry, InsertPos);
 437   }
 438
 439   // Allocate persistent storage for the file name.
 440   char *FileName_cstr = (char*) Alloc.Allocate(FileName.size(), 1);
 441   memcpy(FileName_cstr, FileName.data(), FileName.size());
 442
 443   Entry->files.push_back(std::make_pair(ConsumerName,
 444                                         StringRef(FileName_cstr,
 445                                                   FileName.size())));
 446 }
 447
 448 PathDiagnosticConsumer::PDFileEntry::ConsumerFiles *
 449 PathDiagnosticConsumer::FilesMade::getFiles(const PathDiagnostic &PD) {
 450   llvm::FoldingSetNodeID NodeID;
 451   NodeID.Add(PD);
 452   void *InsertPos;
 453   PDFileEntry *Entry = Set.FindNodeOrInsertPos(NodeID, InsertPos);
 454   if (!Entry)
 455     return nullptr;
 456   return &Entry->files;
 457 }
 458
 459 //===----------------------------------------------------------------------===//
 460 // PathDiagnosticLocation methods.
 461 //===----------------------------------------------------------------------===//
 462
 463 SourceLocation PathDiagnosticLocation::getValidSourceLocation(
 464     const Stmt *S, LocationOrAnalysisDeclContext LAC, bool UseEndOfStatement) {
 465   SourceLocation L = UseEndOfStatement ? S->getEndLoc() : S->getBeginLoc();
 466   assert(!LAC.isNull() &&
 467          "A valid LocationContext or AnalysisDeclContext should be passed to "
 468          "PathDiagnosticLocation upon creation.");
 469
 470   // S might be a temporary statement that does not have a location in the
 471   // source code, so find an enclosing statement and use its location.
 472   if (!L.isValid()) {
 473     AnalysisDeclContext *ADC;
 474     if (LAC.is<const LocationContext*>())
 475       ADC = LAC.get<const LocationContext*>()->getAnalysisDeclContext();
 476     else
 477       ADC = LAC.get<AnalysisDeclContext*>();
 478
 479     ParentMap &PM = ADC->getParentMap();
 480
 481     const Stmt *Parent = S;
 482     do {
 483       Parent = PM.getParent(Parent);
 484
 485       // In rare cases, we have implicit top-level expressions,
 486       // such as arguments for implicit member initializers.
 487       // In this case, fall back to the start of the body (even if we were
 488       // asked for the statement end location).
 489       if (!Parent) {
 490         const Stmt *Body = ADC->getBody();
 491         if (Body)
 492           L = Body->getBeginLoc();
 493         else
 494           L = ADC->getDecl()->getEndLoc();
 495         break;
 496       }
 497
 498       L = UseEndOfStatement ? Parent->getEndLoc() : Parent->getBeginLoc();
 499     } while (!L.isValid());
 500   }
 501
 502   // FIXME: Ironically, this assert actually fails in some cases.
 503   //assert(L.isValid());
 504   return L;
 505 }
 506
 507 static PathDiagnosticLocation
 508 getLocationForCaller(const StackFrameContext *SFC,
 509                      const LocationContext *CallerCtx,
 510                      const SourceManager &SM) {
 511   const CFGBlock &Block = *SFC->getCallSiteBlock();
 512   CFGElement Source = Block[SFC->getIndex()];
 513
 514   switch (Source.getKind()) {
 515   case CFGElement::Statement:
 516   case CFGElement::Constructor:
 517   case CFGElement::CXXRecordTypedCall:
 518     return PathDiagnosticLocation(Source.castAs<CFGStmt>().getStmt(),
 519                                   SM, CallerCtx);
 520   case CFGElement::Initializer: {
 521     const CFGInitializer &Init = Source.castAs<CFGInitializer>();
 522     return PathDiagnosticLocation(Init.getInitializer()->getInit(),
 523                                   SM, CallerCtx);
 524   }
 525   case CFGElement::AutomaticObjectDtor: {
 526     const CFGAutomaticObjDtor &Dtor = Source.castAs<CFGAutomaticObjDtor>();
 527     return PathDiagnosticLocation::createEnd(Dtor.getTriggerStmt(),
 528                                              SM, CallerCtx);
 529   }
 530   case CFGElement::DeleteDtor: {
 531     const CFGDeleteDtor &Dtor = Source.castAs<CFGDeleteDtor>();
 532     return PathDiagnosticLocation(Dtor.getDeleteExpr(), SM, CallerCtx);
 533   }
 534   case CFGElement::BaseDtor:
 535   case CFGElement::MemberDtor: {
 536     const AnalysisDeclContext *CallerInfo = CallerCtx->getAnalysisDeclContext();
 537     if (const Stmt *CallerBody = CallerInfo->getBody())
 538       return PathDiagnosticLocation::createEnd(CallerBody, SM, CallerCtx);
 539     return PathDiagnosticLocation::create(CallerInfo->getDecl(), SM);
 540   }
 541   case CFGElement::NewAllocator: {
 542     const CFGNewAllocator &Alloc = Source.castAs<CFGNewAllocator>();
 543     return PathDiagnosticLocation(Alloc.getAllocatorExpr(), SM, CallerCtx);
 544   }
 545   case CFGElement::TemporaryDtor: {
 546     // Temporary destructors are for temporaries. They die immediately at around
 547     // the location of CXXBindTemporaryExpr. If they are lifetime-extended,
 548     // they'd be dealt with via an AutomaticObjectDtor instead.
 549     const auto &Dtor = Source.castAs<CFGTemporaryDtor>();
 550     return PathDiagnosticLocation::createEnd(Dtor.getBindTemporaryExpr(), SM,
 551                                              CallerCtx);
 552   }
 553   case CFGElement::ScopeBegin:
 554   case CFGElement::ScopeEnd:
 555     llvm_unreachable("not yet implemented!");
 556   case CFGElement::LifetimeEnds:
 557   case CFGElement::LoopExit:
 558     llvm_unreachable("CFGElement kind should not be on callsite!");
 559   }
 560
 561   llvm_unreachable("Unknown CFGElement kind");
 562 }
 563
 564 PathDiagnosticLocation
 565 PathDiagnosticLocation::createBegin(const Decl *D,
 566                                     const SourceManager &SM) {
 567   return PathDiagnosticLocation(D->getBeginLoc(), SM, SingleLocK);
 568 }
 569
 570 PathDiagnosticLocation
 571 PathDiagnosticLocation::createBegin(const Stmt *S,
 572                                     const SourceManager &SM,
 573                                     LocationOrAnalysisDeclContext LAC) {
 574   return PathDiagnosticLocation(getValidSourceLocation(S, LAC),
 575                                 SM, SingleLocK);
 576 }
 577
 578 PathDiagnosticLocation
 579 PathDiagnosticLocation::createEnd(const Stmt *S,
 580                                   const SourceManager &SM,
 581                                   LocationOrAnalysisDeclContext LAC) {
 582   if (const auto *CS = dyn_cast<CompoundStmt>(S))
 583     return createEndBrace(CS, SM);
 584   return PathDiagnosticLocation(getValidSourceLocation(S, LAC, /*End=*/true),
 585                                 SM, SingleLocK);
 586 }
 587
 588 PathDiagnosticLocation
 589 PathDiagnosticLocation::createOperatorLoc(const BinaryOperator *BO,
 590                                           const SourceManager &SM) {
 591   return PathDiagnosticLocation(BO->getOperatorLoc(), SM, SingleLocK);
 592 }
 593
 594 PathDiagnosticLocation
 595 PathDiagnosticLocation::createConditionalColonLoc(
 596                                             const ConditionalOperator *CO,
 597                                             const SourceManager &SM) {
 598   return PathDiagnosticLocation(CO->getColonLoc(), SM, SingleLocK);
 599 }
 600
 601 PathDiagnosticLocation
 602 PathDiagnosticLocation::createMemberLoc(const MemberExpr *ME,
 603                                         const SourceManager &SM) {
 604
 605   assert(ME->getMemberLoc().isValid() || ME->getBeginLoc().isValid());
 606
 607   // In some cases, getMemberLoc isn't valid -- in this case we'll return with
 608   // some other related valid SourceLocation.
 609   if (ME->getMemberLoc().isValid())
 610     return PathDiagnosticLocation(ME->getMemberLoc(), SM, SingleLocK);
 611
 612   return PathDiagnosticLocation(ME->getBeginLoc(), SM, SingleLocK);
 613 }
 614
 615 PathDiagnosticLocation
 616 PathDiagnosticLocation::createBeginBrace(const CompoundStmt *CS,
 617                                          const SourceManager &SM) {
 618   SourceLocation L = CS->getLBracLoc();
 619   return PathDiagnosticLocation(L, SM, SingleLocK);
 620 }
 621
 622 PathDiagnosticLocation
 623 PathDiagnosticLocation::createEndBrace(const CompoundStmt *CS,
 624                                        const SourceManager &SM) {
 625   SourceLocation L = CS->getRBracLoc();
 626   return PathDiagnosticLocation(L, SM, SingleLocK);
 627 }
 628
 629 PathDiagnosticLocation
 630 PathDiagnosticLocation::createDeclBegin(const LocationContext *LC,
 631                                         const SourceManager &SM) {
 632   // FIXME: Should handle CXXTryStmt if analyser starts supporting C++.
 633   if (const auto *CS = dyn_cast_or_null<CompoundStmt>(LC->getDecl()->getBody()))
 634     if (!CS->body_empty()) {
 635       SourceLocation Loc = (*CS->body_begin())->getBeginLoc();
 636       return PathDiagnosticLocation(Loc, SM, SingleLocK);
 637     }
 638
 639   return PathDiagnosticLocation();
 640 }
 641
 642 PathDiagnosticLocation
 643 PathDiagnosticLocation::createDeclEnd(const LocationContext *LC,
 644                                       const SourceManager &SM) {
 645   SourceLocation L = LC->getDecl()->getBodyRBrace();
 646   return PathDiagnosticLocation(L, SM, SingleLocK);
 647 }
 648
 649 PathDiagnosticLocation
 650 PathDiagnosticLocation::create(const ProgramPoint& P,
 651                                const SourceManager &SMng) {
 652   const Stmt* S = nullptr;
 653   if (Optional<BlockEdge> BE = P.getAs<BlockEdge>()) {
 654     const CFGBlock *BSrc = BE->getSrc();
 655     if (BSrc->getTerminator().isVirtualBaseBranch()) {
 656       // TODO: VirtualBaseBranches should also appear for destructors.
 657       // In this case we should put the diagnostic at the end of decl.
 658       return PathDiagnosticLocation::createBegin(
 659           P.getLocationContext()->getDecl(), SMng);
 660
 661     } else {
 662       S = BSrc->getTerminatorCondition();
 663       if (!S) {
 664         // If the BlockEdge has no terminator condition statement but its
 665         // source is the entry of the CFG (e.g. a checker crated the branch at
 666         // the beginning of a function), use the function's declaration instead.
 667         assert(BSrc == &BSrc->getParent()->getEntry() && "CFGBlock has no "
 668                "TerminatorCondition and is not the enrty block of the CFG");
 669         return PathDiagnosticLocation::createBegin(
 670             P.getLocationContext()->getDecl(), SMng);
 671       }
 672     }
 673   } else if (Optional<StmtPoint> SP = P.getAs<StmtPoint>()) {
 674     S = SP->getStmt();
 675     if (P.getAs<PostStmtPurgeDeadSymbols>())
 676       return PathDiagnosticLocation::createEnd(S, SMng, P.getLocationContext());
 677   } else if (Optional<PostInitializer> PIP = P.getAs<PostInitializer>()) {
 678     return PathDiagnosticLocation(PIP->getInitializer()->getSourceLocation(),
 679                                   SMng);
 680   } else if (Optional<PreImplicitCall> PIC = P.getAs<PreImplicitCall>()) {
 681     return PathDiagnosticLocation(PIC->getLocation(), SMng);
 682   } else if (Optional<PostImplicitCall> PIE = P.getAs<PostImplicitCall>()) {
 683     return PathDiagnosticLocation(PIE->getLocation(), SMng);
 684   } else if (Optional<CallEnter> CE = P.getAs<CallEnter>()) {
 685     return getLocationForCaller(CE->getCalleeContext(),
 686                                 CE->getLocationContext(),
 687                                 SMng);
 688   } else if (Optional<CallExitEnd> CEE = P.getAs<CallExitEnd>()) {
 689     return getLocationForCaller(CEE->getCalleeContext(),
 690                                 CEE->getLocationContext(),
 691                                 SMng);
 692   } else if (auto CEB = P.getAs<CallExitBegin>()) {
 693     if (const ReturnStmt *RS = CEB->getReturnStmt())
 694       return PathDiagnosticLocation::createBegin(RS, SMng,
 695                                                  CEB->getLocationContext());
 696     return PathDiagnosticLocation(
 697         CEB->getLocationContext()->getDecl()->getSourceRange().getEnd(), SMng);
 698   } else if (Optional<BlockEntrance> BE = P.getAs<BlockEntrance>()) {
 699     if (Optional<CFGElement> BlockFront = BE->getFirstElement()) {
 700       if (auto StmtElt = BlockFront->getAs<CFGStmt>()) {
 701         return PathDiagnosticLocation(StmtElt->getStmt()->getBeginLoc(), SMng);
 702       } else if (auto NewAllocElt = BlockFront->getAs<CFGNewAllocator>()) {
 703         return PathDiagnosticLocation(
 704             NewAllocElt->getAllocatorExpr()->getBeginLoc(), SMng);
 705       }
 706       llvm_unreachable("Unexpected CFG element at front of block");
 707     }
 708
 709     return PathDiagnosticLocation(
 710         BE->getBlock()->getTerminatorStmt()->getBeginLoc(), SMng);
 711   } else if (Optional<FunctionExitPoint> FE = P.getAs<FunctionExitPoint>()) {
 712     return PathDiagnosticLocation(FE->getStmt(), SMng,
 713                                   FE->getLocationContext());
 714   } else {
 715     llvm_unreachable("Unexpected ProgramPoint");
 716   }
 717
 718   return PathDiagnosticLocation(S, SMng, P.getLocationContext());
 719 }
 720
 721 PathDiagnosticLocation PathDiagnosticLocation::createSingleLocation(
 722                                            const PathDiagnosticLocation &PDL) {
 723   FullSourceLoc L = PDL.asLocation();
 724   return PathDiagnosticLocation(L, L.getManager(), SingleLocK);
 725 }
 726
 727 FullSourceLoc
 728   PathDiagnosticLocation::genLocation(SourceLocation L,
 729                                       LocationOrAnalysisDeclContext LAC) const {
 730   assert(isValid());
 731   // Note that we want a 'switch' here so that the compiler can warn us in
 732   // case we add more cases.
 733   switch (K) {
 734     case SingleLocK:
 735     case RangeK:
 736       break;
 737     case StmtK:
 738       // Defensive checking.
 739       if (!S)
 740         break;
 741       return FullSourceLoc(getValidSourceLocation(S, LAC),
 742                            const_cast<SourceManager&>(*SM));
 743     case DeclK:
 744       // Defensive checking.
 745       if (!D)
 746         break;
 747       return FullSourceLoc(D->getLocation(), const_cast<SourceManager&>(*SM));
 748   }
 749
 750   return FullSourceLoc(L, const_cast<SourceManager&>(*SM));
 751 }
 752
 753 PathDiagnosticRange
 754   PathDiagnosticLocation::genRange(LocationOrAnalysisDeclContext LAC) const {
 755   assert(isValid());
 756   // Note that we want a 'switch' here so that the compiler can warn us in
 757   // case we add more cases.
 758   switch (K) {
 759     case SingleLocK:
 760       return PathDiagnosticRange(SourceRange(Loc,Loc), true);
 761     case RangeK:
 762       break;
 763     case StmtK: {
 764       const Stmt *S = asStmt();
 765       switch (S->getStmtClass()) {
 766         default:
 767           break;
 768         case Stmt::DeclStmtClass: {
 769           const auto *DS = cast<DeclStmt>(S);
 770           if (DS->isSingleDecl()) {
 771             // Should always be the case, but we'll be defensive.
 772             return SourceRange(DS->getBeginLoc(),
 773                                DS->getSingleDecl()->getLocation());
 774           }
 775           break;
 776         }
 777           // FIXME: Provide better range information for different
 778           //  terminators.
 779         case Stmt::IfStmtClass:
 780         case Stmt::WhileStmtClass:
 781         case Stmt::DoStmtClass:
 782         case Stmt::ForStmtClass:
 783         case Stmt::ChooseExprClass:
 784         case Stmt::IndirectGotoStmtClass:
 785         case Stmt::SwitchStmtClass:
 786         case Stmt::BinaryConditionalOperatorClass:
 787         case Stmt::ConditionalOperatorClass:
 788         case Stmt::ObjCForCollectionStmtClass: {
 789           SourceLocation L = getValidSourceLocation(S, LAC);
 790           return SourceRange(L, L);
 791         }
 792       }
 793       SourceRange R = S->getSourceRange();
 794       if (R.isValid())
 795         return R;
 796       break;
 797     }
 798     case DeclK:
 799       if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
 800         return MD->getSourceRange();
 801       if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
 802         if (Stmt *Body = FD->getBody())
 803           return Body->getSourceRange();
 804       }
 805       else {
 806         SourceLocation L = D->getLocation();
 807         return PathDiagnosticRange(SourceRange(L, L), true);
 808       }
 809   }
 810
 811   return SourceRange(Loc, Loc);
 812 }
 813
 814 void PathDiagnosticLocation::flatten() {
 815   if (K == StmtK) {
 816     K = RangeK;
 817     S = nullptr;
 818     D = nullptr;
 819   }
 820   else if (K == DeclK) {
 821     K = SingleLocK;
 822     S = nullptr;
 823     D = nullptr;
 824   }
 825 }
 826
 827 //===----------------------------------------------------------------------===//
 828 // Manipulation of PathDiagnosticCallPieces.
 829 //===----------------------------------------------------------------------===//
 830
 831 std::shared_ptr<PathDiagnosticCallPiece>
 832 PathDiagnosticCallPiece::construct(const CallExitEnd &CE,
 833                                    const SourceManager &SM) {
 834   const Decl *caller = CE.getLocationContext()->getDecl();
 835   PathDiagnosticLocation pos = getLocationForCaller(CE.getCalleeContext(),
 836                                                     CE.getLocationContext(),
 837                                                     SM);
 838   return std::shared_ptr<PathDiagnosticCallPiece>(
 839       new PathDiagnosticCallPiece(caller, pos));
 840 }
 841
 842 PathDiagnosticCallPiece *
 843 PathDiagnosticCallPiece::construct(PathPieces &path,
 844                                    const Decl *caller) {
 845   std::shared_ptr<PathDiagnosticCallPiece> C(
 846       new PathDiagnosticCallPiece(path, caller));
 847   path.clear();
 848   auto *R = C.get();
 849   path.push_front(std::move(C));
 850   return R;
 851 }
 852
 853 void PathDiagnosticCallPiece::setCallee(const CallEnter &CE,
 854                                         const SourceManager &SM) {
 855   const StackFrameContext *CalleeCtx = CE.getCalleeContext();
 856   Callee = CalleeCtx->getDecl();
 857
 858   callEnterWithin = PathDiagnosticLocation::createBegin(Callee, SM);
 859   callEnter = getLocationForCaller(CalleeCtx, CE.getLocationContext(), SM);
 860
 861   // Autosynthesized property accessors are special because we'd never
 862   // pop back up to non-autosynthesized code until we leave them.
 863   // This is not generally true for autosynthesized callees, which may call
 864   // non-autosynthesized callbacks.
 865   // Unless set here, the IsCalleeAnAutosynthesizedPropertyAccessor flag
 866   // defaults to false.
 867   if (const auto *MD = dyn_cast<ObjCMethodDecl>(Callee))
 868     IsCalleeAnAutosynthesizedPropertyAccessor = (
 869         MD->isPropertyAccessor() &&
 870         CalleeCtx->getAnalysisDeclContext()->isBodyAutosynthesized());
 871 }
 872
 873 static void describeTemplateParameters(raw_ostream &Out,
 874                                        const ArrayRef<TemplateArgument> TAList,
 875                                        const LangOptions &LO,
 876                                        StringRef Prefix = StringRef(),
 877                                        StringRef Postfix = StringRef());
 878
 879 static void describeTemplateParameter(raw_ostream &Out,
 880                                       const TemplateArgument &TArg,
 881                                       const LangOptions &LO) {
 882
 883   if (TArg.getKind() == TemplateArgument::ArgKind::Pack) {
 884     describeTemplateParameters(Out, TArg.getPackAsArray(), LO);
 885   } else {
 886     TArg.print(PrintingPolicy(LO), Out);
 887   }
 888 }
 889
 890 static void describeTemplateParameters(raw_ostream &Out,
 891                                        const ArrayRef<TemplateArgument> TAList,
 892                                        const LangOptions &LO,
 893                                        StringRef Prefix, StringRef Postfix) {
 894   if (TAList.empty())
 895     return;
 896
 897   Out << Prefix;
 898   for (int I = 0, Last = TAList.size() - 1; I != Last; ++I) {
 899     describeTemplateParameter(Out, TAList[I], LO);
 900     Out << ", ";
 901   }
 902   describeTemplateParameter(Out, TAList[TAList.size() - 1], LO);
 903   Out << Postfix;
 904 }
 905
 906 static void describeClass(raw_ostream &Out, const CXXRecordDecl *D,
 907                           StringRef Prefix = StringRef()) {
 908   if (!D->getIdentifier())
 909     return;
 910   Out << Prefix << '\'' << *D;
 911   if (const auto T = dyn_cast<ClassTemplateSpecializationDecl>(D))
 912     describeTemplateParameters(Out, T->getTemplateArgs().asArray(),
 913                                D->getLangOpts(), "<", ">");
 914
 915   Out << '\'';
 916 }
 917
 918 static bool describeCodeDecl(raw_ostream &Out, const Decl *D,
 919                              bool ExtendedDescription,
 920                              StringRef Prefix = StringRef()) {
 921   if (!D)
 922     return false;
 923
 924   if (isa<BlockDecl>(D)) {
 925     if (ExtendedDescription)
 926       Out << Prefix << "anonymous block";
 927     return ExtendedDescription;
 928   }
 929
 930   if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
 931     Out << Prefix;
 932     if (ExtendedDescription && !MD->isUserProvided()) {
 933       if (MD->isExplicitlyDefaulted())
 934         Out << "defaulted ";
 935       else
 936         Out << "implicit ";
 937     }
 938
 939     if (const auto *CD = dyn_cast<CXXConstructorDecl>(MD)) {
 940       if (CD->isDefaultConstructor())
 941         Out << "default ";
 942       else if (CD->isCopyConstructor())
 943         Out << "copy ";
 944       else if (CD->isMoveConstructor())
 945         Out << "move ";
 946
 947       Out << "constructor";
 948       describeClass(Out, MD->getParent(), " for ");
 949     } else if (isa<CXXDestructorDecl>(MD)) {
 950       if (!MD->isUserProvided()) {
 951         Out << "destructor";
 952         describeClass(Out, MD->getParent(), " for ");
 953       } else {
 954         // Use ~Foo for explicitly-written destructors.
 955         Out << "'" << *MD << "'";
 956       }
 957     } else if (MD->isCopyAssignmentOperator()) {
 958         Out << "copy assignment operator";
 959         describeClass(Out, MD->getParent(), " for ");
 960     } else if (MD->isMoveAssignmentOperator()) {
 961         Out << "move assignment operator";
 962         describeClass(Out, MD->getParent(), " for ");
 963     } else {
 964       if (MD->getParent()->getIdentifier())
 965         Out << "'" << *MD->getParent() << "::" << *MD << "'";
 966       else
 967         Out << "'" << *MD << "'";
 968     }
 969
 970     return true;
 971   }
 972
 973   Out << Prefix << '\'' << cast<NamedDecl>(*D);
 974
 975   // Adding template parameters.
 976   if (const auto FD = dyn_cast<FunctionDecl>(D))
 977     if (const TemplateArgumentList *TAList =
 978                                     FD->getTemplateSpecializationArgs())
 979       describeTemplateParameters(Out, TAList->asArray(), FD->getLangOpts(), "<",
 980                                  ">");
 981
 982   Out << '\'';
 983   return true;
 984 }
 985
 986 std::shared_ptr<PathDiagnosticEventPiece>
 987 PathDiagnosticCallPiece::getCallEnterEvent() const {
 988   // We do not produce call enters and call exits for autosynthesized property
 989   // accessors. We do generally produce them for other functions coming from
 990   // the body farm because they may call callbacks that bring us back into
 991   // visible code.
 992   if (!Callee || IsCalleeAnAutosynthesizedPropertyAccessor)
 993     return nullptr;
 994
 995   SmallString<256> buf;
 996   llvm::raw_svector_ostream Out(buf);
 997
 998   Out << "Calling ";
 999   describeCodeDecl(Out, Callee, /*ExtendedDescription=*/true);
1000
1001   assert(callEnter.asLocation().isValid());
1002   return std::make_shared<PathDiagnosticEventPiece>(callEnter, Out.str());
1003 }
1004
1005 std::shared_ptr<PathDiagnosticEventPiece>
1006 PathDiagnosticCallPiece::getCallEnterWithinCallerEvent() const {
1007   if (!callEnterWithin.asLocation().isValid())
1008     return nullptr;
1009   if (Callee->isImplicit() || !Callee->hasBody())
1010     return nullptr;
1011   if (const auto *MD = dyn_cast<CXXMethodDecl>(Callee))
1012     if (MD->isDefaulted())
1013       return nullptr;
1014
1015   SmallString<256> buf;
1016   llvm::raw_svector_ostream Out(buf);
1017
1018   Out << "Entered call";
1019   describeCodeDecl(Out, Caller, /*ExtendedDescription=*/false, " from ");
1020
1021   return std::make_shared<PathDiagnosticEventPiece>(callEnterWithin, Out.str());
1022 }
1023
1024 std::shared_ptr<PathDiagnosticEventPiece>
1025 PathDiagnosticCallPiece::getCallExitEvent() const {
1026   // We do not produce call enters and call exits for autosynthesized property
1027   // accessors. We do generally produce them for other functions coming from
1028   // the body farm because they may call callbacks that bring us back into
1029   // visible code.
1030   if (NoExit || IsCalleeAnAutosynthesizedPropertyAccessor)
1031     return nullptr;
1032
1033   SmallString<256> buf;
1034   llvm::raw_svector_ostream Out(buf);
1035
1036   if (!CallStackMessage.empty()) {
1037     Out << CallStackMessage;
1038   } else {
1039     bool DidDescribe = describeCodeDecl(Out, Callee,
1040                                         /*ExtendedDescription=*/false,
1041                                         "Returning from ");
1042     if (!DidDescribe)
1043       Out << "Returning to caller";
1044   }
1045
1046   assert(callReturn.asLocation().isValid());
1047   return std::make_shared<PathDiagnosticEventPiece>(callReturn, Out.str());
1048 }
1049
1050 static void compute_path_size(const PathPieces &pieces, unsigned &size) {
1051   for (const auto &I : pieces) {
1052     const PathDiagnosticPiece *piece = I.get();
1053     if (const auto *cp = dyn_cast<PathDiagnosticCallPiece>(piece))
1054       compute_path_size(cp->path, size);
1055     else
1056       ++size;
1057   }
1058 }
1059
1060 unsigned PathDiagnostic::full_size() {
1061   unsigned size = 0;
1062   compute_path_size(path, size);
1063   return size;
1064 }
1065
1066 //===----------------------------------------------------------------------===//
1067 // FoldingSet profiling methods.
1068 //===----------------------------------------------------------------------===//
1069
1070 void PathDiagnosticLocation::Profile(llvm::FoldingSetNodeID &ID) const {
1071   ID.AddInteger(Range.getBegin().getRawEncoding());
1072   ID.AddInteger(Range.getEnd().getRawEncoding());
1073   ID.AddInteger(Loc.getRawEncoding());
1074 }
1075
1076 void PathDiagnosticPiece::Profile(llvm::FoldingSetNodeID &ID) const {
1077   ID.AddInteger((unsigned) getKind());
1078   ID.AddString(str);
1079   // FIXME: Add profiling support for code hints.
1080   ID.AddInteger((unsigned) getDisplayHint());
1081   ArrayRef<SourceRange> Ranges = getRanges();
1082   for (const auto &I : Ranges) {
1083     ID.AddInteger(I.getBegin().getRawEncoding());
1084     ID.AddInteger(I.getEnd().getRawEncoding());
1085   }
1086 }
1087
1088 void PathDiagnosticCallPiece::Profile(llvm::FoldingSetNodeID &ID) const {
1089   PathDiagnosticPiece::Profile(ID);
1090   for (const auto &I : path)
1091     ID.Add(*I);
1092 }
1093
1094 void PathDiagnosticSpotPiece::Profile(llvm::FoldingSetNodeID &ID) const {
1095   PathDiagnosticPiece::Profile(ID);
1096   ID.Add(Pos);
1097 }
1098
1099 void PathDiagnosticControlFlowPiece::Profile(llvm::FoldingSetNodeID &ID) const {
1100   PathDiagnosticPiece::Profile(ID);
1101   for (const auto &I : *this)
1102     ID.Add(I);
1103 }
1104
1105 void PathDiagnosticMacroPiece::Profile(llvm::FoldingSetNodeID &ID) const {
1106   PathDiagnosticSpotPiece::Profile(ID);
1107   for (const auto &I : subPieces)
1108     ID.Add(*I);
1109 }
1110
1111 void PathDiagnosticNotePiece::Profile(llvm::FoldingSetNodeID &ID) const {
1112   PathDiagnosticSpotPiece::Profile(ID);
1113 }
1114
1115 void PathDiagnosticPopUpPiece::Profile(llvm::FoldingSetNodeID &ID) const {
1116   PathDiagnosticSpotPiece::Profile(ID);
1117 }
1118
1119 void PathDiagnostic::Profile(llvm::FoldingSetNodeID &ID) const {
1120   ID.Add(getLocation());
1121   ID.AddString(BugType);
1122   ID.AddString(VerboseDesc);
1123   ID.AddString(Category);
1124 }
1125
1126 void PathDiagnostic::FullProfile(llvm::FoldingSetNodeID &ID) const {
1127   Profile(ID);
1128   for (const auto &I : path)
1129     ID.Add(*I);
1130   for (meta_iterator I = meta_begin(), E = meta_end(); I != E; ++I)
1131     ID.AddString(*I);
1132 }
1133
1134 LLVM_DUMP_METHOD void PathPieces::dump() const {
1135   unsigned index = 0;
1136   for (PathPieces::const_iterator I = begin(), E = end(); I != E; ++I) {
1137     llvm::errs() << "[" << index++ << "]  ";
1138     (*I)->dump();
1139     llvm::errs() << "\n";
1140   }
1141 }
1142
1143 LLVM_DUMP_METHOD void PathDiagnosticCallPiece::dump() const {
1144   llvm::errs() << "CALL\n--------------\n";
1145
1146   if (const Stmt *SLoc = getLocation().getStmtOrNull())
1147     SLoc->dump();
1148   else if (const auto *ND = dyn_cast_or_null<NamedDecl>(getCallee()))
1149     llvm::errs() << *ND << "\n";
1150   else
1151     getLocation().dump();
1152 }
1153
1154 LLVM_DUMP_METHOD void PathDiagnosticEventPiece::dump() const {
1155   llvm::errs() << "EVENT\n--------------\n";
1156   llvm::errs() << getString() << "\n";
1157   llvm::errs() << " ---- at ----\n";
1158   getLocation().dump();
1159 }
1160
1161 LLVM_DUMP_METHOD void PathDiagnosticControlFlowPiece::dump() const {
1162   llvm::errs() << "CONTROL\n--------------\n";
1163   getStartLocation().dump();
1164   llvm::errs() << " ---- to ----\n";
1165   getEndLocation().dump();
1166 }
1167
1168 LLVM_DUMP_METHOD void PathDiagnosticMacroPiece::dump() const {
1169   llvm::errs() << "MACRO\n--------------\n";
1170   // FIXME: Print which macro is being invoked.
1171 }
1172
1173 LLVM_DUMP_METHOD void PathDiagnosticNotePiece::dump() const {
1174   llvm::errs() << "NOTE\n--------------\n";
1175   llvm::errs() << getString() << "\n";
1176   llvm::errs() << " ---- at ----\n";
1177   getLocation().dump();
1178 }
1179
1180 LLVM_DUMP_METHOD void PathDiagnosticPopUpPiece::dump() const {
1181   llvm::errs() << "POP-UP\n--------------\n";
1182   llvm::errs() << getString() << "\n";
1183   llvm::errs() << " ---- at ----\n";
1184   getLocation().dump();
1185 }
1186
1187 LLVM_DUMP_METHOD void PathDiagnosticLocation::dump() const {
1188   if (!isValid()) {
1189     llvm::errs() << "<INVALID>\n";
1190     return;
1191   }
1192
1193   switch (K) {
1194   case RangeK:
1195     // FIXME: actually print the range.
1196     llvm::errs() << "<range>\n";
1197     break;
1198   case SingleLocK:
1199     asLocation().dump();
1200     llvm::errs() << "\n";
1201     break;
1202   case StmtK:
1203     if (S)
1204       S->dump();
1205     else
1206       llvm::errs() << "<NULL STMT>\n";
1207     break;
1208   case DeclK:
1209     if (const auto *ND = dyn_cast_or_null<NamedDecl>(D))
1210       llvm::errs() << *ND << "\n";
1211     else if (isa<BlockDecl>(D))
1212       // FIXME: Make this nicer.
1213       llvm::errs() << "<block>\n";
1214     else if (D)
1215       llvm::errs() << "<unknown decl>\n";
1216     else
1217       llvm::errs() << "<NULL DECL>\n";
1218     break;
1219   }
1220 }