vendor/clang/clang-trunk-r375505vendor/clang

1 files changed, 0 insertions, 923 deletions

diff --git a/include/clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h b/include/clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h
deleted file mode 100644
index 5230742a4aa43..0000000000000
--- a/include/clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h
+++ /dev/null
@@ -1,923 +0,0 @@
-//===- PathDiagnostic.h - Path-Specific Diagnostic Handling -----*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-//  This file defines the PathDiagnostic-related interfaces.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_STATICANALYZER_CORE_BUGREPORTER_PATHDIAGNOSTIC_H
-#define LLVM_CLANG_STATICANALYZER_CORE_BUGREPORTER_PATHDIAGNOSTIC_H
-
-#include "clang/AST/Stmt.h"
-#include "clang/Analysis/AnalysisDeclContext.h"
-#include "clang/Basic/LLVM.h"
-#include "clang/Basic/SourceLocation.h"
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/FoldingSet.h"
-#include "llvm/ADT/Optional.h"
-#include "llvm/ADT/PointerUnion.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/Allocator.h"
-#include <cassert>
-#include <deque>
-#include <iterator>
-#include <list>
-#include <map>
-#include <memory>
-#include <set>
-#include <string>
-#include <utility>
-#include <vector>
-
-namespace clang {
-
-class AnalysisDeclContext;
-class BinaryOperator;
-class CallEnter;
-class CallExitEnd;
-class CallExpr;
-class ConditionalOperator;
-class Decl;
-class Expr;
-class LocationContext;
-class MemberExpr;
-class ProgramPoint;
-class SourceManager;
-
-namespace ento {
-
-class ExplodedNode;
-class SymExpr;
-
-using SymbolRef = const SymExpr *;
-
-//===----------------------------------------------------------------------===//
-// High-level interface for handlers of path-sensitive diagnostics.
-//===----------------------------------------------------------------------===//
-
-class PathDiagnostic;
-
-class PathDiagnosticConsumer {
-public:
-  class PDFileEntry : public llvm::FoldingSetNode {
-  public:
-    PDFileEntry(llvm::FoldingSetNodeID &NodeID) : NodeID(NodeID) {}
-
-    using ConsumerFiles = std::vector<std::pair<StringRef, StringRef>>;
-
-    /// A vector of <consumer,file> pairs.
-    ConsumerFiles files;
-
-    /// A precomputed hash tag used for uniquing PDFileEntry objects.
-    const llvm::FoldingSetNodeID NodeID;
-
-    /// Used for profiling in the FoldingSet.
-    void Profile(llvm::FoldingSetNodeID &ID) { ID = NodeID; }
-  };
-
-  class FilesMade {
-    llvm::BumpPtrAllocator Alloc;
-    llvm::FoldingSet<PDFileEntry> Set;
-
-  public:
-    ~FilesMade();
-
-    bool empty() const { return Set.empty(); }
-
-    void addDiagnostic(const PathDiagnostic &PD,
-                       StringRef ConsumerName,
-                       StringRef fileName);
-
-    PDFileEntry::ConsumerFiles *getFiles(const PathDiagnostic &PD);
-  };
-
-private:
-  virtual void anchor();
-
-public:
-  PathDiagnosticConsumer() = default;
-  virtual ~PathDiagnosticConsumer();
-
-  void FlushDiagnostics(FilesMade *FilesMade);
-
-  virtual void FlushDiagnosticsImpl(std::vector<const PathDiagnostic *> &Diags,
-                                    FilesMade *filesMade) = 0;
-
-  virtual StringRef getName() const = 0;
-
-  void HandlePathDiagnostic(std::unique_ptr<PathDiagnostic> D);
-
-  enum PathGenerationScheme {
-    /// Only runs visitors, no output generated.
-    None,
-
-    /// Used for HTML, SARIF, and text output.
-    Minimal,
-
-    /// Used for plist output, used for "arrows" generation.
-    Extensive,
-  };
-
-  virtual PathGenerationScheme getGenerationScheme() const { return Minimal; }
-  virtual bool supportsLogicalOpControlFlow() const { return false; }
-
-  /// Return true if the PathDiagnosticConsumer supports individual
-  /// PathDiagnostics that span multiple files.
-  virtual bool supportsCrossFileDiagnostics() const { return false; }
-
-protected:
-  bool flushed = false;
-  llvm::FoldingSet<PathDiagnostic> Diags;
-};
-
-//===----------------------------------------------------------------------===//
-// Path-sensitive diagnostics.
-//===----------------------------------------------------------------------===//
-
-class PathDiagnosticRange : public SourceRange {
-public:
-  bool isPoint = false;
-
-  PathDiagnosticRange(SourceRange R, bool isP = false)
-      : SourceRange(R), isPoint(isP) {}
-  PathDiagnosticRange() = default;
-};
-
-using LocationOrAnalysisDeclContext =
-    llvm::PointerUnion<const LocationContext *, AnalysisDeclContext *>;
-
-class PathDiagnosticLocation {
-private:
-  enum Kind { RangeK, SingleLocK, StmtK, DeclK } K = SingleLocK;
-
-  const Stmt *S = nullptr;
-  const Decl *D = nullptr;
-  const SourceManager *SM = nullptr;
-  FullSourceLoc Loc;
-  PathDiagnosticRange Range;
-
-  PathDiagnosticLocation(SourceLocation L, const SourceManager &sm, Kind kind)
-      : K(kind), SM(&sm), Loc(genLocation(L)), Range(genRange()) {}
-
-  FullSourceLoc genLocation(
-      SourceLocation L = SourceLocation(),
-      LocationOrAnalysisDeclContext LAC = (AnalysisDeclContext *)nullptr) const;
-
-  PathDiagnosticRange genRange(
-      LocationOrAnalysisDeclContext LAC = (AnalysisDeclContext *)nullptr) const;
-
-public:
-  /// Create an invalid location.
-  PathDiagnosticLocation() = default;
-
-  /// Create a location corresponding to the given statement.
-  PathDiagnosticLocation(const Stmt *s, const SourceManager &sm,
-                         LocationOrAnalysisDeclContext lac)
-      : K(s->getBeginLoc().isValid() ? StmtK : SingleLocK),
-        S(K == StmtK ? s : nullptr), SM(&sm),
-        Loc(genLocation(SourceLocation(), lac)), Range(genRange(lac)) {
-    assert(K == SingleLocK || S);
-    assert(K == SingleLocK || Loc.isValid());
-    assert(K == SingleLocK || Range.isValid());
-  }
-
-  /// Create a location corresponding to the given declaration.
-  PathDiagnosticLocation(const Decl *d, const SourceManager &sm)
-      : K(DeclK), D(d), SM(&sm), Loc(genLocation()), Range(genRange()) {
-    assert(D);
-    assert(Loc.isValid());
-    assert(Range.isValid());
-  }
-
-  /// Create a location at an explicit offset in the source.
-  ///
-  /// This should only be used if there are no more appropriate constructors.
-  PathDiagnosticLocation(SourceLocation loc, const SourceManager &sm)
-      : SM(&sm), Loc(loc, sm), Range(genRange()) {
-    assert(Loc.isValid());
-    assert(Range.isValid());
-  }
-
-  /// Create a location corresponding to the given declaration.
-  static PathDiagnosticLocation create(const Decl *D,
-                                       const SourceManager &SM) {
-    return PathDiagnosticLocation(D, SM);
-  }
-
-  /// Create a location for the beginning of the declaration.
-  static PathDiagnosticLocation createBegin(const Decl *D,
-                                            const SourceManager &SM);
-
-  /// Create a location for the beginning of the declaration.
-  /// The third argument is ignored, useful for generic treatment
-  /// of statements and declarations.
-  static PathDiagnosticLocation
-  createBegin(const Decl *D, const SourceManager &SM,
-              const LocationOrAnalysisDeclContext LAC) {
-    return createBegin(D, SM);
-  }
-
-  /// Create a location for the beginning of the statement.
-  static PathDiagnosticLocation createBegin(const Stmt *S,
-                                            const SourceManager &SM,
-                                            const LocationOrAnalysisDeclContext LAC);
-
-  /// Create a location for the end of the statement.
-  ///
-  /// If the statement is a CompoundStatement, the location will point to the
-  /// closing brace instead of following it.
-  static PathDiagnosticLocation createEnd(const Stmt *S,
-                                          const SourceManager &SM,
-                                       const LocationOrAnalysisDeclContext LAC);
-
-  /// Create the location for the operator of the binary expression.
-  /// Assumes the statement has a valid location.
-  static PathDiagnosticLocation createOperatorLoc(const BinaryOperator *BO,
-                                                  const SourceManager &SM);
-  static PathDiagnosticLocation createConditionalColonLoc(
-                                                  const ConditionalOperator *CO,
-                                                  const SourceManager &SM);
-
-  /// For member expressions, return the location of the '.' or '->'.
-  /// Assumes the statement has a valid location.
-  static PathDiagnosticLocation createMemberLoc(const MemberExpr *ME,
-                                                const SourceManager &SM);
-
-  /// Create a location for the beginning of the compound statement.
-  /// Assumes the statement has a valid location.
-  static PathDiagnosticLocation createBeginBrace(const CompoundStmt *CS,
-                                                 const SourceManager &SM);
-
-  /// Create a location for the end of the compound statement.
-  /// Assumes the statement has a valid location.
-  static PathDiagnosticLocation createEndBrace(const CompoundStmt *CS,
-                                               const SourceManager &SM);
-
-  /// Create a location for the beginning of the enclosing declaration body.
-  /// Defaults to the beginning of the first statement in the declaration body.
-  static PathDiagnosticLocation createDeclBegin(const LocationContext *LC,
-                                                const SourceManager &SM);
-
-  /// Constructs a location for the end of the enclosing declaration body.
-  /// Defaults to the end of brace.
-  static PathDiagnosticLocation createDeclEnd(const LocationContext *LC,
-                                                   const SourceManager &SM);
-
-  /// Create a location corresponding to the given valid ExplodedNode.
-  static PathDiagnosticLocation create(const ProgramPoint &P,
-                                       const SourceManager &SMng);
-
-  /// Create a location corresponding to the next valid ExplodedNode as end
-  /// of path location.
-  static PathDiagnosticLocation createEndOfPath(const ExplodedNode* N,
-                                                const SourceManager &SM);
-
-  /// Convert the given location into a single kind location.
-  static PathDiagnosticLocation createSingleLocation(
-                                             const PathDiagnosticLocation &PDL);
-
-  bool operator==(const PathDiagnosticLocation &X) const {
-    return K == X.K && Loc == X.Loc && Range == X.Range;
-  }
-
-  bool operator!=(const PathDiagnosticLocation &X) const {
-    return !(*this == X);
-  }
-
-  bool isValid() const {
-    return SM != nullptr;
-  }
-
-  FullSourceLoc asLocation() const {
-    return Loc;
-  }
-
-  PathDiagnosticRange asRange() const {
-    return Range;
-  }
-
-  const Stmt *asStmt() const { assert(isValid()); return S; }
-  const Stmt *getStmtOrNull() const {
-    if (!isValid())
-      return nullptr;
-    return asStmt();
-  }
-
-  const Decl *asDecl() const { assert(isValid()); return D; }
-
-  bool hasRange() const { return K == StmtK || K == RangeK || K == DeclK; }
-
-  bool hasValidLocation() const { return asLocation().isValid(); }
-
-  void invalidate() {
-    *this = PathDiagnosticLocation();
-  }
-
-  void flatten();
-
-  const SourceManager& getManager() const { assert(isValid()); return *SM; }
-
-  void Profile(llvm::FoldingSetNodeID &ID) const;
-
-  void dump() const;
-
-  /// Given an exploded node, retrieve the statement that should be used
-  /// for the diagnostic location.
-  static const Stmt *getStmt(const ExplodedNode *N);
-
-  /// Retrieve the statement corresponding to the successor node.
-  static const Stmt *getNextStmt(const ExplodedNode *N);
-};
-
-class PathDiagnosticLocationPair {
-private:
-  PathDiagnosticLocation Start, End;
-
-public:
-  PathDiagnosticLocationPair(const PathDiagnosticLocation &start,
-                             const PathDiagnosticLocation &end)
-      : Start(start), End(end) {}
-
-  const PathDiagnosticLocation &getStart() const { return Start; }
-  const PathDiagnosticLocation &getEnd() const { return End; }
-
-  void setStart(const PathDiagnosticLocation &L) { Start = L; }
-  void setEnd(const PathDiagnosticLocation &L) { End = L; }
-
-  void flatten() {
-    Start.flatten();
-    End.flatten();
-  }
-
-  void Profile(llvm::FoldingSetNodeID &ID) const {
-    Start.Profile(ID);
-    End.Profile(ID);
-  }
-};
-
-//===----------------------------------------------------------------------===//
-// Path "pieces" for path-sensitive diagnostics.
-//===----------------------------------------------------------------------===//
-
-class PathDiagnosticPiece: public llvm::FoldingSetNode {
-public:
-  enum Kind { ControlFlow, Event, Macro, Call, Note, PopUp };
-  enum DisplayHint { Above, Below };
-
-private:
-  const std::string str;
-  const Kind kind;
-  const DisplayHint Hint;
-
-  /// In the containing bug report, this piece is the last piece from
-  /// the main source file.
-  bool LastInMainSourceFile = false;
-
-  /// A constant string that can be used to tag the PathDiagnosticPiece,
-  /// typically with the identification of the creator.  The actual pointer
-  /// value is meant to be an identifier; the string itself is useful for
-  /// debugging.
-  StringRef Tag;
-
-  std::vector<SourceRange> ranges;
-
-protected:
-  PathDiagnosticPiece(StringRef s, Kind k, DisplayHint hint = Below);
-  PathDiagnosticPiece(Kind k, DisplayHint hint = Below);
-
-public:
-  PathDiagnosticPiece() = delete;
-  PathDiagnosticPiece(const PathDiagnosticPiece &) = delete;
-  PathDiagnosticPiece &operator=(const PathDiagnosticPiece &) = delete;
-  virtual ~PathDiagnosticPiece();
-
-  StringRef getString() const { return str; }
-
-  /// Tag this PathDiagnosticPiece with the given C-string.
-  void setTag(const char *tag) { Tag = tag; }
-
-  /// Return the opaque tag (if any) on the PathDiagnosticPiece.
-  const void *getTag() const { return Tag.data(); }
-
-  /// Return the string representation of the tag.  This is useful
-  /// for debugging.
-  StringRef getTagStr() const { return Tag; }
-
-  /// getDisplayHint - Return a hint indicating where the diagnostic should
-  ///  be displayed by the PathDiagnosticConsumer.
-  DisplayHint getDisplayHint() const { return Hint; }
-
-  virtual PathDiagnosticLocation getLocation() const = 0;
-  virtual void flattenLocations() = 0;
-
-  Kind getKind() const { return kind; }
-
-  void addRange(SourceRange R) {
-    if (!R.isValid())
-      return;
-    ranges.push_back(R);
-  }
-
-  void addRange(SourceLocation B, SourceLocation E) {
-    if (!B.isValid() || !E.isValid())
-      return;
-    ranges.push_back(SourceRange(B,E));
-  }
-
-  /// Return the SourceRanges associated with this PathDiagnosticPiece.
-  ArrayRef<SourceRange> getRanges() const { return ranges; }
-
-  virtual void Profile(llvm::FoldingSetNodeID &ID) const;
-
-  void setAsLastInMainSourceFile() {
-    LastInMainSourceFile = true;
-  }
-
-  bool isLastInMainSourceFile() const {
-    return LastInMainSourceFile;
-  }
-
-  virtual void dump() const = 0;
-};
-
-class PathPieces : public std::list<std::shared_ptr<PathDiagnosticPiece>> {
-  void flattenTo(PathPieces &Primary, PathPieces &Current,
-                 bool ShouldFlattenMacros) const;
-
-public:
-  PathPieces flatten(bool ShouldFlattenMacros) const {
-    PathPieces Result;
-    flattenTo(Result, Result, ShouldFlattenMacros);
-    return Result;
-  }
-
-  void dump() const;
-};
-
-class PathDiagnosticSpotPiece : public PathDiagnosticPiece {
-private:
-  PathDiagnosticLocation Pos;
-
-public:
-  PathDiagnosticSpotPiece(const PathDiagnosticLocation &pos,
-                          StringRef s,
-                          PathDiagnosticPiece::Kind k,
-                          bool addPosRange = true)
-      : PathDiagnosticPiece(s, k), Pos(pos) {
-    assert(Pos.isValid() && Pos.hasValidLocation() &&
-           "PathDiagnosticSpotPiece's must have a valid location.");
-    if (addPosRange && Pos.hasRange()) addRange(Pos.asRange());
-  }
-
-  PathDiagnosticLocation getLocation() const override { return Pos; }
-  void flattenLocations() override { Pos.flatten(); }
-
-  void Profile(llvm::FoldingSetNodeID &ID) const override;
-
-  static bool classof(const PathDiagnosticPiece *P) {
-    return P->getKind() == Event || P->getKind() == Macro ||
-           P->getKind() == Note || P->getKind() == PopUp;
-  }
-};
-
-/// Interface for classes constructing Stack hints.
-///
-/// If a PathDiagnosticEvent occurs in a different frame than the final
-/// diagnostic the hints can be used to summarize the effect of the call.
-class StackHintGenerator {
-public:
-  virtual ~StackHintGenerator() = 0;
-
-  /// Construct the Diagnostic message for the given ExplodedNode.
-  virtual std::string getMessage(const ExplodedNode *N) = 0;
-};
-
-/// Constructs a Stack hint for the given symbol.
-///
-/// The class knows how to construct the stack hint message based on
-/// traversing the CallExpr associated with the call and checking if the given
-/// symbol is returned or is one of the arguments.
-/// The hint can be customized by redefining 'getMessageForX()' methods.
-class StackHintGeneratorForSymbol : public StackHintGenerator {
-private:
-  SymbolRef Sym;
-  std::string Msg;
-
-public:
-  StackHintGeneratorForSymbol(SymbolRef S, StringRef M) : Sym(S), Msg(M) {}
-  ~StackHintGeneratorForSymbol() override = default;
-
-  /// Search the call expression for the symbol Sym and dispatch the
-  /// 'getMessageForX()' methods to construct a specific message.
-  std::string getMessage(const ExplodedNode *N) override;
-
-  /// Produces the message of the following form:
-  ///   'Msg via Nth parameter'
-  virtual std::string getMessageForArg(const Expr *ArgE, unsigned ArgIndex);
-
-  virtual std::string getMessageForReturn(const CallExpr *CallExpr) {
-    return Msg;
-  }
-
-  virtual std::string getMessageForSymbolNotFound() {
-    return Msg;
-  }
-};
-
-class PathDiagnosticEventPiece : public PathDiagnosticSpotPiece {
-  Optional<bool> IsPrunable;
-
-  /// If the event occurs in a different frame than the final diagnostic,
-  /// supply a message that will be used to construct an extra hint on the
-  /// returns from all the calls on the stack from this event to the final
-  /// diagnostic.
-  std::unique_ptr<StackHintGenerator> CallStackHint;
-
-public:
-  PathDiagnosticEventPiece(const PathDiagnosticLocation &pos,
-                           StringRef s, bool addPosRange = true,
-                           StackHintGenerator *stackHint = nullptr)
-      : PathDiagnosticSpotPiece(pos, s, Event, addPosRange),
-        CallStackHint(stackHint) {}
-  ~PathDiagnosticEventPiece() override;
-
-  /// Mark the diagnostic piece as being potentially prunable.  This
-  /// flag may have been previously set, at which point it will not
-  /// be reset unless one specifies to do so.
-  void setPrunable(bool isPrunable, bool override = false) {
-    if (IsPrunable.hasValue() && !override)
-     return;
-    IsPrunable = isPrunable;
-  }
-
-  /// Return true if the diagnostic piece is prunable.
-  bool isPrunable() const {
-    return IsPrunable.hasValue() ? IsPrunable.getValue() : false;
-  }
-
-  bool hasCallStackHint() { return (bool)CallStackHint; }
-
-  /// Produce the hint for the given node. The node contains
-  /// information about the call for which the diagnostic can be generated.
-  std::string getCallStackMessage(const ExplodedNode *N) {
-    if (CallStackHint)
-      return CallStackHint->getMessage(N);
-    return {};
-  }
-
-  void dump() const override;
-
-  static bool classof(const PathDiagnosticPiece *P) {
-    return P->getKind() == Event;
-  }
-};
-
-class PathDiagnosticCallPiece : public PathDiagnosticPiece {
-  const Decl *Caller;
-  const Decl *Callee = nullptr;
-
-  // Flag signifying that this diagnostic has only call enter and no matching
-  // call exit.
-  bool NoExit;
-
-  // Flag signifying that the callee function is an Objective-C autosynthesized
-  // property getter or setter.
-  bool IsCalleeAnAutosynthesizedPropertyAccessor = false;
-
-  // The custom string, which should appear after the call Return Diagnostic.
-  // TODO: Should we allow multiple diagnostics?
-  std::string CallStackMessage;
-
-  PathDiagnosticCallPiece(const Decl *callerD,
-                          const PathDiagnosticLocation &callReturnPos)
-      : PathDiagnosticPiece(Call), Caller(callerD), NoExit(false),
-        callReturn(callReturnPos) {}
-  PathDiagnosticCallPiece(PathPieces &oldPath, const Decl *caller)
-      : PathDiagnosticPiece(Call), Caller(caller), NoExit(true),
-        path(oldPath) {}
-
-public:
-  PathDiagnosticLocation callEnter;
-  PathDiagnosticLocation callEnterWithin;
-  PathDiagnosticLocation callReturn;
-  PathPieces path;
-
-  ~PathDiagnosticCallPiece() override;
-
-  const Decl *getCaller() const { return Caller; }
-
-  const Decl *getCallee() const { return Callee; }
-  void setCallee(const CallEnter &CE, const SourceManager &SM);
-
-  bool hasCallStackMessage() { return !CallStackMessage.empty(); }
-  void setCallStackMessage(StringRef st) { CallStackMessage = st; }
-
-  PathDiagnosticLocation getLocation() const override { return callEnter; }
-
-  std::shared_ptr<PathDiagnosticEventPiece> getCallEnterEvent() const;
-  std::shared_ptr<PathDiagnosticEventPiece>
-  getCallEnterWithinCallerEvent() const;
-  std::shared_ptr<PathDiagnosticEventPiece> getCallExitEvent() const;
-
-  void flattenLocations() override {
-    callEnter.flatten();
-    callReturn.flatten();
-    for (const auto &I : path)
-      I->flattenLocations();
-  }
-
-  static std::shared_ptr<PathDiagnosticCallPiece>
-  construct(const CallExitEnd &CE,
-            const SourceManager &SM);
-
-  static PathDiagnosticCallPiece *construct(PathPieces &pieces,
-                                            const Decl *caller);
-
-  void dump() const override;
-
-  void Profile(llvm::FoldingSetNodeID &ID) const override;
-
-  static bool classof(const PathDiagnosticPiece *P) {
-    return P->getKind() == Call;
-  }
-};
-
-class PathDiagnosticControlFlowPiece : public PathDiagnosticPiece {
-  std::vector<PathDiagnosticLocationPair> LPairs;
-
-public:
-  PathDiagnosticControlFlowPiece(const PathDiagnosticLocation &startPos,
-                                 const PathDiagnosticLocation &endPos,
-                                 StringRef s)
-      : PathDiagnosticPiece(s, ControlFlow) {
-    LPairs.push_back(PathDiagnosticLocationPair(startPos, endPos));
-  }
-
-  PathDiagnosticControlFlowPiece(const PathDiagnosticLocation &startPos,
-                                 const PathDiagnosticLocation &endPos)
-      : PathDiagnosticPiece(ControlFlow) {
-    LPairs.push_back(PathDiagnosticLocationPair(startPos, endPos));
-  }
-
-  ~PathDiagnosticControlFlowPiece() override;
-
-  PathDiagnosticLocation getStartLocation() const {
-    assert(!LPairs.empty() &&
-           "PathDiagnosticControlFlowPiece needs at least one location.");
-    return LPairs[0].getStart();
-  }
-
-  PathDiagnosticLocation getEndLocation() const {
-    assert(!LPairs.empty() &&
-           "PathDiagnosticControlFlowPiece needs at least one location.");
-    return LPairs[0].getEnd();
-  }
-
-  void setStartLocation(const PathDiagnosticLocation &L) {
-    LPairs[0].setStart(L);
-  }
-
-  void setEndLocation(const PathDiagnosticLocation &L) {
-    LPairs[0].setEnd(L);
-  }
-
-  void push_back(const PathDiagnosticLocationPair &X) { LPairs.push_back(X); }
-
-  PathDiagnosticLocation getLocation() const override {
-    return getStartLocation();
-  }
-
-  using iterator = std::vector<PathDiagnosticLocationPair>::iterator;
-
-  iterator begin() { return LPairs.begin(); }
-  iterator end() { return LPairs.end(); }
-
-  void flattenLocations() override {
-    for (auto &I : *this)
-      I.flatten();
-  }
-
-  using const_iterator =
-      std::vector<PathDiagnosticLocationPair>::const_iterator;
-
-  const_iterator begin() const { return LPairs.begin(); }
-  const_iterator end() const { return LPairs.end(); }
-
-  static bool classof(const PathDiagnosticPiece *P) {
-    return P->getKind() == ControlFlow;
-  }
-
-  void dump() const override;
-
-  void Profile(llvm::FoldingSetNodeID &ID) const override;
-};
-
-class PathDiagnosticMacroPiece : public PathDiagnosticSpotPiece {
-public:
-  PathDiagnosticMacroPiece(const PathDiagnosticLocation &pos)
-      : PathDiagnosticSpotPiece(pos, "", Macro) {}
-  ~PathDiagnosticMacroPiece() override;
-
-  PathPieces subPieces;
-
-  bool containsEvent() const;
-
-  void flattenLocations() override {
-    PathDiagnosticSpotPiece::flattenLocations();
-    for (const auto &I : subPieces)
-      I->flattenLocations();
-  }
-
-  static bool classof(const PathDiagnosticPiece *P) {
-    return P->getKind() == Macro;
-  }
-
-  void dump() const override;
-
-  void Profile(llvm::FoldingSetNodeID &ID) const override;
-};
-
-class PathDiagnosticNotePiece: public PathDiagnosticSpotPiece {
-public:
-  PathDiagnosticNotePiece(const PathDiagnosticLocation &Pos, StringRef S,
-                          bool AddPosRange = true)
-      : PathDiagnosticSpotPiece(Pos, S, Note, AddPosRange) {}
-  ~PathDiagnosticNotePiece() override;
-
-  static bool classof(const PathDiagnosticPiece *P) {
-    return P->getKind() == Note;
-  }
-
-  void dump() const override;
-
-  void Profile(llvm::FoldingSetNodeID &ID) const override;
-};
-
-class PathDiagnosticPopUpPiece: public PathDiagnosticSpotPiece {
-public:
-  PathDiagnosticPopUpPiece(const PathDiagnosticLocation &Pos, StringRef S,
-                           bool AddPosRange = true)
-      : PathDiagnosticSpotPiece(Pos, S, PopUp, AddPosRange) {}
-  ~PathDiagnosticPopUpPiece() override;
-
-  static bool classof(const PathDiagnosticPiece *P) {
-    return P->getKind() == PopUp;
-  }
-
-  void dump() const override;
-
-  void Profile(llvm::FoldingSetNodeID &ID) const override;
-};
-
-/// File IDs mapped to sets of line numbers.
-using FilesToLineNumsMap = std::map<FileID, std::set<unsigned>>;
-
-/// PathDiagnostic - PathDiagnostic objects represent a single path-sensitive
-///  diagnostic.  It represents an ordered-collection of PathDiagnosticPieces,
-///  each which represent the pieces of the path.
-class PathDiagnostic : public llvm::FoldingSetNode {
-  std::string CheckName;
-  const Decl *DeclWithIssue;
-  std::string BugType;
-  std::string VerboseDesc;
-  std::string ShortDesc;
-  std::string Category;
-  std::deque<std::string> OtherDesc;
-
-  /// Loc The location of the path diagnostic report.
-  PathDiagnosticLocation Loc;
-
-  PathPieces pathImpl;
-  SmallVector<PathPieces *, 3> pathStack;
-
-  /// Important bug uniqueing location.
-  /// The location info is useful to differentiate between bugs.
-  PathDiagnosticLocation UniqueingLoc;
-  const Decl *UniqueingDecl;
-
-  /// Lines executed in the path.
-  std::unique_ptr<FilesToLineNumsMap> ExecutedLines;
-
-public:
-  PathDiagnostic() = delete;
-  PathDiagnostic(StringRef CheckName, const Decl *DeclWithIssue,
-                 StringRef bugtype, StringRef verboseDesc, StringRef shortDesc,
-                 StringRef category, PathDiagnosticLocation LocationToUnique,
-                 const Decl *DeclToUnique,
-                 std::unique_ptr<FilesToLineNumsMap> ExecutedLines);
-  ~PathDiagnostic();
-
-  const PathPieces &path;
-
-  /// Return the path currently used by builders for constructing the
-  /// PathDiagnostic.
-  PathPieces &getActivePath() {
-    if (pathStack.empty())
-      return pathImpl;
-    return *pathStack.back();
-  }
-
-  /// Return a mutable version of 'path'.
-  PathPieces &getMutablePieces() {
-    return pathImpl;
-  }
-
-  /// Return the unrolled size of the path.
-  unsigned full_size();
-
-  void pushActivePath(PathPieces *p) { pathStack.push_back(p); }
-  void popActivePath() { if (!pathStack.empty()) pathStack.pop_back(); }
-
-  bool isWithinCall() const { return !pathStack.empty(); }
-
-  void setEndOfPath(std::shared_ptr<PathDiagnosticPiece> EndPiece) {
-    assert(!Loc.isValid() && "End location already set!");
-    Loc = EndPiece->getLocation();
-    assert(Loc.isValid() && "Invalid location for end-of-path piece");
-    getActivePath().push_back(std::move(EndPiece));
-  }
-
-  void appendToDesc(StringRef S) {
-    if (!ShortDesc.empty())
-      ShortDesc += S;
-    VerboseDesc += S;
-  }
-
-  /// If the last piece of the report point to the header file, resets
-  /// the location of the report to be the last location in the main source
-  /// file.
-  void resetDiagnosticLocationToMainFile();
-
-  StringRef getVerboseDescription() const { return VerboseDesc; }
-
-  StringRef getShortDescription() const {
-    return ShortDesc.empty() ? VerboseDesc : ShortDesc;
-  }
-
-  StringRef getCheckName() const { return CheckName; }
-  StringRef getBugType() const { return BugType; }
-  StringRef getCategory() const { return Category; }
-
-  /// Return the semantic context where an issue occurred.  If the
-  /// issue occurs along a path, this represents the "central" area
-  /// where the bug manifests.
-  const Decl *getDeclWithIssue() const { return DeclWithIssue; }
-
-  using meta_iterator = std::deque<std::string>::const_iterator;
-
-  meta_iterator meta_begin() const { return OtherDesc.begin(); }
-  meta_iterator meta_end() const { return OtherDesc.end(); }
-  void addMeta(StringRef s) { OtherDesc.push_back(s); }
-
-  const FilesToLineNumsMap &getExecutedLines() const {
-    return *ExecutedLines;
-  }
-
-  FilesToLineNumsMap &getExecutedLines() {
-    return *ExecutedLines;
-  }
-
-  PathDiagnosticLocation getLocation() const {
-    return Loc;
-  }
-
-  /// Get the location on which the report should be uniqued.
-  PathDiagnosticLocation getUniqueingLoc() const {
-    return UniqueingLoc;
-  }
-
-  /// Get the declaration containing the uniqueing location.
-  const Decl *getUniqueingDecl() const {
-    return UniqueingDecl;
-  }
-
-  void flattenLocations() {
-    Loc.flatten();
-    for (const auto &I : pathImpl)
-      I->flattenLocations();
-  }
-
-  /// Profiles the diagnostic, independent of the path it references.
-  ///
-  /// This can be used to merge diagnostics that refer to the same issue
-  /// along different paths.
-  void Profile(llvm::FoldingSetNodeID &ID) const;
-
-  /// Profiles the diagnostic, including its path.
-  ///
-  /// Two diagnostics with the same issue along different paths will generate
-  /// different profiles.
-  void FullProfile(llvm::FoldingSetNodeID &ID) const;
-};
-
-} // namespace ento
-
-} // namespace clang
-
-#endif // LLVM_CLANG_STATICANALYZER_CORE_BUGREPORTER_PATHDIAGNOSTIC_H