[analyzer] NFC: Move PathDiagnostic to libAnalysis.

[NoQ]

Summary

At this point PathDiagnostic, PathDiagnosticLocation, PathDiagnosticPiece structures no longer rely on anything specific to Static Analyzer, so we can move them out for everybody to use.

It's not the point where I'm happy with the API that i'm exposing this way; it's just the point where i expose it "because i can", i.e. the technical difficulties have been sorted out and a relatively clear separation between aspects of the API that are specific to the Analyzer and the aspects that aren't necessarily specific to the Analyzer has been achieved.

PathDiagnosticConsumers are still to be handed off.

[NoQ]

clang-tools-extra/clang-tidy/ClangTidy.cpp

26 ↗

(On Diff #219627)

This needed to go up because that's where CLANG_ENABLE_STATIC_ANALYZER is defined.

[Szelethus]

Looks great! Are we sure that PathDiagnostic.h is a good header name?

clang-tools-extra/clang-tidy/ClangTidy.cpp

26 ↗

(On Diff #219627)

Let's add some scary comments then, to warn everyone trying to blindly clang-format this file.

[gribozavr]

clang-tools-extra/clang-tidy/ClangTidy.cpp

26 ↗

(On Diff #219627)

I'd suggest to move all conditionally-included headers into a separate "section" below, separated by a newline from the rest of the headers. clang-format will respect that and won't reorder sections.

[NoQ]

In D67419#1665993, @Szelethus wrote:

Looks great! Are we sure that PathDiagnostic.h is a good header name?

Not really, but i haven't come up with a better name yet (see also the summary of D67422).

P.S. Sry, i seem to have had a spam streak today.

cfe/trunk/include/clang/Analysis/PathDiagnostic.h

+//===- 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 {
+
+//===----------------------------------------------------------------------===//
+// 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; }
+
+  bool shouldGenerateDiagnostics() const {
+    return getGenerationScheme() != None;
+  }
+
+  bool shouldAddPathEdges() const { return getGenerationScheme() == Extensive; }
+
+  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 ProgramPoint.
+  static PathDiagnosticLocation create(const ProgramPoint &P,
+                                       const SourceManager &SMng);
+
+  /// Convert the given location into a single kind location.
+  static PathDiagnosticLocation createSingleLocation(
+                                             const PathDiagnosticLocation &PDL);
+
+  /// Construct a source location that corresponds to either the beginning
+  /// or the end of the given statement, or a nearby valid source location
+  /// if the statement does not have a valid source location of its own.
+  static SourceLocation
+  getValidSourceLocation(const Stmt *S, LocationOrAnalysisDeclContext LAC,
+                         bool UseEndOfStatement = false);
+
+  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;
+};
+
+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;
+  std::vector<FixItHint> fixits;
+
+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));
+  }
+
+  void addFixit(FixItHint F) {
+    fixits.push_back(F);
+  }
+
+  /// Return the SourceRanges associated with this PathDiagnosticPiece.
+  ArrayRef<SourceRange> getRanges() const { return ranges; }
+
+  /// Return the fix-it hints associated with this PathDiagnosticPiece.
+  ArrayRef<FixItHint> getFixits() const { return fixits; }
+
+  virtual void Profile(llvm::FoldingSetNodeID &ID) const;
+
+  void setAsLastInMainSourceFile() {
+    LastInMainSourceFile = true;
+  }
+
+  bool isLastInMainSourceFile() const {
+    return LastInMainSourceFile;
+  }
+
+  virtual void dump() const = 0;
+};
+
+using PathDiagnosticPieceRef = std::shared_ptr<PathDiagnosticPiece>;
+
+class PathPieces : public std::list<PathDiagnosticPieceRef> {
+  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;
+  }
+};
+
+class PathDiagnosticEventPiece : public PathDiagnosticSpotPiece {
+  Optional<bool> IsPrunable;
+
+public:
+  PathDiagnosticEventPiece(const PathDiagnosticLocation &pos,
+                           StringRef s, bool addPosRange = true)
+      : PathDiagnosticSpotPiece(pos, s, Event, addPosRange) {}
+  ~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;
+  }
+
+  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;
+
+  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(PathDiagnosticPieceRef 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;
+  }
+
+  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; }
+
+  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;
+  }
+
+  /// 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; }
+
+  void setDeclWithIssue(const Decl *D) {
+    DeclWithIssue = D;
+  }
+
+  PathDiagnosticLocation getLocation() const {
+    return Loc;
+  }
+
+  void setLocation(PathDiagnosticLocation NewLoc) {
+    Loc = NewLoc;
+  }
+
+  /// 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

cfe/trunk/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h

 //===- BugReporter.h - Generate PathDiagnostics -----------------*- 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 BugReporter, a utility class for generating
 //  PathDiagnostics for analyses based on ProgramState.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_STATICANALYZER_CORE_BUGREPORTER_BUGREPORTER_H
 #define LLVM_CLANG_STATICANALYZER_CORE_BUGREPORTER_BUGREPORTER_H
 
+#include "clang/Analysis/PathDiagnostic.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h"
-#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SymExpr.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/FoldingSet.h"

cfe/trunk/include/clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h

-//===- 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 {
-
-//===----------------------------------------------------------------------===//
-// 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; }
-
-  bool shouldGenerateDiagnostics() const {
-    return getGenerationScheme() != None;
-  }
-
-  bool shouldAddPathEdges() const { return getGenerationScheme() == Extensive; }
-
-  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 ProgramPoint.
-  static PathDiagnosticLocation create(const ProgramPoint &P,
-                                       const SourceManager &SMng);
-
-  /// Convert the given location into a single kind location.
-  static PathDiagnosticLocation createSingleLocation(
-                                             const PathDiagnosticLocation &PDL);
-
-  /// Construct a source location that corresponds to either the beginning
-  /// or the end of the given statement, or a nearby valid source location
-  /// if the statement does not have a valid source location of its own.
-  static SourceLocation
-  getValidSourceLocation(const Stmt *S, LocationOrAnalysisDeclContext LAC,
-                         bool UseEndOfStatement = false);
-
-  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;
-};
-
-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;
-  std::vector<FixItHint> fixits;
-
-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));
-  }
-
-  void addFixit(FixItHint F) {
-    fixits.push_back(F);
-  }
-
-  /// Return the SourceRanges associated with this PathDiagnosticPiece.
-  ArrayRef<SourceRange> getRanges() const { return ranges; }
-
-  /// Return the fix-it hints associated with this PathDiagnosticPiece.
-  ArrayRef<FixItHint> getFixits() const { return fixits; }
-
-  virtual void Profile(llvm::FoldingSetNodeID &ID) const;
-
-  void setAsLastInMainSourceFile() {
-    LastInMainSourceFile = true;
-  }
-
-  bool isLastInMainSourceFile() const {
-    return LastInMainSourceFile;
-  }
-
-  virtual void dump() const = 0;
-};
-
-using PathDiagnosticPieceRef = std::shared_ptr<PathDiagnosticPiece>;
-
-class PathPieces : public std::list<PathDiagnosticPieceRef> {
-  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;
-  }
-};
-
-class PathDiagnosticEventPiece : public PathDiagnosticSpotPiece {
-  Optional<bool> IsPrunable;
-
-public:
-  PathDiagnosticEventPiece(const PathDiagnosticLocation &pos,
-                           StringRef s, bool addPosRange = true)
-      : PathDiagnosticSpotPiece(pos, s, Event, addPosRange) {}
-  ~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;
-  }
-
-  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;
-
-  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(PathDiagnosticPieceRef 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;
-  }
-
-  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; }
-
-  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;
-  }
-
-  /// 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; }
-
-  void setDeclWithIssue(const Decl *D) {
-    DeclWithIssue = D;
-  }
-
-  PathDiagnosticLocation getLocation() const {
-    return Loc;
-  }
-
-  void setLocation(PathDiagnosticLocation NewLoc) {
-    Loc = NewLoc;
-  }
-
-  /// 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

cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h

 // for path sensitive analysis.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_ANALYSISMANAGER_H
 #define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_ANALYSISMANAGER_H
 
 #include "clang/Analysis/AnalysisDeclContext.h"
+#include "clang/Analysis/PathDiagnostic.h"
 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
-#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
 #include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
 
 namespace clang {
 
 class CodeInjector;
 
 namespace ento {
   class CheckerManager;

cfe/trunk/lib/Analysis/CMakeLists.txt

add_clang_library(clangAnalysis
   CocoaConventions.cpp
   ConstructionContext.cpp
   Consumed.cpp
   CodeInjector.cpp
   Dominators.cpp
   ExprMutationAnalyzer.cpp
   LiveVariables.cpp
   ObjCNoReturn.cpp
+  PathDiagnostic.cpp
   PostOrderCFGView.cpp
   ProgramPoint.cpp
   ReachableCode.cpp
   RetainSummaryManager.cpp
   ThreadSafety.cpp
   ThreadSafetyCommon.cpp
   ThreadSafetyLogical.cpp
   ThreadSafetyTIL.cpp

cfe/trunk/lib/Analysis/PathDiagnostic.cpp

+//===- PathDiagnostic.cpp - Path-Specific Diagnostic Handling -------------===//
+//
+// 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Analysis/PathDiagnostic.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclBase.h"
+#include "clang/AST/DeclCXX.h"
+#include "clang/AST/DeclObjC.h"
+#include "clang/AST/DeclTemplate.h"
+#include "clang/AST/Expr.h"
+#include "clang/AST/ExprCXX.h"
+#include "clang/AST/OperationKinds.h"
+#include "clang/AST/ParentMap.h"
+#include "clang/AST/Stmt.h"
+#include "clang/AST/Type.h"
+#include "clang/Analysis/AnalysisDeclContext.h"
+#include "clang/Analysis/CFG.h"
+#include "clang/Analysis/ProgramPoint.h"
+#include "clang/Basic/FileManager.h"
+#include "clang/Basic/LLVM.h"
+#include "clang/Basic/SourceLocation.h"
+#include "clang/Basic/SourceManager.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/FoldingSet.h"
+#include "llvm/ADT/None.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/raw_ostream.h"
+#include <cassert>
+#include <cstring>
+#include <memory>
+#include <utility>
+#include <vector>
+
+using namespace clang;
+using namespace ento;
+
+static StringRef StripTrailingDots(StringRef s) {
+  for (StringRef::size_type i = s.size(); i != 0; --i)
+    if (s[i - 1] != '.')
+      return s.substr(0, i);
+  return {};
+}
+
+PathDiagnosticPiece::PathDiagnosticPiece(StringRef s,
+                                         Kind k, DisplayHint hint)
+    : str(StripTrailingDots(s)), kind(k), Hint(hint) {}
+
+PathDiagnosticPiece::PathDiagnosticPiece(Kind k, DisplayHint hint)
+    : kind(k), Hint(hint) {}
+
+PathDiagnosticPiece::~PathDiagnosticPiece() = default;
+
+PathDiagnosticEventPiece::~PathDiagnosticEventPiece() = default;
+
+PathDiagnosticCallPiece::~PathDiagnosticCallPiece() = default;
+
+PathDiagnosticControlFlowPiece::~PathDiagnosticControlFlowPiece() = default;
+
+PathDiagnosticMacroPiece::~PathDiagnosticMacroPiece() = default;
+
+PathDiagnosticNotePiece::~PathDiagnosticNotePiece() = default;
+
+PathDiagnosticPopUpPiece::~PathDiagnosticPopUpPiece() = default;
+
+void PathPieces::flattenTo(PathPieces &Primary, PathPieces &Current,
+                           bool ShouldFlattenMacros) const {
+  for (auto &Piece : *this) {
+    switch (Piece->getKind()) {
+    case PathDiagnosticPiece::Call: {
+      auto &Call = cast<PathDiagnosticCallPiece>(*Piece);
+      if (auto CallEnter = Call.getCallEnterEvent())
+        Current.push_back(std::move(CallEnter));
+      Call.path.flattenTo(Primary, Primary, ShouldFlattenMacros);
+      if (auto callExit = Call.getCallExitEvent())
+        Current.push_back(std::move(callExit));
+      break;
+    }
+    case PathDiagnosticPiece::Macro: {
+      auto &Macro = cast<PathDiagnosticMacroPiece>(*Piece);
+      if (ShouldFlattenMacros) {
+        Macro.subPieces.flattenTo(Primary, Primary, ShouldFlattenMacros);
+      } else {
+        Current.push_back(Piece);
+        PathPieces NewPath;
+        Macro.subPieces.flattenTo(Primary, NewPath, ShouldFlattenMacros);
+        // FIXME: This probably shouldn't mutate the original path piece.
+        Macro.subPieces = NewPath;
+      }
+      break;
+    }
+    case PathDiagnosticPiece::Event:
+    case PathDiagnosticPiece::ControlFlow:
+    case PathDiagnosticPiece::Note:
+    case PathDiagnosticPiece::PopUp:
+      Current.push_back(Piece);
+      break;
+    }
+  }
+}
+
+PathDiagnostic::~PathDiagnostic() = default;
+
+PathDiagnostic::PathDiagnostic(
+    StringRef CheckName, const Decl *declWithIssue, StringRef bugtype,
+    StringRef verboseDesc, StringRef shortDesc, StringRef category,
+    PathDiagnosticLocation LocationToUnique, const Decl *DeclToUnique,
+    std::unique_ptr<FilesToLineNumsMap> ExecutedLines)
+    : CheckName(CheckName), DeclWithIssue(declWithIssue),
+      BugType(StripTrailingDots(bugtype)),
+      VerboseDesc(StripTrailingDots(verboseDesc)),
+      ShortDesc(StripTrailingDots(shortDesc)),
+      Category(StripTrailingDots(category)), UniqueingLoc(LocationToUnique),
+      UniqueingDecl(DeclToUnique), ExecutedLines(std::move(ExecutedLines)),
+      path(pathImpl) {}
+
+void PathDiagnosticConsumer::anchor() {}
+
+PathDiagnosticConsumer::~PathDiagnosticConsumer() {
+  // Delete the contents of the FoldingSet if it isn't empty already.
+  for (auto &Diag : Diags)
+    delete &Diag;
+}
+
+void PathDiagnosticConsumer::HandlePathDiagnostic(
+    std::unique_ptr<PathDiagnostic> D) {
+  if (!D || D->path.empty())
+    return;
+
+  // We need to flatten the locations (convert Stmt* to locations) because
+  // the referenced statements may be freed by the time the diagnostics
+  // are emitted.
+  D->flattenLocations();
+
+  // If the PathDiagnosticConsumer does not support diagnostics that
+  // cross file boundaries, prune out such diagnostics now.
+  if (!supportsCrossFileDiagnostics()) {
+    // Verify that the entire path is from the same FileID.
+    FileID FID;
+    const SourceManager &SMgr = D->path.front()->getLocation().getManager();
+    SmallVector<const PathPieces *, 5> WorkList;
+    WorkList.push_back(&D->path);
+    SmallString<128> buf;
+    llvm::raw_svector_ostream warning(buf);
+    warning << "warning: Path diagnostic report is not generated. Current "
+            << "output format does not support diagnostics that cross file "
+            << "boundaries. Refer to --analyzer-output for valid output "
+            << "formats\n";
+
+    while (!WorkList.empty()) {
+      const PathPieces &path = *WorkList.pop_back_val();
+
+      for (const auto &I : path) {
+        const PathDiagnosticPiece *piece = I.get();
+        FullSourceLoc L = piece->getLocation().asLocation().getExpansionLoc();
+
+        if (FID.isInvalid()) {
+          FID = SMgr.getFileID(L);
+        } else if (SMgr.getFileID(L) != FID) {
+          llvm::errs() << warning.str();
+          return;
+        }
+
+        // Check the source ranges.
+        ArrayRef<SourceRange> Ranges = piece->getRanges();
+        for (const auto &I : Ranges) {
+          SourceLocation L = SMgr.getExpansionLoc(I.getBegin());
+          if (!L.isFileID() || SMgr.getFileID(L) != FID) {
+            llvm::errs() << warning.str();
+            return;
+          }
+          L = SMgr.getExpansionLoc(I.getEnd());
+          if (!L.isFileID() || SMgr.getFileID(L) != FID) {
+            llvm::errs() << warning.str();
+            return;
+          }
+        }
+
+        if (const auto *call = dyn_cast<PathDiagnosticCallPiece>(piece))
+          WorkList.push_back(&call->path);
+        else if (const auto *macro = dyn_cast<PathDiagnosticMacroPiece>(piece))
+          WorkList.push_back(&macro->subPieces);
+      }
+    }
+
+    if (FID.isInvalid())
+      return; // FIXME: Emit a warning?
+  }
+
+  // Profile the node to see if we already have something matching it
+  llvm::FoldingSetNodeID profile;
+  D->Profile(profile);
+  void *InsertPos = nullptr;
+
+  if (PathDiagnostic *orig = Diags.FindNodeOrInsertPos(profile, InsertPos)) {
+    // Keep the PathDiagnostic with the shorter path.
+    // Note, the enclosing routine is called in deterministic order, so the
+    // results will be consistent between runs (no reason to break ties if the
+    // size is the same).
+    const unsigned orig_size = orig->full_size();
+    const unsigned new_size = D->full_size();
+    if (orig_size <= new_size)
+      return;
+
+    assert(orig != D.get());
+    Diags.RemoveNode(orig);
+    delete orig;
+  }
+
+  Diags.InsertNode(D.release());
+}
+
+static Optional<bool> comparePath(const PathPieces &X, const PathPieces &Y);
+
+static Optional<bool>
+compareControlFlow(const PathDiagnosticControlFlowPiece &X,
+                   const PathDiagnosticControlFlowPiece &Y) {
+  FullSourceLoc XSL = X.getStartLocation().asLocation();
+  FullSourceLoc YSL = Y.getStartLocation().asLocation();
+  if (XSL != YSL)
+    return XSL.isBeforeInTranslationUnitThan(YSL);
+  FullSourceLoc XEL = X.getEndLocation().asLocation();
+  FullSourceLoc YEL = Y.getEndLocation().asLocation();
+  if (XEL != YEL)
+    return XEL.isBeforeInTranslationUnitThan(YEL);
+  return None;
+}
+
+static Optional<bool> compareMacro(const PathDiagnosticMacroPiece &X,
+                                   const PathDiagnosticMacroPiece &Y) {
+  return comparePath(X.subPieces, Y.subPieces);
+}
+
+static Optional<bool> compareCall(const PathDiagnosticCallPiece &X,
+                                  const PathDiagnosticCallPiece &Y) {
+  FullSourceLoc X_CEL = X.callEnter.asLocation();
+  FullSourceLoc Y_CEL = Y.callEnter.asLocation();
+  if (X_CEL != Y_CEL)
+    return X_CEL.isBeforeInTranslationUnitThan(Y_CEL);
+  FullSourceLoc X_CEWL = X.callEnterWithin.asLocation();
+  FullSourceLoc Y_CEWL = Y.callEnterWithin.asLocation();
+  if (X_CEWL != Y_CEWL)
+    return X_CEWL.isBeforeInTranslationUnitThan(Y_CEWL);
+  FullSourceLoc X_CRL = X.callReturn.asLocation();
+  FullSourceLoc Y_CRL = Y.callReturn.asLocation();
+  if (X_CRL != Y_CRL)
+    return X_CRL.isBeforeInTranslationUnitThan(Y_CRL);
+  return comparePath(X.path, Y.path);
+}
+
+static Optional<bool> comparePiece(const PathDiagnosticPiece &X,
+                                   const PathDiagnosticPiece &Y) {
+  if (X.getKind() != Y.getKind())
+    return X.getKind() < Y.getKind();
+
+  FullSourceLoc XL = X.getLocation().asLocation();
+  FullSourceLoc YL = Y.getLocation().asLocation();
+  if (XL != YL)
+    return XL.isBeforeInTranslationUnitThan(YL);
+
+  if (X.getString() != Y.getString())
+    return X.getString() < Y.getString();
+
+  if (X.getRanges().size() != Y.getRanges().size())
+    return X.getRanges().size() < Y.getRanges().size();
+
+  const SourceManager &SM = XL.getManager();
+
+  for (unsigned i = 0, n = X.getRanges().size(); i < n; ++i) {
+    SourceRange XR = X.getRanges()[i];
+    SourceRange YR = Y.getRanges()[i];
+    if (XR != YR) {
+      if (XR.getBegin() != YR.getBegin())
+        return SM.isBeforeInTranslationUnit(XR.getBegin(), YR.getBegin());
+      return SM.isBeforeInTranslationUnit(XR.getEnd(), YR.getEnd());
+    }
+  }
+
+  switch (X.getKind()) {
+    case PathDiagnosticPiece::ControlFlow:
+      return compareControlFlow(cast<PathDiagnosticControlFlowPiece>(X),
+                                cast<PathDiagnosticControlFlowPiece>(Y));
+    case PathDiagnosticPiece::Macro:
+      return compareMacro(cast<PathDiagnosticMacroPiece>(X),
+                          cast<PathDiagnosticMacroPiece>(Y));
+    case PathDiagnosticPiece::Call:
+      return compareCall(cast<PathDiagnosticCallPiece>(X),
+                         cast<PathDiagnosticCallPiece>(Y));
+    case PathDiagnosticPiece::Event:
+    case PathDiagnosticPiece::Note:
+    case PathDiagnosticPiece::PopUp:
+      return None;
+  }
+  llvm_unreachable("all cases handled");
+}
+
+static Optional<bool> comparePath(const PathPieces &X, const PathPieces &Y) {
+  if (X.size() != Y.size())
+    return X.size() < Y.size();
+
+  PathPieces::const_iterator X_I = X.begin(), X_end = X.end();
+  PathPieces::const_iterator Y_I = Y.begin(), Y_end = Y.end();
+
+  for ( ; X_I != X_end && Y_I != Y_end; ++X_I, ++Y_I) {
+    Optional<bool> b = comparePiece(**X_I, **Y_I);
+    if (b.hasValue())
+      return b.getValue();
+  }
+
+  return None;
+}
+
+static bool compareCrossTUSourceLocs(FullSourceLoc XL, FullSourceLoc YL) {
+  std::pair<FileID, unsigned> XOffs = XL.getDecomposedLoc();
+  std::pair<FileID, unsigned> YOffs = YL.getDecomposedLoc();
+  const SourceManager &SM = XL.getManager();
+  std::pair<bool, bool> InSameTU = SM.isInTheSameTranslationUnit(XOffs, YOffs);
+  if (InSameTU.first)
+    return XL.isBeforeInTranslationUnitThan(YL);
+  const FileEntry *XFE = SM.getFileEntryForID(XL.getSpellingLoc().getFileID());
+  const FileEntry *YFE = SM.getFileEntryForID(YL.getSpellingLoc().getFileID());
+  if (!XFE || !YFE)
+    return XFE && !YFE;
+  int NameCmp = XFE->getName().compare(YFE->getName());
+  if (NameCmp != 0)
+    return NameCmp == -1;
+  // Last resort: Compare raw file IDs that are possibly expansions.
+  return XL.getFileID() < YL.getFileID();
+}
+
+static bool compare(const PathDiagnostic &X, const PathDiagnostic &Y) {
+  FullSourceLoc XL = X.getLocation().asLocation();
+  FullSourceLoc YL = Y.getLocation().asLocation();
+  if (XL != YL)
+    return compareCrossTUSourceLocs(XL, YL);
+  if (X.getBugType() != Y.getBugType())
+    return X.getBugType() < Y.getBugType();
+  if (X.getCategory() != Y.getCategory())
+    return X.getCategory() < Y.getCategory();
+  if (X.getVerboseDescription() != Y.getVerboseDescription())
+    return X.getVerboseDescription() < Y.getVerboseDescription();
+  if (X.getShortDescription() != Y.getShortDescription())
+    return X.getShortDescription() < Y.getShortDescription();
+  if (X.getDeclWithIssue() != Y.getDeclWithIssue()) {
+    const Decl *XD = X.getDeclWithIssue();
+    if (!XD)
+      return true;
+    const Decl *YD = Y.getDeclWithIssue();
+    if (!YD)
+      return false;
+    SourceLocation XDL = XD->getLocation();
+    SourceLocation YDL = YD->getLocation();
+    if (XDL != YDL) {
+      const SourceManager &SM = XL.getManager();
+      return compareCrossTUSourceLocs(FullSourceLoc(XDL, SM),
+                                      FullSourceLoc(YDL, SM));
+    }
+  }
+  PathDiagnostic::meta_iterator XI = X.meta_begin(), XE = X.meta_end();
+  PathDiagnostic::meta_iterator YI = Y.meta_begin(), YE = Y.meta_end();
+  if (XE - XI != YE - YI)
+    return (XE - XI) < (YE - YI);
+  for ( ; XI != XE ; ++XI, ++YI) {
+    if (*XI != *YI)
+      return (*XI) < (*YI);
+  }
+  Optional<bool> b = comparePath(X.path, Y.path);
+  assert(b.hasValue());
+  return b.getValue();
+}
+
+void PathDiagnosticConsumer::FlushDiagnostics(
+                                     PathDiagnosticConsumer::FilesMade *Files) {
+  if (flushed)
+    return;
+
+  flushed = true;
+
+  std::vector<const PathDiagnostic *> BatchDiags;
+  for (const auto &D : Diags)
+    BatchDiags.push_back(&D);
+
+  // Sort the diagnostics so that they are always emitted in a deterministic
+  // order.
+  int (*Comp)(const PathDiagnostic *const *, const PathDiagnostic *const *) =
+      [](const PathDiagnostic *const *X, const PathDiagnostic *const *Y) {
+        assert(*X != *Y && "PathDiagnostics not uniqued!");
+        if (compare(**X, **Y))
+          return -1;
+        assert(compare(**Y, **X) && "Not a total order!");
+        return 1;
+      };
+  array_pod_sort(BatchDiags.begin(), BatchDiags.end(), Comp);
+
+  FlushDiagnosticsImpl(BatchDiags, Files);
+
+  // Delete the flushed diagnostics.
+  for (const auto D : BatchDiags)
+    delete D;
+
+  // Clear out the FoldingSet.
+  Diags.clear();
+}
+
+PathDiagnosticConsumer::FilesMade::~FilesMade() {
+  for (PDFileEntry &Entry : Set)
+    Entry.~PDFileEntry();
+}
+
+void PathDiagnosticConsumer::FilesMade::addDiagnostic(const PathDiagnostic &PD,
+                                                      StringRef ConsumerName,
+                                                      StringRef FileName) {
+  llvm::FoldingSetNodeID NodeID;
+  NodeID.Add(PD);
+  void *InsertPos;
+  PDFileEntry *Entry = Set.FindNodeOrInsertPos(NodeID, InsertPos);
+  if (!Entry) {
+    Entry = Alloc.Allocate<PDFileEntry>();
+    Entry = new (Entry) PDFileEntry(NodeID);
+    Set.InsertNode(Entry, InsertPos);
+  }
+
+  // Allocate persistent storage for the file name.
+  char *FileName_cstr = (char*) Alloc.Allocate(FileName.size(), 1);
+  memcpy(FileName_cstr, FileName.data(), FileName.size());
+
+  Entry->files.push_back(std::make_pair(ConsumerName,
+                                        StringRef(FileName_cstr,
+                                                  FileName.size())));
+}
+
+PathDiagnosticConsumer::PDFileEntry::ConsumerFiles *
+PathDiagnosticConsumer::FilesMade::getFiles(const PathDiagnostic &PD) {
+  llvm::FoldingSetNodeID NodeID;
+  NodeID.Add(PD);
+  void *InsertPos;
+  PDFileEntry *Entry = Set.FindNodeOrInsertPos(NodeID, InsertPos);
+  if (!Entry)
+    return nullptr;
+  return &Entry->files;
+}
+
+//===----------------------------------------------------------------------===//
+// PathDiagnosticLocation methods.
+//===----------------------------------------------------------------------===//
+
+SourceLocation PathDiagnosticLocation::getValidSourceLocation(
+    const Stmt *S, LocationOrAnalysisDeclContext LAC, bool UseEndOfStatement) {
+  SourceLocation L = UseEndOfStatement ? S->getEndLoc() : S->getBeginLoc();
+  assert(!LAC.isNull() &&
+         "A valid LocationContext or AnalysisDeclContext should be passed to "
+         "PathDiagnosticLocation upon creation.");
+
+  // S might be a temporary statement that does not have a location in the
+  // source code, so find an enclosing statement and use its location.
+  if (!L.isValid()) {
+    AnalysisDeclContext *ADC;
+    if (LAC.is<const LocationContext*>())
+      ADC = LAC.get<const LocationContext*>()->getAnalysisDeclContext();
+    else
+      ADC = LAC.get<AnalysisDeclContext*>();
+
+    ParentMap &PM = ADC->getParentMap();
+
+    const Stmt *Parent = S;
+    do {
+      Parent = PM.getParent(Parent);
+
+      // In rare cases, we have implicit top-level expressions,
+      // such as arguments for implicit member initializers.
+      // In this case, fall back to the start of the body (even if we were
+      // asked for the statement end location).
+      if (!Parent) {
+        const Stmt *Body = ADC->getBody();
+        if (Body)
+          L = Body->getBeginLoc();
+        else
+          L = ADC->getDecl()->getEndLoc();
+        break;
+      }
+
+      L = UseEndOfStatement ? Parent->getEndLoc() : Parent->getBeginLoc();
+    } while (!L.isValid());
+  }
+
+  // FIXME: Ironically, this assert actually fails in some cases.
+  //assert(L.isValid());
+  return L;
+}
+
+static PathDiagnosticLocation
+getLocationForCaller(const StackFrameContext *SFC,
+                     const LocationContext *CallerCtx,
+                     const SourceManager &SM) {
+  const CFGBlock &Block = *SFC->getCallSiteBlock();
+  CFGElement Source = Block[SFC->getIndex()];
+
+  switch (Source.getKind()) {
+  case CFGElement::Statement:
+  case CFGElement::Constructor:
+  case CFGElement::CXXRecordTypedCall:
+    return PathDiagnosticLocation(Source.castAs<CFGStmt>().getStmt(),
+                                  SM, CallerCtx);
+  case CFGElement::Initializer: {
+    const CFGInitializer &Init = Source.castAs<CFGInitializer>();
+    return PathDiagnosticLocation(Init.getInitializer()->getInit(),
+                                  SM, CallerCtx);
+  }
+  case CFGElement::AutomaticObjectDtor: {
+    const CFGAutomaticObjDtor &Dtor = Source.castAs<CFGAutomaticObjDtor>();
+    return PathDiagnosticLocation::createEnd(Dtor.getTriggerStmt(),
+                                             SM, CallerCtx);
+  }
+  case CFGElement::DeleteDtor: {
+    const CFGDeleteDtor &Dtor = Source.castAs<CFGDeleteDtor>();
+    return PathDiagnosticLocation(Dtor.getDeleteExpr(), SM, CallerCtx);
+  }
+  case CFGElement::BaseDtor:
+  case CFGElement::MemberDtor: {
+    const AnalysisDeclContext *CallerInfo = CallerCtx->getAnalysisDeclContext();
+    if (const Stmt *CallerBody = CallerInfo->getBody())
+      return PathDiagnosticLocation::createEnd(CallerBody, SM, CallerCtx);
+    return PathDiagnosticLocation::create(CallerInfo->getDecl(), SM);
+  }
+  case CFGElement::NewAllocator: {
+    const CFGNewAllocator &Alloc = Source.castAs<CFGNewAllocator>();
+    return PathDiagnosticLocation(Alloc.getAllocatorExpr(), SM, CallerCtx);
+  }
+  case CFGElement::TemporaryDtor: {
+    // Temporary destructors are for temporaries. They die immediately at around
+    // the location of CXXBindTemporaryExpr. If they are lifetime-extended,
+    // they'd be dealt with via an AutomaticObjectDtor instead.
+    const auto &Dtor = Source.castAs<CFGTemporaryDtor>();
+    return PathDiagnosticLocation::createEnd(Dtor.getBindTemporaryExpr(), SM,
+                                             CallerCtx);
+  }
+  case CFGElement::ScopeBegin:
+  case CFGElement::ScopeEnd:
+    llvm_unreachable("not yet implemented!");
+  case CFGElement::LifetimeEnds:
+  case CFGElement::LoopExit:
+    llvm_unreachable("CFGElement kind should not be on callsite!");
+  }
+
+  llvm_unreachable("Unknown CFGElement kind");
+}
+
+PathDiagnosticLocation
+PathDiagnosticLocation::createBegin(const Decl *D,
+                                    const SourceManager &SM) {
+  return PathDiagnosticLocation(D->getBeginLoc(), SM, SingleLocK);
+}
+
+PathDiagnosticLocation
+PathDiagnosticLocation::createBegin(const Stmt *S,
+                                    const SourceManager &SM,
+                                    LocationOrAnalysisDeclContext LAC) {
+  return PathDiagnosticLocation(getValidSourceLocation(S, LAC),
+                                SM, SingleLocK);
+}
+
+PathDiagnosticLocation
+PathDiagnosticLocation::createEnd(const Stmt *S,
+                                  const SourceManager &SM,
+                                  LocationOrAnalysisDeclContext LAC) {
+  if (const auto *CS = dyn_cast<CompoundStmt>(S))
+    return createEndBrace(CS, SM);
+  return PathDiagnosticLocation(getValidSourceLocation(S, LAC, /*End=*/true),
+                                SM, SingleLocK);
+}
+
+PathDiagnosticLocation
+PathDiagnosticLocation::createOperatorLoc(const BinaryOperator *BO,
+                                          const SourceManager &SM) {
+  return PathDiagnosticLocation(BO->getOperatorLoc(), SM, SingleLocK);
+}
+
+PathDiagnosticLocation
+PathDiagnosticLocation::createConditionalColonLoc(
+                                            const ConditionalOperator *CO,
+                                            const SourceManager &SM) {
+  return PathDiagnosticLocation(CO->getColonLoc(), SM, SingleLocK);
+}
+
+PathDiagnosticLocation
+PathDiagnosticLocation::createMemberLoc(const MemberExpr *ME,
+                                        const SourceManager &SM) {
+
+  assert(ME->getMemberLoc().isValid() || ME->getBeginLoc().isValid());
+
+  // In some cases, getMemberLoc isn't valid -- in this case we'll return with
+  // some other related valid SourceLocation.
+  if (ME->getMemberLoc().isValid())
+    return PathDiagnosticLocation(ME->getMemberLoc(), SM, SingleLocK);
+
+  return PathDiagnosticLocation(ME->getBeginLoc(), SM, SingleLocK);
+}
+
+PathDiagnosticLocation
+PathDiagnosticLocation::createBeginBrace(const CompoundStmt *CS,
+                                         const SourceManager &SM) {
+  SourceLocation L = CS->getLBracLoc();
+  return PathDiagnosticLocation(L, SM, SingleLocK);
+}
+
+PathDiagnosticLocation
+PathDiagnosticLocation::createEndBrace(const CompoundStmt *CS,
+                                       const SourceManager &SM) {
+  SourceLocation L = CS->getRBracLoc();
+  return PathDiagnosticLocation(L, SM, SingleLocK);
+}
+
+PathDiagnosticLocation
+PathDiagnosticLocation::createDeclBegin(const LocationContext *LC,
+                                        const SourceManager &SM) {
+  // FIXME: Should handle CXXTryStmt if analyser starts supporting C++.
+  if (const auto *CS = dyn_cast_or_null<CompoundStmt>(LC->getDecl()->getBody()))
+    if (!CS->body_empty()) {
+      SourceLocation Loc = (*CS->body_begin())->getBeginLoc();
+      return PathDiagnosticLocation(Loc, SM, SingleLocK);
+    }
+
+  return PathDiagnosticLocation();
+}
+
+PathDiagnosticLocation
+PathDiagnosticLocation::createDeclEnd(const LocationContext *LC,
+                                      const SourceManager &SM) {
+  SourceLocation L = LC->getDecl()->getBodyRBrace();
+  return PathDiagnosticLocation(L, SM, SingleLocK);
+}
+
+PathDiagnosticLocation
+PathDiagnosticLocation::create(const ProgramPoint& P,
+                               const SourceManager &SMng) {
+  const Stmt* S = nullptr;
+  if (Optional<BlockEdge> BE = P.getAs<BlockEdge>()) {
+    const CFGBlock *BSrc = BE->getSrc();
+    if (BSrc->getTerminator().isVirtualBaseBranch()) {
+      // TODO: VirtualBaseBranches should also appear for destructors.
+      // In this case we should put the diagnostic at the end of decl.
+      return PathDiagnosticLocation::createBegin(
+          P.getLocationContext()->getDecl(), SMng);
+
+    } else {
+      S = BSrc->getTerminatorCondition();
+      if (!S) {
+        // If the BlockEdge has no terminator condition statement but its
+        // source is the entry of the CFG (e.g. a checker crated the branch at
+        // the beginning of a function), use the function's declaration instead.
+        assert(BSrc == &BSrc->getParent()->getEntry() && "CFGBlock has no "
+               "TerminatorCondition and is not the enrty block of the CFG");
+        return PathDiagnosticLocation::createBegin(
+            P.getLocationContext()->getDecl(), SMng);
+      }
+    }
+  } else if (Optional<StmtPoint> SP = P.getAs<StmtPoint>()) {
+    S = SP->getStmt();
+    if (P.getAs<PostStmtPurgeDeadSymbols>())
+      return PathDiagnosticLocation::createEnd(S, SMng, P.getLocationContext());
+  } else if (Optional<PostInitializer> PIP = P.getAs<PostInitializer>()) {
+    return PathDiagnosticLocation(PIP->getInitializer()->getSourceLocation(),
+                                  SMng);
+  } else if (Optional<PreImplicitCall> PIC = P.getAs<PreImplicitCall>()) {
+    return PathDiagnosticLocation(PIC->getLocation(), SMng);
+  } else if (Optional<PostImplicitCall> PIE = P.getAs<PostImplicitCall>()) {
+    return PathDiagnosticLocation(PIE->getLocation(), SMng);
+  } else if (Optional<CallEnter> CE = P.getAs<CallEnter>()) {
+    return getLocationForCaller(CE->getCalleeContext(),
+                                CE->getLocationContext(),
+                                SMng);
+  } else if (Optional<CallExitEnd> CEE = P.getAs<CallExitEnd>()) {
+    return getLocationForCaller(CEE->getCalleeContext(),
+                                CEE->getLocationContext(),
+                                SMng);
+  } else if (auto CEB = P.getAs<CallExitBegin>()) {
+    if (const ReturnStmt *RS = CEB->getReturnStmt())
+      return PathDiagnosticLocation::createBegin(RS, SMng,
+                                                 CEB->getLocationContext());
+    return PathDiagnosticLocation(
+        CEB->getLocationContext()->getDecl()->getSourceRange().getEnd(), SMng);
+  } else if (Optional<BlockEntrance> BE = P.getAs<BlockEntrance>()) {
+    CFGElement BlockFront = BE->getBlock()->front();
+    if (auto StmtElt = BlockFront.getAs<CFGStmt>()) {
+      return PathDiagnosticLocation(StmtElt->getStmt()->getBeginLoc(), SMng);
+    } else if (auto NewAllocElt = BlockFront.getAs<CFGNewAllocator>()) {
+      return PathDiagnosticLocation(
+          NewAllocElt->getAllocatorExpr()->getBeginLoc(), SMng);
+    }
+    llvm_unreachable("Unexpected CFG element at front of block");
+  } else if (Optional<FunctionExitPoint> FE = P.getAs<FunctionExitPoint>()) {
+    return PathDiagnosticLocation(FE->getStmt(), SMng,
+                                  FE->getLocationContext());
+  } else {
+    llvm_unreachable("Unexpected ProgramPoint");
+  }
+
+  return PathDiagnosticLocation(S, SMng, P.getLocationContext());
+}
+
+PathDiagnosticLocation PathDiagnosticLocation::createSingleLocation(
+                                           const PathDiagnosticLocation &PDL) {
+  FullSourceLoc L = PDL.asLocation();
+  return PathDiagnosticLocation(L, L.getManager(), SingleLocK);
+}
+
+FullSourceLoc
+  PathDiagnosticLocation::genLocation(SourceLocation L,
+                                      LocationOrAnalysisDeclContext LAC) const {
+  assert(isValid());
+  // Note that we want a 'switch' here so that the compiler can warn us in
+  // case we add more cases.
+  switch (K) {
+    case SingleLocK:
+    case RangeK:
+      break;
+    case StmtK:
+      // Defensive checking.
+      if (!S)
+        break;
+      return FullSourceLoc(getValidSourceLocation(S, LAC),
+                           const_cast<SourceManager&>(*SM));
+    case DeclK:
+      // Defensive checking.
+      if (!D)
+        break;
+      return FullSourceLoc(D->getLocation(), const_cast<SourceManager&>(*SM));
+  }
+
+  return FullSourceLoc(L, const_cast<SourceManager&>(*SM));
+}
+
+PathDiagnosticRange
+  PathDiagnosticLocation::genRange(LocationOrAnalysisDeclContext LAC) const {
+  assert(isValid());
+  // Note that we want a 'switch' here so that the compiler can warn us in
+  // case we add more cases.
+  switch (K) {
+    case SingleLocK:
+      return PathDiagnosticRange(SourceRange(Loc,Loc), true);
+    case RangeK:
+      break;
+    case StmtK: {
+      const Stmt *S = asStmt();
+      switch (S->getStmtClass()) {
+        default:
+          break;
+        case Stmt::DeclStmtClass: {
+          const auto *DS = cast<DeclStmt>(S);
+          if (DS->isSingleDecl()) {
+            // Should always be the case, but we'll be defensive.
+            return SourceRange(DS->getBeginLoc(),
+                               DS->getSingleDecl()->getLocation());
+          }
+          break;
+        }
+          // FIXME: Provide better range information for different
+          //  terminators.
+        case Stmt::IfStmtClass:
+        case Stmt::WhileStmtClass:
+        case Stmt::DoStmtClass:
+        case Stmt::ForStmtClass:
+        case Stmt::ChooseExprClass:
+        case Stmt::IndirectGotoStmtClass:
+        case Stmt::SwitchStmtClass:
+        case Stmt::BinaryConditionalOperatorClass:
+        case Stmt::ConditionalOperatorClass:
+        case Stmt::ObjCForCollectionStmtClass: {
+          SourceLocation L = getValidSourceLocation(S, LAC);
+          return SourceRange(L, L);
+        }
+      }
+      SourceRange R = S->getSourceRange();
+      if (R.isValid())
+        return R;
+      break;
+    }
+    case DeclK:
+      if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
+        return MD->getSourceRange();
+      if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
+        if (Stmt *Body = FD->getBody())
+          return Body->getSourceRange();
+      }
+      else {
+        SourceLocation L = D->getLocation();
+        return PathDiagnosticRange(SourceRange(L, L), true);
+      }
+  }
+
+  return SourceRange(Loc, Loc);
+}
+
+void PathDiagnosticLocation::flatten() {
+  if (K == StmtK) {
+    K = RangeK;
+    S = nullptr;
+    D = nullptr;
+  }
+  else if (K == DeclK) {
+    K = SingleLocK;
+    S = nullptr;
+    D = nullptr;
+  }
+}
+
+//===----------------------------------------------------------------------===//
+// Manipulation of PathDiagnosticCallPieces.
+//===----------------------------------------------------------------------===//
+
+std::shared_ptr<PathDiagnosticCallPiece>
+PathDiagnosticCallPiece::construct(const CallExitEnd &CE,
+                                   const SourceManager &SM) {
+  const Decl *caller = CE.getLocationContext()->getDecl();
+  PathDiagnosticLocation pos = getLocationForCaller(CE.getCalleeContext(),
+                                                    CE.getLocationContext(),
+                                                    SM);
+  return std::shared_ptr<PathDiagnosticCallPiece>(
+      new PathDiagnosticCallPiece(caller, pos));
+}
+
+PathDiagnosticCallPiece *
+PathDiagnosticCallPiece::construct(PathPieces &path,
+                                   const Decl *caller) {
+  std::shared_ptr<PathDiagnosticCallPiece> C(
+      new PathDiagnosticCallPiece(path, caller));
+  path.clear();
+  auto *R = C.get();
+  path.push_front(std::move(C));
+  return R;
+}
+
+void PathDiagnosticCallPiece::setCallee(const CallEnter &CE,
+                                        const SourceManager &SM) {
+  const StackFrameContext *CalleeCtx = CE.getCalleeContext();
+  Callee = CalleeCtx->getDecl();
+
+  callEnterWithin = PathDiagnosticLocation::createBegin(Callee, SM);
+  callEnter = getLocationForCaller(CalleeCtx, CE.getLocationContext(), SM);
+
+  // Autosynthesized property accessors are special because we'd never
+  // pop back up to non-autosynthesized code until we leave them.
+  // This is not generally true for autosynthesized callees, which may call
+  // non-autosynthesized callbacks.
+  // Unless set here, the IsCalleeAnAutosynthesizedPropertyAccessor flag
+  // defaults to false.
+  if (const auto *MD = dyn_cast<ObjCMethodDecl>(Callee))
+    IsCalleeAnAutosynthesizedPropertyAccessor = (
+        MD->isPropertyAccessor() &&
+        CalleeCtx->getAnalysisDeclContext()->isBodyAutosynthesized());
+}
+
+static void describeTemplateParameters(raw_ostream &Out,
+                                       const ArrayRef<TemplateArgument> TAList,
+                                       const LangOptions &LO,
+                                       StringRef Prefix = StringRef(),
+                                       StringRef Postfix = StringRef());
+
+static void describeTemplateParameter(raw_ostream &Out,
+                                      const TemplateArgument &TArg,
+                                      const LangOptions &LO) {
+
+  if (TArg.getKind() == TemplateArgument::ArgKind::Pack) {
+    describeTemplateParameters(Out, TArg.getPackAsArray(), LO);
+  } else {
+    TArg.print(PrintingPolicy(LO), Out);
+  }
+}
+
+static void describeTemplateParameters(raw_ostream &Out,
+                                       const ArrayRef<TemplateArgument> TAList,
+                                       const LangOptions &LO,
+                                       StringRef Prefix, StringRef Postfix) {
+  if (TAList.empty())
+    return;
+
+  Out << Prefix;
+  for (int I = 0, Last = TAList.size() - 1; I != Last; ++I) {
+    describeTemplateParameter(Out, TAList[I], LO);
+    Out << ", ";
+  }
+  describeTemplateParameter(Out, TAList[TAList.size() - 1], LO);
+  Out << Postfix;
+}
+
+static void describeClass(raw_ostream &Out, const CXXRecordDecl *D,
+                          StringRef Prefix = StringRef()) {
+  if (!D->getIdentifier())
+    return;
+  Out << Prefix << '\'' << *D;
+  if (const auto T = dyn_cast<ClassTemplateSpecializationDecl>(D))
+    describeTemplateParameters(Out, T->getTemplateArgs().asArray(),
+                               D->getASTContext().getLangOpts(), "<", ">");
+
+  Out << '\'';
+}
+
+static bool describeCodeDecl(raw_ostream &Out, const Decl *D,
+                             bool ExtendedDescription,
+                             StringRef Prefix = StringRef()) {
+  if (!D)
+    return false;
+
+  if (isa<BlockDecl>(D)) {
+    if (ExtendedDescription)
+      Out << Prefix << "anonymous block";
+    return ExtendedDescription;
+  }
+
+  if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
+    Out << Prefix;
+    if (ExtendedDescription && !MD->isUserProvided()) {
+      if (MD->isExplicitlyDefaulted())
+        Out << "defaulted ";
+      else
+        Out << "implicit ";
+    }
+
+    if (const auto *CD = dyn_cast<CXXConstructorDecl>(MD)) {
+      if (CD->isDefaultConstructor())
+        Out << "default ";
+      else if (CD->isCopyConstructor())
+        Out << "copy ";
+      else if (CD->isMoveConstructor())
+        Out << "move ";
+
+      Out << "constructor";
+      describeClass(Out, MD->getParent(), " for ");
+    } else if (isa<CXXDestructorDecl>(MD)) {
+      if (!MD->isUserProvided()) {
+        Out << "destructor";
+        describeClass(Out, MD->getParent(), " for ");
+      } else {
+        // Use ~Foo for explicitly-written destructors.
+        Out << "'" << *MD << "'";
+      }
+    } else if (MD->isCopyAssignmentOperator()) {
+        Out << "copy assignment operator";
+        describeClass(Out, MD->getParent(), " for ");
+    } else if (MD->isMoveAssignmentOperator()) {
+        Out << "move assignment operator";
+        describeClass(Out, MD->getParent(), " for ");
+    } else {
+      if (MD->getParent()->getIdentifier())
+        Out << "'" << *MD->getParent() << "::" << *MD << "'";
+      else
+        Out << "'" << *MD << "'";
+    }
+
+    return true;
+  }
+
+  Out << Prefix << '\'' << cast<NamedDecl>(*D);
+
+  // Adding template parameters.
+  if (const auto FD = dyn_cast<FunctionDecl>(D))
+    if (const TemplateArgumentList *TAList =
+                                    FD->getTemplateSpecializationArgs())
+      describeTemplateParameters(Out, TAList->asArray(),
+                                 FD->getASTContext().getLangOpts(), "<", ">");
+
+  Out << '\'';
+  return true;
+}
+
+std::shared_ptr<PathDiagnosticEventPiece>
+PathDiagnosticCallPiece::getCallEnterEvent() const {
+  // We do not produce call enters and call exits for autosynthesized property
+  // accessors. We do generally produce them for other functions coming from
+  // the body farm because they may call callbacks that bring us back into
+  // visible code.
+  if (!Callee || IsCalleeAnAutosynthesizedPropertyAccessor)
+    return nullptr;
+
+  SmallString<256> buf;
+  llvm::raw_svector_ostream Out(buf);
+
+  Out << "Calling ";
+  describeCodeDecl(Out, Callee, /*ExtendedDescription=*/true);
+
+  assert(callEnter.asLocation().isValid());
+  return std::make_shared<PathDiagnosticEventPiece>(callEnter, Out.str());
+}
+
+std::shared_ptr<PathDiagnosticEventPiece>
+PathDiagnosticCallPiece::getCallEnterWithinCallerEvent() const {
+  if (!callEnterWithin.asLocation().isValid())
+    return nullptr;
+  if (Callee->isImplicit() || !Callee->hasBody())
+    return nullptr;
+  if (const auto *MD = dyn_cast<CXXMethodDecl>(Callee))
+    if (MD->isDefaulted())
+      return nullptr;
+
+  SmallString<256> buf;
+  llvm::raw_svector_ostream Out(buf);
+
+  Out << "Entered call";
+  describeCodeDecl(Out, Caller, /*ExtendedDescription=*/false, " from ");
+
+  return std::make_shared<PathDiagnosticEventPiece>(callEnterWithin, Out.str());
+}
+
+std::shared_ptr<PathDiagnosticEventPiece>
+PathDiagnosticCallPiece::getCallExitEvent() const {
+  // We do not produce call enters and call exits for autosynthesized property
+  // accessors. We do generally produce them for other functions coming from
+  // the body farm because they may call callbacks that bring us back into
+  // visible code.
+  if (NoExit || IsCalleeAnAutosynthesizedPropertyAccessor)
+    return nullptr;
+
+  SmallString<256> buf;
+  llvm::raw_svector_ostream Out(buf);
+
+  if (!CallStackMessage.empty()) {
+    Out << CallStackMessage;
+  } else {
+    bool DidDescribe = describeCodeDecl(Out, Callee,
+                                        /*ExtendedDescription=*/false,
+                                        "Returning from ");
+    if (!DidDescribe)
+      Out << "Returning to caller";
+  }
+
+  assert(callReturn.asLocation().isValid());
+  return std::make_shared<PathDiagnosticEventPiece>(callReturn, Out.str());
+}
+
+static void compute_path_size(const PathPieces &pieces, unsigned &size) {
+  for (const auto &I : pieces) {
+    const PathDiagnosticPiece *piece = I.get();
+    if (const auto *cp = dyn_cast<PathDiagnosticCallPiece>(piece))
+      compute_path_size(cp->path, size);
+    else
+      ++size;
+  }
+}
+
+unsigned PathDiagnostic::full_size() {
+  unsigned size = 0;
+  compute_path_size(path, size);
+  return size;
+}
+
+//===----------------------------------------------------------------------===//
+// FoldingSet profiling methods.
+//===----------------------------------------------------------------------===//
+
+void PathDiagnosticLocation::Profile(llvm::FoldingSetNodeID &ID) const {
+  ID.AddInteger(Range.getBegin().getRawEncoding());
+  ID.AddInteger(Range.getEnd().getRawEncoding());
+  ID.AddInteger(Loc.getRawEncoding());
+}
+
+void PathDiagnosticPiece::Profile(llvm::FoldingSetNodeID &ID) const {
+  ID.AddInteger((unsigned) getKind());
+  ID.AddString(str);
+  // FIXME: Add profiling support for code hints.
+  ID.AddInteger((unsigned) getDisplayHint());
+  ArrayRef<SourceRange> Ranges = getRanges();
+  for (const auto &I : Ranges) {
+    ID.AddInteger(I.getBegin().getRawEncoding());
+    ID.AddInteger(I.getEnd().getRawEncoding());
+  }
+}
+
+void PathDiagnosticCallPiece::Profile(llvm::FoldingSetNodeID &ID) const {
+  PathDiagnosticPiece::Profile(ID);
+  for (const auto &I : path)
+    ID.Add(*I);
+}
+
+void PathDiagnosticSpotPiece::Profile(llvm::FoldingSetNodeID &ID) const {
+  PathDiagnosticPiece::Profile(ID);
+  ID.Add(Pos);
+}
+
+void PathDiagnosticControlFlowPiece::Profile(llvm::FoldingSetNodeID &ID) const {
+  PathDiagnosticPiece::Profile(ID);
+  for (const auto &I : *this)
+    ID.Add(I);
+}
+
+void PathDiagnosticMacroPiece::Profile(llvm::FoldingSetNodeID &ID) const {
+  PathDiagnosticSpotPiece::Profile(ID);
+  for (const auto &I : subPieces)
+    ID.Add(*I);
+}
+
+void PathDiagnosticNotePiece::Profile(llvm::FoldingSetNodeID &ID) const {
+  PathDiagnosticSpotPiece::Profile(ID);
+}
+
+void PathDiagnosticPopUpPiece::Profile(llvm::FoldingSetNodeID &ID) const {
+  PathDiagnosticSpotPiece::Profile(ID);
+}
+
+void PathDiagnostic::Profile(llvm::FoldingSetNodeID &ID) const {
+  ID.Add(getLocation());
+  ID.AddString(BugType);
+  ID.AddString(VerboseDesc);
+  ID.AddString(Category);
+}
+
+void PathDiagnostic::FullProfile(llvm::FoldingSetNodeID &ID) const {
+  Profile(ID);
+  for (const auto &I : path)
+    ID.Add(*I);
+  for (meta_iterator I = meta_begin(), E = meta_end(); I != E; ++I)
+    ID.AddString(*I);
+}
+
+LLVM_DUMP_METHOD void PathPieces::dump() const {
+  unsigned index = 0;
+  for (PathPieces::const_iterator I = begin(), E = end(); I != E; ++I) {
+    llvm::errs() << "[" << index++ << "]  ";
+    (*I)->dump();
+    llvm::errs() << "\n";
+  }
+}
+
+LLVM_DUMP_METHOD void PathDiagnosticCallPiece::dump() const {
+  llvm::errs() << "CALL\n--------------\n";
+
+  if (const Stmt *SLoc = getLocation().getStmtOrNull())
+    SLoc->dump();
+  else if (const auto *ND = dyn_cast_or_null<NamedDecl>(getCallee()))
+    llvm::errs() << *ND << "\n";
+  else
+    getLocation().dump();
+}
+
+LLVM_DUMP_METHOD void PathDiagnosticEventPiece::dump() const {
+  llvm::errs() << "EVENT\n--------------\n";
+  llvm::errs() << getString() << "\n";
+  llvm::errs() << " ---- at ----\n";
+  getLocation().dump();
+}
+
+LLVM_DUMP_METHOD void PathDiagnosticControlFlowPiece::dump() const {
+  llvm::errs() << "CONTROL\n--------------\n";
+  getStartLocation().dump();
+  llvm::errs() << " ---- to ----\n";
+  getEndLocation().dump();
+}
+
+LLVM_DUMP_METHOD void PathDiagnosticMacroPiece::dump() const {
+  llvm::errs() << "MACRO\n--------------\n";
+  // FIXME: Print which macro is being invoked.
+}
+
+LLVM_DUMP_METHOD void PathDiagnosticNotePiece::dump() const {
+  llvm::errs() << "NOTE\n--------------\n";
+  llvm::errs() << getString() << "\n";
+  llvm::errs() << " ---- at ----\n";
+  getLocation().dump();
+}
+
+LLVM_DUMP_METHOD void PathDiagnosticPopUpPiece::dump() const {
+  llvm::errs() << "POP-UP\n--------------\n";
+  llvm::errs() << getString() << "\n";
+  llvm::errs() << " ---- at ----\n";
+  getLocation().dump();
+}
+
+LLVM_DUMP_METHOD void PathDiagnosticLocation::dump() const {
+  if (!isValid()) {
+    llvm::errs() << "<INVALID>\n";
+    return;
+  }
+
+  switch (K) {
+  case RangeK:
+    // FIXME: actually print the range.
+    llvm::errs() << "<range>\n";
+    break;
+  case SingleLocK:
+    asLocation().dump();
+    llvm::errs() << "\n";
+    break;
+  case StmtK:
+    if (S)
+      S->dump();
+    else
+      llvm::errs() << "<NULL STMT>\n";
+    break;
+  case DeclK:
+    if (const auto *ND = dyn_cast_or_null<NamedDecl>(D))
+      llvm::errs() << *ND << "\n";
+    else if (isa<BlockDecl>(D))
+      // FIXME: Make this nicer.
+      llvm::errs() << "<block>\n";
+    else if (D)
+      llvm::errs() << "<unknown decl>\n";
+    else
+      llvm::errs() << "<NULL DECL>\n";
+    break;
+  }
+}

cfe/trunk/lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp

 //  This checker only warns for instance variables synthesized to back
 //  properties. Handling the more general case would require inferring whether
 //  an instance variable is stored retained or not. For synthesized properties,
 //  this is specified in the property declaration itself.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
+#include "clang/Analysis/PathDiagnostic.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
-#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
 #include "clang/StaticAnalyzer/Core/Checker.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h"
 #include "llvm/Support/raw_ostream.h"

cfe/trunk/lib/StaticAnalyzer/Checkers/CheckObjCInstMethSignature.cpp

 //===-- CheckObjCInstMethSignature.cpp - Check ObjC method signatures -----===//
 //
 // 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 a CheckObjCInstMethSignature, a flow-insenstive check
 //  that determines if an Objective-C class interface incorrectly redefines
 //  the method signature in a subclass.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
+#include "clang/Analysis/PathDiagnostic.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/Type.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
-#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
 #include "clang/StaticAnalyzer/Core/Checker.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang;
 using namespace ento;
 
 static bool AreTypesCompatible(QualType Derived, QualType Ancestor,

cfe/trunk/lib/StaticAnalyzer/Checkers/ObjCMissingSuperCallChecker.cpp

 //==- ObjCMissingSuperCallChecker.cpp - Check missing super-calls in ObjC --==//
 //
 // 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 a ObjCMissingSuperCallChecker, a checker that
 //  analyzes a UIViewController implementation to determine if it
 //  correctly calls super in the methods where this is mandatory.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
+#include "clang/Analysis/PathDiagnostic.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
-#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
 #include "clang/StaticAnalyzer/Core/Checker.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang;
 using namespace ento;

cfe/trunk/lib/StaticAnalyzer/Checkers/ObjCUnusedIVarsChecker.cpp

 //==- ObjCUnusedIVarsChecker.cpp - Check for unused ivars --------*- 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 a CheckObjCUnusedIvars, a checker that
 //  analyzes an Objective-C class's interface/implementation to determine if it
 //  has any ivars that are never accessed.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
+#include "clang/Analysis/PathDiagnostic.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
-#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
 #include "clang/StaticAnalyzer/Core/Checker.h"
 
 using namespace clang;
 using namespace ento;
 
 enum IVarState { Unused, Used };
 typedef llvm::DenseMap<const ObjCIvarDecl*,IVarState> IvarUsageMap;
 

cfe/trunk/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.h

 
 #include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
 #include "RetainCountDiagnostics.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/ParentMap.h"
 #include "clang/Analysis/DomainSpecific/CocoaConventions.h"
+#include "clang/Analysis/PathDiagnostic.h"
 #include "clang/Analysis/RetainSummaryManager.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Analysis/SelectorExtras.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
-#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
 #include "clang/StaticAnalyzer/Core/Checker.h"
 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/FoldingSet.h"

cfe/trunk/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.h

 //== RetainCountDiagnostics.h - Checks for leaks and other issues -*- 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 diagnostics for RetainCountChecker, which implements
 //  a reference count checker for Core Foundation and Cocoa on (Mac OS X).
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_RETAINCOUNTCHECKER_DIAGNOSTICS_H
 #define LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_RETAINCOUNTCHECKER_DIAGNOSTICS_H
 
+#include "clang/Analysis/PathDiagnostic.h"
 #include "clang/Analysis/RetainSummaryManager.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h"
-#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
 
 namespace clang {
 namespace ento {
 namespace retaincountchecker {
 
 class RefCountBug : public BugType {
 public:

cfe/trunk/lib/StaticAnalyzer/Core/BugReporter.cpp

 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ParentMap.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/StmtCXX.h"
 #include "clang/AST/StmtObjC.h"
 #include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Analysis/CFG.h"
 #include "clang/Analysis/CFGStmtMap.h"
+#include "clang/Analysis/PathDiagnostic.h"
 #include "clang/Analysis/ProgramPoint.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
-#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
 #include "clang/StaticAnalyzer/Core/Checker.h"
 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h"

cfe/trunk/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/Type.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Analysis/Analyses/Dominators.h"
 #include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Analysis/CFG.h"
 #include "clang/Analysis/CFGStmtMap.h"
+#include "clang/Analysis/PathDiagnostic.h"
 #include "clang/Analysis/ProgramPoint.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
-#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState_Fwd.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SMTConv.h"

cfe/trunk/lib/StaticAnalyzer/Core/CMakeLists.txt

add_clang_library(clangStaticAnalyzerCore
   ExprEngineCallAndReturn.cpp
   ExprEngineObjC.cpp
   FunctionSummary.cpp
   HTMLDiagnostics.cpp
   IssueHash.cpp
   LoopUnrolling.cpp
   LoopWidening.cpp
   MemRegion.cpp
-  PathDiagnostic.cpp
   PlistDiagnostics.cpp
   ProgramState.cpp
   RangeConstraintManager.cpp
   RangedConstraintManager.cpp
   RegionStore.cpp
   SarifDiagnostics.cpp
   SimpleConstraintManager.cpp
   SimpleSValBuilder.cpp

cfe/trunk/lib/StaticAnalyzer/Core/CallEvent.cpp

 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/ParentMap.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/Type.h"
 #include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Analysis/CFG.h"
 #include "clang/Analysis/CFGStmtMap.h"
+#include "clang/Analysis/PathDiagnostic.h"
 #include "clang/Analysis/ProgramPoint.h"
 #include "clang/CrossTU/CrossTranslationUnit.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/Specifiers.h"
-#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/DynamicTypeInfo.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/DynamicType.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState_Fwd.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h"

cfe/trunk/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp

 //===- HTMLDiagnostics.cpp - HTML Diagnostics for Paths -------------------===//
 //
 // 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 HTMLDiagnostics object.
 //
 //===----------------------------------------------------------------------===//
 
+#include "clang/Analysis/PathDiagnostic.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/AST/Stmt.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/Token.h"
 #include "clang/Rewrite/Core/HTMLRewrite.h"
 #include "clang/Rewrite/Core/Rewriter.h"
 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
-#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
 #include "clang/StaticAnalyzer/Core/IssueHash.h"
 #include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Errc.h"

cfe/trunk/lib/StaticAnalyzer/Core/PathDiagnostic.cpp

-//===- PathDiagnostic.cpp - Path-Specific Diagnostic Handling -------------===//
-//
-// 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.
-//
-//===----------------------------------------------------------------------===//
-
-#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
-#include "clang/AST/Decl.h"
-#include "clang/AST/DeclBase.h"
-#include "clang/AST/DeclCXX.h"
-#include "clang/AST/DeclObjC.h"
-#include "clang/AST/DeclTemplate.h"
-#include "clang/AST/Expr.h"
-#include "clang/AST/ExprCXX.h"
-#include "clang/AST/OperationKinds.h"
-#include "clang/AST/ParentMap.h"
-#include "clang/AST/Stmt.h"
-#include "clang/AST/Type.h"
-#include "clang/Analysis/AnalysisDeclContext.h"
-#include "clang/Analysis/CFG.h"
-#include "clang/Analysis/ProgramPoint.h"
-#include "clang/Basic/FileManager.h"
-#include "clang/Basic/LLVM.h"
-#include "clang/Basic/SourceLocation.h"
-#include "clang/Basic/SourceManager.h"
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/FoldingSet.h"
-#include "llvm/ADT/None.h"
-#include "llvm/ADT/Optional.h"
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/SmallString.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringExtras.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/Casting.h"
-#include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/raw_ostream.h"
-#include <cassert>
-#include <cstring>
-#include <memory>
-#include <utility>
-#include <vector>
-
-using namespace clang;
-using namespace ento;
-
-static StringRef StripTrailingDots(StringRef s) {
-  for (StringRef::size_type i = s.size(); i != 0; --i)
-    if (s[i - 1] != '.')
-      return s.substr(0, i);
-  return {};
-}
-
-PathDiagnosticPiece::PathDiagnosticPiece(StringRef s,
-                                         Kind k, DisplayHint hint)
-    : str(StripTrailingDots(s)), kind(k), Hint(hint) {}
-
-PathDiagnosticPiece::PathDiagnosticPiece(Kind k, DisplayHint hint)
-    : kind(k), Hint(hint) {}
-
-PathDiagnosticPiece::~PathDiagnosticPiece() = default;
-
-PathDiagnosticEventPiece::~PathDiagnosticEventPiece() = default;
-
-PathDiagnosticCallPiece::~PathDiagnosticCallPiece() = default;
-
-PathDiagnosticControlFlowPiece::~PathDiagnosticControlFlowPiece() = default;
-
-PathDiagnosticMacroPiece::~PathDiagnosticMacroPiece() = default;
-
-PathDiagnosticNotePiece::~PathDiagnosticNotePiece() = default;
-
-PathDiagnosticPopUpPiece::~PathDiagnosticPopUpPiece() = default;
-
-void PathPieces::flattenTo(PathPieces &Primary, PathPieces &Current,
-                           bool ShouldFlattenMacros) const {
-  for (auto &Piece : *this) {
-    switch (Piece->getKind()) {
-    case PathDiagnosticPiece::Call: {
-      auto &Call = cast<PathDiagnosticCallPiece>(*Piece);
-      if (auto CallEnter = Call.getCallEnterEvent())
-        Current.push_back(std::move(CallEnter));
-      Call.path.flattenTo(Primary, Primary, ShouldFlattenMacros);
-      if (auto callExit = Call.getCallExitEvent())
-        Current.push_back(std::move(callExit));
-      break;
-    }
-    case PathDiagnosticPiece::Macro: {
-      auto &Macro = cast<PathDiagnosticMacroPiece>(*Piece);
-      if (ShouldFlattenMacros) {
-        Macro.subPieces.flattenTo(Primary, Primary, ShouldFlattenMacros);
-      } else {
-        Current.push_back(Piece);
-        PathPieces NewPath;
-        Macro.subPieces.flattenTo(Primary, NewPath, ShouldFlattenMacros);
-        // FIXME: This probably shouldn't mutate the original path piece.
-        Macro.subPieces = NewPath;
-      }
-      break;
-    }
-    case PathDiagnosticPiece::Event:
-    case PathDiagnosticPiece::ControlFlow:
-    case PathDiagnosticPiece::Note:
-    case PathDiagnosticPiece::PopUp:
-      Current.push_back(Piece);
-      break;
-    }
-  }
-}
-
-PathDiagnostic::~PathDiagnostic() = default;
-
-PathDiagnostic::PathDiagnostic(
-    StringRef CheckName, const Decl *declWithIssue, StringRef bugtype,
-    StringRef verboseDesc, StringRef shortDesc, StringRef category,
-    PathDiagnosticLocation LocationToUnique, const Decl *DeclToUnique,
-    std::unique_ptr<FilesToLineNumsMap> ExecutedLines)
-    : CheckName(CheckName), DeclWithIssue(declWithIssue),
-      BugType(StripTrailingDots(bugtype)),
-      VerboseDesc(StripTrailingDots(verboseDesc)),
-      ShortDesc(StripTrailingDots(shortDesc)),
-      Category(StripTrailingDots(category)), UniqueingLoc(LocationToUnique),
-      UniqueingDecl(DeclToUnique), ExecutedLines(std::move(ExecutedLines)),
-      path(pathImpl) {}
-
-void PathDiagnosticConsumer::anchor() {}
-
-PathDiagnosticConsumer::~PathDiagnosticConsumer() {
-  // Delete the contents of the FoldingSet if it isn't empty already.
-  for (auto &Diag : Diags)
-    delete &Diag;
-}
-
-void PathDiagnosticConsumer::HandlePathDiagnostic(
-    std::unique_ptr<PathDiagnostic> D) {
-  if (!D || D->path.empty())
-    return;
-
-  // We need to flatten the locations (convert Stmt* to locations) because
-  // the referenced statements may be freed by the time the diagnostics
-  // are emitted.
-  D->flattenLocations();
-
-  // If the PathDiagnosticConsumer does not support diagnostics that
-  // cross file boundaries, prune out such diagnostics now.
-  if (!supportsCrossFileDiagnostics()) {
-    // Verify that the entire path is from the same FileID.
-    FileID FID;
-    const SourceManager &SMgr = D->path.front()->getLocation().getManager();
-    SmallVector<const PathPieces *, 5> WorkList;
-    WorkList.push_back(&D->path);
-    SmallString<128> buf;
-    llvm::raw_svector_ostream warning(buf);
-    warning << "warning: Path diagnostic report is not generated. Current "
-            << "output format does not support diagnostics that cross file "
-            << "boundaries. Refer to --analyzer-output for valid output "
-            << "formats\n";
-
-    while (!WorkList.empty()) {
-      const PathPieces &path = *WorkList.pop_back_val();
-
-      for (const auto &I : path) {
-        const PathDiagnosticPiece *piece = I.get();
-        FullSourceLoc L = piece->getLocation().asLocation().getExpansionLoc();
-
-        if (FID.isInvalid()) {
-          FID = SMgr.getFileID(L);
-        } else if (SMgr.getFileID(L) != FID) {
-          llvm::errs() << warning.str();
-          return;
-        }
-
-        // Check the source ranges.
-        ArrayRef<SourceRange> Ranges = piece->getRanges();
-        for (const auto &I : Ranges) {
-          SourceLocation L = SMgr.getExpansionLoc(I.getBegin());
-          if (!L.isFileID() || SMgr.getFileID(L) != FID) {
-            llvm::errs() << warning.str();
-            return;
-          }
-          L = SMgr.getExpansionLoc(I.getEnd());
-          if (!L.isFileID() || SMgr.getFileID(L) != FID) {
-            llvm::errs() << warning.str();
-            return;
-          }
-        }
-
-        if (const auto *call = dyn_cast<PathDiagnosticCallPiece>(piece))
-          WorkList.push_back(&call->path);
-        else if (const auto *macro = dyn_cast<PathDiagnosticMacroPiece>(piece))
-          WorkList.push_back(&macro->subPieces);
-      }
-    }
-
-    if (FID.isInvalid())
-      return; // FIXME: Emit a warning?
-  }
-
-  // Profile the node to see if we already have something matching it
-  llvm::FoldingSetNodeID profile;
-  D->Profile(profile);
-  void *InsertPos = nullptr;
-
-  if (PathDiagnostic *orig = Diags.FindNodeOrInsertPos(profile, InsertPos)) {
-    // Keep the PathDiagnostic with the shorter path.
-    // Note, the enclosing routine is called in deterministic order, so the
-    // results will be consistent between runs (no reason to break ties if the
-    // size is the same).
-    const unsigned orig_size = orig->full_size();
-    const unsigned new_size = D->full_size();
-    if (orig_size <= new_size)
-      return;
-
-    assert(orig != D.get());
-    Diags.RemoveNode(orig);
-    delete orig;
-  }
-
-  Diags.InsertNode(D.release());
-}
-
-static Optional<bool> comparePath(const PathPieces &X, const PathPieces &Y);
-
-static Optional<bool>
-compareControlFlow(const PathDiagnosticControlFlowPiece &X,
-                   const PathDiagnosticControlFlowPiece &Y) {
-  FullSourceLoc XSL = X.getStartLocation().asLocation();
-  FullSourceLoc YSL = Y.getStartLocation().asLocation();
-  if (XSL != YSL)
-    return XSL.isBeforeInTranslationUnitThan(YSL);
-  FullSourceLoc XEL = X.getEndLocation().asLocation();
-  FullSourceLoc YEL = Y.getEndLocation().asLocation();
-  if (XEL != YEL)
-    return XEL.isBeforeInTranslationUnitThan(YEL);
-  return None;
-}
-
-static Optional<bool> compareMacro(const PathDiagnosticMacroPiece &X,
-                                   const PathDiagnosticMacroPiece &Y) {
-  return comparePath(X.subPieces, Y.subPieces);
-}
-
-static Optional<bool> compareCall(const PathDiagnosticCallPiece &X,
-                                  const PathDiagnosticCallPiece &Y) {
-  FullSourceLoc X_CEL = X.callEnter.asLocation();
-  FullSourceLoc Y_CEL = Y.callEnter.asLocation();
-  if (X_CEL != Y_CEL)
-    return X_CEL.isBeforeInTranslationUnitThan(Y_CEL);
-  FullSourceLoc X_CEWL = X.callEnterWithin.asLocation();
-  FullSourceLoc Y_CEWL = Y.callEnterWithin.asLocation();
-  if (X_CEWL != Y_CEWL)
-    return X_CEWL.isBeforeInTranslationUnitThan(Y_CEWL);
-  FullSourceLoc X_CRL = X.callReturn.asLocation();
-  FullSourceLoc Y_CRL = Y.callReturn.asLocation();
-  if (X_CRL != Y_CRL)
-    return X_CRL.isBeforeInTranslationUnitThan(Y_CRL);
-  return comparePath(X.path, Y.path);
-}
-
-static Optional<bool> comparePiece(const PathDiagnosticPiece &X,
-                                   const PathDiagnosticPiece &Y) {
-  if (X.getKind() != Y.getKind())
-    return X.getKind() < Y.getKind();
-
-  FullSourceLoc XL = X.getLocation().asLocation();
-  FullSourceLoc YL = Y.getLocation().asLocation();
-  if (XL != YL)
-    return XL.isBeforeInTranslationUnitThan(YL);
-
-  if (X.getString() != Y.getString())
-    return X.getString() < Y.getString();
-
-  if (X.getRanges().size() != Y.getRanges().size())
-    return X.getRanges().size() < Y.getRanges().size();
-
-  const SourceManager &SM = XL.getManager();
-
-  for (unsigned i = 0, n = X.getRanges().size(); i < n; ++i) {
-    SourceRange XR = X.getRanges()[i];
-    SourceRange YR = Y.getRanges()[i];
-    if (XR != YR) {
-      if (XR.getBegin() != YR.getBegin())
-        return SM.isBeforeInTranslationUnit(XR.getBegin(), YR.getBegin());
-      return SM.isBeforeInTranslationUnit(XR.getEnd(), YR.getEnd());
-    }
-  }
-
-  switch (X.getKind()) {
-    case PathDiagnosticPiece::ControlFlow:
-      return compareControlFlow(cast<PathDiagnosticControlFlowPiece>(X),
-                                cast<PathDiagnosticControlFlowPiece>(Y));
-    case PathDiagnosticPiece::Macro:
-      return compareMacro(cast<PathDiagnosticMacroPiece>(X),
-                          cast<PathDiagnosticMacroPiece>(Y));
-    case PathDiagnosticPiece::Call:
-      return compareCall(cast<PathDiagnosticCallPiece>(X),
-                         cast<PathDiagnosticCallPiece>(Y));
-    case PathDiagnosticPiece::Event:
-    case PathDiagnosticPiece::Note:
-    case PathDiagnosticPiece::PopUp:
-      return None;
-  }
-  llvm_unreachable("all cases handled");
-}
-
-static Optional<bool> comparePath(const PathPieces &X, const PathPieces &Y) {
-  if (X.size() != Y.size())
-    return X.size() < Y.size();
-
-  PathPieces::const_iterator X_I = X.begin(), X_end = X.end();
-  PathPieces::const_iterator Y_I = Y.begin(), Y_end = Y.end();
-
-  for ( ; X_I != X_end && Y_I != Y_end; ++X_I, ++Y_I) {
-    Optional<bool> b = comparePiece(**X_I, **Y_I);
-    if (b.hasValue())
-      return b.getValue();
-  }
-
-  return None;
-}
-
-static bool compareCrossTUSourceLocs(FullSourceLoc XL, FullSourceLoc YL) {
-  std::pair<FileID, unsigned> XOffs = XL.getDecomposedLoc();
-  std::pair<FileID, unsigned> YOffs = YL.getDecomposedLoc();
-  const SourceManager &SM = XL.getManager();
-  std::pair<bool, bool> InSameTU = SM.isInTheSameTranslationUnit(XOffs, YOffs);
-  if (InSameTU.first)
-    return XL.isBeforeInTranslationUnitThan(YL);
-  const FileEntry *XFE = SM.getFileEntryForID(XL.getSpellingLoc().getFileID());
-  const FileEntry *YFE = SM.getFileEntryForID(YL.getSpellingLoc().getFileID());
-  if (!XFE || !YFE)
-    return XFE && !YFE;
-  int NameCmp = XFE->getName().compare(YFE->getName());
-  if (NameCmp != 0)
-    return NameCmp == -1;
-  // Last resort: Compare raw file IDs that are possibly expansions.
-  return XL.getFileID() < YL.getFileID();
-}
-
-static bool compare(const PathDiagnostic &X, const PathDiagnostic &Y) {
-  FullSourceLoc XL = X.getLocation().asLocation();
-  FullSourceLoc YL = Y.getLocation().asLocation();
-  if (XL != YL)
-    return compareCrossTUSourceLocs(XL, YL);
-  if (X.getBugType() != Y.getBugType())
-    return X.getBugType() < Y.getBugType();
-  if (X.getCategory() != Y.getCategory())
-    return X.getCategory() < Y.getCategory();
-  if (X.getVerboseDescription() != Y.getVerboseDescription())
-    return X.getVerboseDescription() < Y.getVerboseDescription();
-  if (X.getShortDescription() != Y.getShortDescription())
-    return X.getShortDescription() < Y.getShortDescription();
-  if (X.getDeclWithIssue() != Y.getDeclWithIssue()) {
-    const Decl *XD = X.getDeclWithIssue();
-    if (!XD)
-      return true;
-    const Decl *YD = Y.getDeclWithIssue();
-    if (!YD)
-      return false;
-    SourceLocation XDL = XD->getLocation();
-    SourceLocation YDL = YD->getLocation();
-    if (XDL != YDL) {
-      const SourceManager &SM = XL.getManager();
-      return compareCrossTUSourceLocs(FullSourceLoc(XDL, SM),
-                                      FullSourceLoc(YDL, SM));
-    }
-  }
-  PathDiagnostic::meta_iterator XI = X.meta_begin(), XE = X.meta_end();
-  PathDiagnostic::meta_iterator YI = Y.meta_begin(), YE = Y.meta_end();
-  if (XE - XI != YE - YI)
-    return (XE - XI) < (YE - YI);
-  for ( ; XI != XE ; ++XI, ++YI) {
-    if (*XI != *YI)
-      return (*XI) < (*YI);
-  }
-  Optional<bool> b = comparePath(X.path, Y.path);
-  assert(b.hasValue());
-  return b.getValue();
-}
-
-void PathDiagnosticConsumer::FlushDiagnostics(
-                                     PathDiagnosticConsumer::FilesMade *Files) {
-  if (flushed)
-    return;
-
-  flushed = true;
-
-  std::vector<const PathDiagnostic *> BatchDiags;
-  for (const auto &D : Diags)
-    BatchDiags.push_back(&D);
-
-  // Sort the diagnostics so that they are always emitted in a deterministic
-  // order.
-  int (*Comp)(const PathDiagnostic *const *, const PathDiagnostic *const *) =
-      [](const PathDiagnostic *const *X, const PathDiagnostic *const *Y) {
-        assert(*X != *Y && "PathDiagnostics not uniqued!");
-        if (compare(**X, **Y))
-          return -1;
-        assert(compare(**Y, **X) && "Not a total order!");
-        return 1;
-      };
-  array_pod_sort(BatchDiags.begin(), BatchDiags.end(), Comp);
-
-  FlushDiagnosticsImpl(BatchDiags, Files);
-
-  // Delete the flushed diagnostics.
-  for (const auto D : BatchDiags)
-    delete D;
-
-  // Clear out the FoldingSet.
-  Diags.clear();
-}
-
-PathDiagnosticConsumer::FilesMade::~FilesMade() {
-  for (PDFileEntry &Entry : Set)
-    Entry.~PDFileEntry();
-}
-
-void PathDiagnosticConsumer::FilesMade::addDiagnostic(const PathDiagnostic &PD,
-                                                      StringRef ConsumerName,
-                                                      StringRef FileName) {
-  llvm::FoldingSetNodeID NodeID;
-  NodeID.Add(PD);
-  void *InsertPos;
-  PDFileEntry *Entry = Set.FindNodeOrInsertPos(NodeID, InsertPos);
-  if (!Entry) {
-    Entry = Alloc.Allocate<PDFileEntry>();
-    Entry = new (Entry) PDFileEntry(NodeID);
-    Set.InsertNode(Entry, InsertPos);
-  }
-
-  // Allocate persistent storage for the file name.
-  char *FileName_cstr = (char*) Alloc.Allocate(FileName.size(), 1);
-  memcpy(FileName_cstr, FileName.data(), FileName.size());
-
-  Entry->files.push_back(std::make_pair(ConsumerName,
-                                        StringRef(FileName_cstr,
-                                                  FileName.size())));
-}
-
-PathDiagnosticConsumer::PDFileEntry::ConsumerFiles *
-PathDiagnosticConsumer::FilesMade::getFiles(const PathDiagnostic &PD) {
-  llvm::FoldingSetNodeID NodeID;
-  NodeID.Add(PD);
-  void *InsertPos;
-  PDFileEntry *Entry = Set.FindNodeOrInsertPos(NodeID, InsertPos);
-  if (!Entry)
-    return nullptr;
-  return &Entry->files;
-}
-
-//===----------------------------------------------------------------------===//
-// PathDiagnosticLocation methods.
-//===----------------------------------------------------------------------===//
-
-SourceLocation PathDiagnosticLocation::getValidSourceLocation(
-    const Stmt *S, LocationOrAnalysisDeclContext LAC, bool UseEndOfStatement) {
-  SourceLocation L = UseEndOfStatement ? S->getEndLoc() : S->getBeginLoc();
-  assert(!LAC.isNull() &&
-         "A valid LocationContext or AnalysisDeclContext should be passed to "
-         "PathDiagnosticLocation upon creation.");
-
-  // S might be a temporary statement that does not have a location in the
-  // source code, so find an enclosing statement and use its location.
-  if (!L.isValid()) {
-    AnalysisDeclContext *ADC;
-    if (LAC.is<const LocationContext*>())
-      ADC = LAC.get<const LocationContext*>()->getAnalysisDeclContext();
-    else
-      ADC = LAC.get<AnalysisDeclContext*>();
-
-    ParentMap &PM = ADC->getParentMap();
-
-    const Stmt *Parent = S;
-    do {
-      Parent = PM.getParent(Parent);
-
-      // In rare cases, we have implicit top-level expressions,
-      // such as arguments for implicit member initializers.
-      // In this case, fall back to the start of the body (even if we were
-      // asked for the statement end location).
-      if (!Parent) {
-        const Stmt *Body = ADC->getBody();
-        if (Body)
-          L = Body->getBeginLoc();
-        else
-          L = ADC->getDecl()->getEndLoc();
-        break;
-      }
-
-      L = UseEndOfStatement ? Parent->getEndLoc() : Parent->getBeginLoc();
-    } while (!L.isValid());
-  }
-
-  // FIXME: Ironically, this assert actually fails in some cases.
-  //assert(L.isValid());
-  return L;
-}
-
-static PathDiagnosticLocation
-getLocationForCaller(const StackFrameContext *SFC,
-                     const LocationContext *CallerCtx,
-                     const SourceManager &SM) {
-  const CFGBlock &Block = *SFC->getCallSiteBlock();
-  CFGElement Source = Block[SFC->getIndex()];
-
-  switch (Source.getKind()) {
-  case CFGElement::Statement:
-  case CFGElement::Constructor:
-  case CFGElement::CXXRecordTypedCall:
-    return PathDiagnosticLocation(Source.castAs<CFGStmt>().getStmt(),
-                                  SM, CallerCtx);
-  case CFGElement::Initializer: {
-    const CFGInitializer &Init = Source.castAs<CFGInitializer>();
-    return PathDiagnosticLocation(Init.getInitializer()->getInit(),
-                                  SM, CallerCtx);
-  }
-  case CFGElement::AutomaticObjectDtor: {
-    const CFGAutomaticObjDtor &Dtor = Source.castAs<CFGAutomaticObjDtor>();
-    return PathDiagnosticLocation::createEnd(Dtor.getTriggerStmt(),
-                                             SM, CallerCtx);
-  }
-  case CFGElement::DeleteDtor: {
-    const CFGDeleteDtor &Dtor = Source.castAs<CFGDeleteDtor>();
-    return PathDiagnosticLocation(Dtor.getDeleteExpr(), SM, CallerCtx);
-  }
-  case CFGElement::BaseDtor:
-  case CFGElement::MemberDtor: {
-    const AnalysisDeclContext *CallerInfo = CallerCtx->getAnalysisDeclContext();
-    if (const Stmt *CallerBody = CallerInfo->getBody())
-      return PathDiagnosticLocation::createEnd(CallerBody, SM, CallerCtx);
-    return PathDiagnosticLocation::create(CallerInfo->getDecl(), SM);
-  }
-  case CFGElement::NewAllocator: {
-    const CFGNewAllocator &Alloc = Source.castAs<CFGNewAllocator>();
-    return PathDiagnosticLocation(Alloc.getAllocatorExpr(), SM, CallerCtx);
-  }
-  case CFGElement::TemporaryDtor: {
-    // Temporary destructors are for temporaries. They die immediately at around
-    // the location of CXXBindTemporaryExpr. If they are lifetime-extended,
-    // they'd be dealt with via an AutomaticObjectDtor instead.
-    const auto &Dtor = Source.castAs<CFGTemporaryDtor>();
-    return PathDiagnosticLocation::createEnd(Dtor.getBindTemporaryExpr(), SM,
-                                             CallerCtx);
-  }
-  case CFGElement::ScopeBegin:
-  case CFGElement::ScopeEnd:
-    llvm_unreachable("not yet implemented!");
-  case CFGElement::LifetimeEnds:
-  case CFGElement::LoopExit:
-    llvm_unreachable("CFGElement kind should not be on callsite!");
-  }
-
-  llvm_unreachable("Unknown CFGElement kind");
-}
-
-PathDiagnosticLocation
-PathDiagnosticLocation::createBegin(const Decl *D,
-                                    const SourceManager &SM) {
-  return PathDiagnosticLocation(D->getBeginLoc(), SM, SingleLocK);
-}
-
-PathDiagnosticLocation
-PathDiagnosticLocation::createBegin(const Stmt *S,
-                                    const SourceManager &SM,
-                                    LocationOrAnalysisDeclContext LAC) {
-  return PathDiagnosticLocation(getValidSourceLocation(S, LAC),
-                                SM, SingleLocK);
-}
-
-PathDiagnosticLocation
-PathDiagnosticLocation::createEnd(const Stmt *S,
-                                  const SourceManager &SM,
-                                  LocationOrAnalysisDeclContext LAC) {
-  if (const auto *CS = dyn_cast<CompoundStmt>(S))
-    return createEndBrace(CS, SM);
-  return PathDiagnosticLocation(getValidSourceLocation(S, LAC, /*End=*/true),
-                                SM, SingleLocK);
-}
-
-PathDiagnosticLocation
-PathDiagnosticLocation::createOperatorLoc(const BinaryOperator *BO,
-                                          const SourceManager &SM) {
-  return PathDiagnosticLocation(BO->getOperatorLoc(), SM, SingleLocK);
-}
-
-PathDiagnosticLocation
-PathDiagnosticLocation::createConditionalColonLoc(
-                                            const ConditionalOperator *CO,
-                                            const SourceManager &SM) {
-  return PathDiagnosticLocation(CO->getColonLoc(), SM, SingleLocK);
-}
-
-PathDiagnosticLocation
-PathDiagnosticLocation::createMemberLoc(const MemberExpr *ME,
-                                        const SourceManager &SM) {
-
-  assert(ME->getMemberLoc().isValid() || ME->getBeginLoc().isValid());
-
-  // In some cases, getMemberLoc isn't valid -- in this case we'll return with
-  // some other related valid SourceLocation.
-  if (ME->getMemberLoc().isValid())
-    return PathDiagnosticLocation(ME->getMemberLoc(), SM, SingleLocK);
-
-  return PathDiagnosticLocation(ME->getBeginLoc(), SM, SingleLocK);
-}
-
-PathDiagnosticLocation
-PathDiagnosticLocation::createBeginBrace(const CompoundStmt *CS,
-                                         const SourceManager &SM) {
-  SourceLocation L = CS->getLBracLoc();
-  return PathDiagnosticLocation(L, SM, SingleLocK);
-}
-
-PathDiagnosticLocation
-PathDiagnosticLocation::createEndBrace(const CompoundStmt *CS,
-                                       const SourceManager &SM) {
-  SourceLocation L = CS->getRBracLoc();
-  return PathDiagnosticLocation(L, SM, SingleLocK);
-}
-
-PathDiagnosticLocation
-PathDiagnosticLocation::createDeclBegin(const LocationContext *LC,
-                                        const SourceManager &SM) {
-  // FIXME: Should handle CXXTryStmt if analyser starts supporting C++.
-  if (const auto *CS = dyn_cast_or_null<CompoundStmt>(LC->getDecl()->getBody()))
-    if (!CS->body_empty()) {
-      SourceLocation Loc = (*CS->body_begin())->getBeginLoc();
-      return PathDiagnosticLocation(Loc, SM, SingleLocK);
-    }
-
-  return PathDiagnosticLocation();
-}
-
-PathDiagnosticLocation
-PathDiagnosticLocation::createDeclEnd(const LocationContext *LC,
-                                      const SourceManager &SM) {
-  SourceLocation L = LC->getDecl()->getBodyRBrace();
-  return PathDiagnosticLocation(L, SM, SingleLocK);
-}
-
-PathDiagnosticLocation
-PathDiagnosticLocation::create(const ProgramPoint& P,
-                               const SourceManager &SMng) {
-  const Stmt* S = nullptr;
-  if (Optional<BlockEdge> BE = P.getAs<BlockEdge>()) {
-    const CFGBlock *BSrc = BE->getSrc();
-    if (BSrc->getTerminator().isVirtualBaseBranch()) {
-      // TODO: VirtualBaseBranches should also appear for destructors.
-      // In this case we should put the diagnostic at the end of decl.
-      return PathDiagnosticLocation::createBegin(
-          P.getLocationContext()->getDecl(), SMng);
-
-    } else {
-      S = BSrc->getTerminatorCondition();
-      if (!S) {
-        // If the BlockEdge has no terminator condition statement but its
-        // source is the entry of the CFG (e.g. a checker crated the branch at
-        // the beginning of a function), use the function's declaration instead.
-        assert(BSrc == &BSrc->getParent()->getEntry() && "CFGBlock has no "
-               "TerminatorCondition and is not the enrty block of the CFG");
-        return PathDiagnosticLocation::createBegin(
-            P.getLocationContext()->getDecl(), SMng);
-      }
-    }
-  } else if (Optional<StmtPoint> SP = P.getAs<StmtPoint>()) {
-    S = SP->getStmt();
-    if (P.getAs<PostStmtPurgeDeadSymbols>())
-      return PathDiagnosticLocation::createEnd(S, SMng, P.getLocationContext());
-  } else if (Optional<PostInitializer> PIP = P.getAs<PostInitializer>()) {
-    return PathDiagnosticLocation(PIP->getInitializer()->getSourceLocation(),
-                                  SMng);
-  } else if (Optional<PreImplicitCall> PIC = P.getAs<PreImplicitCall>()) {
-    return PathDiagnosticLocation(PIC->getLocation(), SMng);
-  } else if (Optional<PostImplicitCall> PIE = P.getAs<PostImplicitCall>()) {
-    return PathDiagnosticLocation(PIE->getLocation(), SMng);
-  } else if (Optional<CallEnter> CE = P.getAs<CallEnter>()) {
-    return getLocationForCaller(CE->getCalleeContext(),
-                                CE->getLocationContext(),
-                                SMng);
-  } else if (Optional<CallExitEnd> CEE = P.getAs<CallExitEnd>()) {
-    return getLocationForCaller(CEE->getCalleeContext(),
-                                CEE->getLocationContext(),
-                                SMng);
-  } else if (auto CEB = P.getAs<CallExitBegin>()) {
-    if (const ReturnStmt *RS = CEB->getReturnStmt())
-      return PathDiagnosticLocation::createBegin(RS, SMng,
-                                                 CEB->getLocationContext());
-    return PathDiagnosticLocation(
-        CEB->getLocationContext()->getDecl()->getSourceRange().getEnd(), SMng);
-  } else if (Optional<BlockEntrance> BE = P.getAs<BlockEntrance>()) {
-    CFGElement BlockFront = BE->getBlock()->front();
-    if (auto StmtElt = BlockFront.getAs<CFGStmt>()) {
-      return PathDiagnosticLocation(StmtElt->getStmt()->getBeginLoc(), SMng);
-    } else if (auto NewAllocElt = BlockFront.getAs<CFGNewAllocator>()) {
-      return PathDiagnosticLocation(
-          NewAllocElt->getAllocatorExpr()->getBeginLoc(), SMng);
-    }
-    llvm_unreachable("Unexpected CFG element at front of block");
-  } else if (Optional<FunctionExitPoint> FE = P.getAs<FunctionExitPoint>()) {
-    return PathDiagnosticLocation(FE->getStmt(), SMng,
-                                  FE->getLocationContext());
-  } else {
-    llvm_unreachable("Unexpected ProgramPoint");
-  }
-
-  return PathDiagnosticLocation(S, SMng, P.getLocationContext());
-}
-
-PathDiagnosticLocation PathDiagnosticLocation::createSingleLocation(
-                                           const PathDiagnosticLocation &PDL) {
-  FullSourceLoc L = PDL.asLocation();
-  return PathDiagnosticLocation(L, L.getManager(), SingleLocK);
-}
-
-FullSourceLoc
-  PathDiagnosticLocation::genLocation(SourceLocation L,
-                                      LocationOrAnalysisDeclContext LAC) const {
-  assert(isValid());
-  // Note that we want a 'switch' here so that the compiler can warn us in
-  // case we add more cases.
-  switch (K) {
-    case SingleLocK:
-    case RangeK:
-      break;
-    case StmtK:
-      // Defensive checking.
-      if (!S)
-        break;
-      return FullSourceLoc(getValidSourceLocation(S, LAC),
-                           const_cast<SourceManager&>(*SM));
-    case DeclK:
-      // Defensive checking.
-      if (!D)
-        break;
-      return FullSourceLoc(D->getLocation(), const_cast<SourceManager&>(*SM));
-  }
-
-  return FullSourceLoc(L, const_cast<SourceManager&>(*SM));
-}
-
-PathDiagnosticRange
-  PathDiagnosticLocation::genRange(LocationOrAnalysisDeclContext LAC) const {
-  assert(isValid());
-  // Note that we want a 'switch' here so that the compiler can warn us in
-  // case we add more cases.
-  switch (K) {
-    case SingleLocK:
-      return PathDiagnosticRange(SourceRange(Loc,Loc), true);
-    case RangeK:
-      break;
-    case StmtK: {
-      const Stmt *S = asStmt();
-      switch (S->getStmtClass()) {
-        default:
-          break;
-        case Stmt::DeclStmtClass: {
-          const auto *DS = cast<DeclStmt>(S);
-          if (DS->isSingleDecl()) {
-            // Should always be the case, but we'll be defensive.
-            return SourceRange(DS->getBeginLoc(),
-                               DS->getSingleDecl()->getLocation());
-          }
-          break;
-        }
-          // FIXME: Provide better range information for different
-          //  terminators.
-        case Stmt::IfStmtClass:
-        case Stmt::WhileStmtClass:
-        case Stmt::DoStmtClass:
-        case Stmt::ForStmtClass:
-        case Stmt::ChooseExprClass:
-        case Stmt::IndirectGotoStmtClass:
-        case Stmt::SwitchStmtClass:
-        case Stmt::BinaryConditionalOperatorClass:
-        case Stmt::ConditionalOperatorClass:
-        case Stmt::ObjCForCollectionStmtClass: {
-          SourceLocation L = getValidSourceLocation(S, LAC);
-          return SourceRange(L, L);
-        }
-      }
-      SourceRange R = S->getSourceRange();
-      if (R.isValid())
-        return R;
-      break;
-    }
-    case DeclK:
-      if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
-        return MD->getSourceRange();
-      if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
-        if (Stmt *Body = FD->getBody())
-          return Body->getSourceRange();
-      }
-      else {
-        SourceLocation L = D->getLocation();
-        return PathDiagnosticRange(SourceRange(L, L), true);
-      }
-  }
-
-  return SourceRange(Loc, Loc);
-}
-
-void PathDiagnosticLocation::flatten() {
-  if (K == StmtK) {
-    K = RangeK;
-    S = nullptr;
-    D = nullptr;
-  }
-  else if (K == DeclK) {
-    K = SingleLocK;
-    S = nullptr;
-    D = nullptr;
-  }
-}
-
-//===----------------------------------------------------------------------===//
-// Manipulation of PathDiagnosticCallPieces.
-//===----------------------------------------------------------------------===//
-
-std::shared_ptr<PathDiagnosticCallPiece>
-PathDiagnosticCallPiece::construct(const CallExitEnd &CE,
-                                   const SourceManager &SM) {
-  const Decl *caller = CE.getLocationContext()->getDecl();
-  PathDiagnosticLocation pos = getLocationForCaller(CE.getCalleeContext(),
-                                                    CE.getLocationContext(),
-                                                    SM);
-  return std::shared_ptr<PathDiagnosticCallPiece>(
-      new PathDiagnosticCallPiece(caller, pos));
-}
-
-PathDiagnosticCallPiece *
-PathDiagnosticCallPiece::construct(PathPieces &path,
-                                   const Decl *caller) {
-  std::shared_ptr<PathDiagnosticCallPiece> C(
-      new PathDiagnosticCallPiece(path, caller));
-  path.clear();
-  auto *R = C.get();
-  path.push_front(std::move(C));
-  return R;
-}
-
-void PathDiagnosticCallPiece::setCallee(const CallEnter &CE,
-                                        const SourceManager &SM) {
-  const StackFrameContext *CalleeCtx = CE.getCalleeContext();
-  Callee = CalleeCtx->getDecl();
-
-  callEnterWithin = PathDiagnosticLocation::createBegin(Callee, SM);
-  callEnter = getLocationForCaller(CalleeCtx, CE.getLocationContext(), SM);
-
-  // Autosynthesized property accessors are special because we'd never
-  // pop back up to non-autosynthesized code until we leave them.
-  // This is not generally true for autosynthesized callees, which may call
-  // non-autosynthesized callbacks.
-  // Unless set here, the IsCalleeAnAutosynthesizedPropertyAccessor flag
-  // defaults to false.
-  if (const auto *MD = dyn_cast<ObjCMethodDecl>(Callee))
-    IsCalleeAnAutosynthesizedPropertyAccessor = (
-        MD->isPropertyAccessor() &&
-        CalleeCtx->getAnalysisDeclContext()->isBodyAutosynthesized());
-}
-
-static void describeTemplateParameters(raw_ostream &Out,
-                                       const ArrayRef<TemplateArgument> TAList,
-                                       const LangOptions &LO,
-                                       StringRef Prefix = StringRef(),
-                                       StringRef Postfix = StringRef());
-
-static void describeTemplateParameter(raw_ostream &Out,
-                                      const TemplateArgument &TArg,
-                                      const LangOptions &LO) {
-
-  if (TArg.getKind() == TemplateArgument::ArgKind::Pack) {
-    describeTemplateParameters(Out, TArg.getPackAsArray(), LO);
-  } else {
-    TArg.print(PrintingPolicy(LO), Out);
-  }
-}
-
-static void describeTemplateParameters(raw_ostream &Out,
-                                       const ArrayRef<TemplateArgument> TAList,
-                                       const LangOptions &LO,
-                                       StringRef Prefix, StringRef Postfix) {
-  if (TAList.empty())
-    return;
-
-  Out << Prefix;
-  for (int I = 0, Last = TAList.size() - 1; I != Last; ++I) {
-    describeTemplateParameter(Out, TAList[I], LO);
-    Out << ", ";
-  }
-  describeTemplateParameter(Out, TAList[TAList.size() - 1], LO);
-  Out << Postfix;
-}
-
-static void describeClass(raw_ostream &Out, const CXXRecordDecl *D,
-                          StringRef Prefix = StringRef()) {
-  if (!D->getIdentifier())
-    return;
-  Out << Prefix << '\'' << *D;
-  if (const auto T = dyn_cast<ClassTemplateSpecializationDecl>(D))
-    describeTemplateParameters(Out, T->getTemplateArgs().asArray(),
-                               D->getASTContext().getLangOpts(), "<", ">");
-
-  Out << '\'';
-}
-
-static bool describeCodeDecl(raw_ostream &Out, const Decl *D,
-                             bool ExtendedDescription,
-                             StringRef Prefix = StringRef()) {
-  if (!D)
-    return false;
-
-  if (isa<BlockDecl>(D)) {
-    if (ExtendedDescription)
-      Out << Prefix << "anonymous block";
-    return ExtendedDescription;
-  }
-
-  if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
-    Out << Prefix;
-    if (ExtendedDescription && !MD->isUserProvided()) {
-      if (MD->isExplicitlyDefaulted())
-        Out << "defaulted ";
-      else
-        Out << "implicit ";
-    }
-
-    if (const auto *CD = dyn_cast<CXXConstructorDecl>(MD)) {
-      if (CD->isDefaultConstructor())
-        Out << "default ";
-      else if (CD->isCopyConstructor())
-        Out << "copy ";
-      else if (CD->isMoveConstructor())
-        Out << "move ";
-
-      Out << "constructor";
-      describeClass(Out, MD->getParent(), " for ");
-    } else if (isa<CXXDestructorDecl>(MD)) {
-      if (!MD->isUserProvided()) {
-        Out << "destructor";
-        describeClass(Out, MD->getParent(), " for ");
-      } else {
-        // Use ~Foo for explicitly-written destructors.
-        Out << "'" << *MD << "'";
-      }
-    } else if (MD->isCopyAssignmentOperator()) {
-        Out << "copy assignment operator";
-        describeClass(Out, MD->getParent(), " for ");
-    } else if (MD->isMoveAssignmentOperator()) {
-        Out << "move assignment operator";
-        describeClass(Out, MD->getParent(), " for ");
-    } else {
-      if (MD->getParent()->getIdentifier())
-        Out << "'" << *MD->getParent() << "::" << *MD << "'";
-      else
-        Out << "'" << *MD << "'";
-    }
-
-    return true;
-  }
-
-  Out << Prefix << '\'' << cast<NamedDecl>(*D);
-
-  // Adding template parameters.
-  if (const auto FD = dyn_cast<FunctionDecl>(D))
-    if (const TemplateArgumentList *TAList =
-                                    FD->getTemplateSpecializationArgs())
-      describeTemplateParameters(Out, TAList->asArray(),
-                                 FD->getASTContext().getLangOpts(), "<", ">");
-
-  Out << '\'';
-  return true;
-}
-
-std::shared_ptr<PathDiagnosticEventPiece>
-PathDiagnosticCallPiece::getCallEnterEvent() const {
-  // We do not produce call enters and call exits for autosynthesized property
-  // accessors. We do generally produce them for other functions coming from
-  // the body farm because they may call callbacks that bring us back into
-  // visible code.
-  if (!Callee || IsCalleeAnAutosynthesizedPropertyAccessor)
-    return nullptr;
-
-  SmallString<256> buf;
-  llvm::raw_svector_ostream Out(buf);
-
-  Out << "Calling ";
-  describeCodeDecl(Out, Callee, /*ExtendedDescription=*/true);
-
-  assert(callEnter.asLocation().isValid());
-  return std::make_shared<PathDiagnosticEventPiece>(callEnter, Out.str());
-}
-
-std::shared_ptr<PathDiagnosticEventPiece>
-PathDiagnosticCallPiece::getCallEnterWithinCallerEvent() const {
-  if (!callEnterWithin.asLocation().isValid())
-    return nullptr;
-  if (Callee->isImplicit() || !Callee->hasBody())
-    return nullptr;
-  if (const auto *MD = dyn_cast<CXXMethodDecl>(Callee))
-    if (MD->isDefaulted())
-      return nullptr;
-
-  SmallString<256> buf;
-  llvm::raw_svector_ostream Out(buf);
-
-  Out << "Entered call";
-  describeCodeDecl(Out, Caller, /*ExtendedDescription=*/false, " from ");
-
-  return std::make_shared<PathDiagnosticEventPiece>(callEnterWithin, Out.str());
-}
-
-std::shared_ptr<PathDiagnosticEventPiece>
-PathDiagnosticCallPiece::getCallExitEvent() const {
-  // We do not produce call enters and call exits for autosynthesized property
-  // accessors. We do generally produce them for other functions coming from
-  // the body farm because they may call callbacks that bring us back into
-  // visible code.
-  if (NoExit || IsCalleeAnAutosynthesizedPropertyAccessor)
-    return nullptr;
-
-  SmallString<256> buf;
-  llvm::raw_svector_ostream Out(buf);
-
-  if (!CallStackMessage.empty()) {
-    Out << CallStackMessage;
-  } else {
-    bool DidDescribe = describeCodeDecl(Out, Callee,
-                                        /*ExtendedDescription=*/false,
-                                        "Returning from ");
-    if (!DidDescribe)
-      Out << "Returning to caller";
-  }
-
-  assert(callReturn.asLocation().isValid());
-  return std::make_shared<PathDiagnosticEventPiece>(callReturn, Out.str());
-}
-
-static void compute_path_size(const PathPieces &pieces, unsigned &size) {
-  for (const auto &I : pieces) {
-    const PathDiagnosticPiece *piece = I.get();
-    if (const auto *cp = dyn_cast<PathDiagnosticCallPiece>(piece))
-      compute_path_size(cp->path, size);
-    else
-      ++size;
-  }
-}
-
-unsigned PathDiagnostic::full_size() {
-  unsigned size = 0;
-  compute_path_size(path, size);
-  return size;
-}
-
-//===----------------------------------------------------------------------===//
-// FoldingSet profiling methods.
-//===----------------------------------------------------------------------===//
-
-void PathDiagnosticLocation::Profile(llvm::FoldingSetNodeID &ID) const {
-  ID.AddInteger(Range.getBegin().getRawEncoding());
-  ID.AddInteger(Range.getEnd().getRawEncoding());
-  ID.AddInteger(Loc.getRawEncoding());
-}
-
-void PathDiagnosticPiece::Profile(llvm::FoldingSetNodeID &ID) const {
-  ID.AddInteger((unsigned) getKind());
-  ID.AddString(str);
-  // FIXME: Add profiling support for code hints.
-  ID.AddInteger((unsigned) getDisplayHint());
-  ArrayRef<SourceRange> Ranges = getRanges();
-  for (const auto &I : Ranges) {
-    ID.AddInteger(I.getBegin().getRawEncoding());
-    ID.AddInteger(I.getEnd().getRawEncoding());
-  }
-}
-
-void PathDiagnosticCallPiece::Profile(llvm::FoldingSetNodeID &ID) const {
-  PathDiagnosticPiece::Profile(ID);
-  for (const auto &I : path)
-    ID.Add(*I);
-}
-
-void PathDiagnosticSpotPiece::Profile(llvm::FoldingSetNodeID &ID) const {
-  PathDiagnosticPiece::Profile(ID);
-  ID.Add(Pos);
-}
-
-void PathDiagnosticControlFlowPiece::Profile(llvm::FoldingSetNodeID &ID) const {
-  PathDiagnosticPiece::Profile(ID);
-  for (const auto &I : *this)
-    ID.Add(I);
-}
-
-void PathDiagnosticMacroPiece::Profile(llvm::FoldingSetNodeID &ID) const {
-  PathDiagnosticSpotPiece::Profile(ID);
-  for (const auto &I : subPieces)
-    ID.Add(*I);
-}
-
-void PathDiagnosticNotePiece::Profile(llvm::FoldingSetNodeID &ID) const {
-  PathDiagnosticSpotPiece::Profile(ID);
-}
-
-void PathDiagnosticPopUpPiece::Profile(llvm::FoldingSetNodeID &ID) const {
-  PathDiagnosticSpotPiece::Profile(ID);
-}
-
-void PathDiagnostic::Profile(llvm::FoldingSetNodeID &ID) const {
-  ID.Add(getLocation());
-  ID.AddString(BugType);
-  ID.AddString(VerboseDesc);
-  ID.AddString(Category);
-}
-
-void PathDiagnostic::FullProfile(llvm::FoldingSetNodeID &ID) const {
-  Profile(ID);
-  for (const auto &I : path)
-    ID.Add(*I);
-  for (meta_iterator I = meta_begin(), E = meta_end(); I != E; ++I)
-    ID.AddString(*I);
-}
-
-LLVM_DUMP_METHOD void PathPieces::dump() const {
-  unsigned index = 0;
-  for (PathPieces::const_iterator I = begin(), E = end(); I != E; ++I) {
-    llvm::errs() << "[" << index++ << "]  ";
-    (*I)->dump();
-    llvm::errs() << "\n";
-  }
-}
-
-LLVM_DUMP_METHOD void PathDiagnosticCallPiece::dump() const {
-  llvm::errs() << "CALL\n--------------\n";
-
-  if (const Stmt *SLoc = getLocation().getStmtOrNull())
-    SLoc->dump();
-  else if (const auto *ND = dyn_cast_or_null<NamedDecl>(getCallee()))
-    llvm::errs() << *ND << "\n";
-  else
-    getLocation().dump();
-}
-
-LLVM_DUMP_METHOD void PathDiagnosticEventPiece::dump() const {
-  llvm::errs() << "EVENT\n--------------\n";
-  llvm::errs() << getString() << "\n";
-  llvm::errs() << " ---- at ----\n";
-  getLocation().dump();
-}
-
-LLVM_DUMP_METHOD void PathDiagnosticControlFlowPiece::dump() const {
-  llvm::errs() << "CONTROL\n--------------\n";
-  getStartLocation().dump();
-  llvm::errs() << " ---- to ----\n";
-  getEndLocation().dump();
-}
-
-LLVM_DUMP_METHOD void PathDiagnosticMacroPiece::dump() const {
-  llvm::errs() << "MACRO\n--------------\n";
-  // FIXME: Print which macro is being invoked.
-}
-
-LLVM_DUMP_METHOD void PathDiagnosticNotePiece::dump() const {
-  llvm::errs() << "NOTE\n--------------\n";
-  llvm::errs() << getString() << "\n";
-  llvm::errs() << " ---- at ----\n";
-  getLocation().dump();
-}
-
-LLVM_DUMP_METHOD void PathDiagnosticPopUpPiece::dump() const {
-  llvm::errs() << "POP-UP\n--------------\n";
-  llvm::errs() << getString() << "\n";
-  llvm::errs() << " ---- at ----\n";
-  getLocation().dump();
-}
-
-LLVM_DUMP_METHOD void PathDiagnosticLocation::dump() const {
-  if (!isValid()) {
-    llvm::errs() << "<INVALID>\n";
-    return;
-  }
-
-  switch (K) {
-  case RangeK:
-    // FIXME: actually print the range.
-    llvm::errs() << "<range>\n";
-    break;
-  case SingleLocK:
-    asLocation().dump();
-    llvm::errs() << "\n";
-    break;
-  case StmtK:
-    if (S)
-      S->dump();
-    else
-      llvm::errs() << "<NULL STMT>\n";
-    break;
-  case DeclK:
-    if (const auto *ND = dyn_cast_or_null<NamedDecl>(D))
-      llvm::errs() << *ND << "\n";
-    else if (isa<BlockDecl>(D))
-      // FIXME: Make this nicer.
-      llvm::errs() << "<block>\n";
-    else if (D)
-      llvm::errs() << "<unknown decl>\n";
-    else
-      llvm::errs() << "<NULL DECL>\n";
-    break;
-  }
-}

cfe/trunk/lib/StaticAnalyzer/Core/PlistDiagnostics.cpp

 //===--- PlistDiagnostics.cpp - Plist Diagnostics for Paths -----*- 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 PlistDiagnostics object.
 //
 //===----------------------------------------------------------------------===//
 
+#include "clang/Analysis/PathDiagnostic.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/PlistSupport.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/Version.h"
 #include "clang/CrossTU/CrossTranslationUnit.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/TokenConcatenation.h"
 #include "clang/Rewrite/Core/HTMLRewrite.h"
 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
-#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
 #include "clang/StaticAnalyzer/Core/IssueHash.h"
 #include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Support/Casting.h"
 
 using namespace clang;

cfe/trunk/lib/StaticAnalyzer/Core/SarifDiagnostics.cpp

 //===--- SarifDiagnostics.cpp - Sarif Diagnostics for Paths -----*- 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 SarifDiagnostics object.
 //
 //===----------------------------------------------------------------------===//
 
+#include "clang/Analysis/PathDiagnostic.h"
 #include "clang/Basic/Version.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
-#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
 #include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/Path.h"
 
 using namespace llvm;
 using namespace clang;

cfe/trunk/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp

 //===--- AnalysisConsumer.cpp - ASTConsumer for running Analyses ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // "Meta" ASTConsumer for running different source analyses.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/StaticAnalyzer/Frontend/AnalysisConsumer.h"
 #include "ModelInjector.h"
+#include "clang/Analysis/PathDiagnostic.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Analysis/Analyses/LiveVariables.h"
 #include "clang/Analysis/CFG.h"
 #include "clang/Analysis/CallGraph.h"
 #include "clang/Analysis/CodeInjector.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/CrossTU/CrossTranslationUnit.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/StaticAnalyzer/Checkers/LocalCheckers.h"
 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
-#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
 #include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h"
 #include "clang/StaticAnalyzer/Frontend/CheckerRegistration.h"
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Support/FileSystem.h"

clang-tools-extra/trunk/clang-tidy/ClangTidy.cpp

 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Frontend/MultiplexConsumer.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Rewrite/Frontend/FixItRewriter.h"
 #include "clang/Rewrite/Frontend/FrontendActions.h"
 #include "clang/Tooling/Core/Diagnostic.h"
-#if CLANG_ENABLE_STATIC_ANALYZER
-#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
-#include "clang/StaticAnalyzer/Frontend/AnalysisConsumer.h"
-#endif // CLANG_ENABLE_STATIC_ANALYZER
 #include "clang/Tooling/DiagnosticsYaml.h"
 #include "clang/Tooling/Refactoring.h"
 #include "clang/Tooling/ReplacementsYaml.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 #include <algorithm>
 #include <utility>
 
+#if CLANG_ENABLE_STATIC_ANALYZER
+#include "clang/Analysis/PathDiagnostic.h"
+#include "clang/StaticAnalyzer/Frontend/AnalysisConsumer.h"
+#endif // CLANG_ENABLE_STATIC_ANALYZER
+
 using namespace clang::ast_matchers;
 using namespace clang::driver;
 using namespace clang::tooling;
 using namespace llvm;
 
 LLVM_INSTANTIATE_REGISTRY(clang::tidy::ClangTidyModuleRegistry)
 
 namespace clang {