3 files changed, 0 insertions, 1049 deletions
diff --git a/include/clang/Checker/BugReporter/BugReporter.h b/include/clang/Checker/BugReporter/BugReporter.h
deleted file mode 100644
index 370d965..0000000
--- a/include/clang/Checker/BugReporter/BugReporter.h
+++ /dev/null
@@ -1,483 +0,0 @@
-//===---  BugReporter.h - Generate PathDiagnostics --------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-//  This file defines BugReporter, a utility class for generating
-//  PathDiagnostics for analyses based on GRState.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_ANALYSIS_BUGREPORTER
-#define LLVM_CLANG_ANALYSIS_BUGREPORTER
-
-#include "clang/Basic/SourceLocation.h"
-#include "clang/Checker/PathSensitive/GRState.h"
-#include "llvm/ADT/FoldingSet.h"
-#include "llvm/ADT/ImmutableList.h"
-#include "llvm/ADT/ImmutableSet.h"
-#include "llvm/ADT/SmallSet.h"
-#include <list>
-
-namespace clang {
-
-class PathDiagnostic;
-class PathDiagnosticPiece;
-class PathDiagnosticClient;
-class ASTContext;
-class Diagnostic;
-class ExplodedNode;
-class ExplodedGraph;
-class BugReporter;
-class BugReporterContext;
-class GRExprEngine;
-class GRState;
-class Stmt;
-class BugType;
-class ParentMap;
-
-//===----------------------------------------------------------------------===//
-// Interface for individual bug reports.
-//===----------------------------------------------------------------------===//
-
-class BugReporterVisitor : public llvm::FoldingSetNode {
-public:
-  virtual ~BugReporterVisitor();
-  virtual PathDiagnosticPiece* VisitNode(const ExplodedNode* N,
-                                         const ExplodedNode* PrevN,
-                                         BugReporterContext& BRC) = 0;
-
-  virtual bool isOwnedByReporterContext() { return true; }
-  virtual void Profile(llvm::FoldingSetNodeID &ID) const = 0;
-};
-
-// FIXME: Combine this with RangedBugReport and remove RangedBugReport.
-class BugReport : public BugReporterVisitor {
-protected:
-  BugType& BT;
-  std::string ShortDescription;
-  std::string Description;
-  const ExplodedNode *EndNode;
-  SourceRange R;
-
-protected:
-  friend class BugReporter;
-  friend class BugReportEquivClass;
-
-  virtual void Profile(llvm::FoldingSetNodeID& hash) const {
-    hash.AddInteger(getLocation().getRawEncoding());
-    hash.AddString(Description);
-  }
-
-public:
-  class NodeResolver {
-  public:
-    virtual ~NodeResolver() {}
-    virtual const ExplodedNode*
-            getOriginalNode(const ExplodedNode* N) = 0;
-  };
-
-  BugReport(BugType& bt, llvm::StringRef desc, const ExplodedNode *n)
-    : BT(bt), Description(desc), EndNode(n) {}
-
-  BugReport(BugType& bt, llvm::StringRef shortDesc, llvm::StringRef desc,
-            const ExplodedNode *n)
-  : BT(bt), ShortDescription(shortDesc), Description(desc), EndNode(n) {}
-
-  virtual ~BugReport();
-
-  virtual bool isOwnedByReporterContext() { return false; }
-
-  const BugType& getBugType() const { return BT; }
-  BugType& getBugType() { return BT; }
-
-  // FIXME: Perhaps this should be moved into a subclass?
-  const ExplodedNode* getEndNode() const { return EndNode; }
-
-  // FIXME: Do we need this?  Maybe getLocation() should return a ProgramPoint
-  // object.
-  // FIXME: If we do need it, we can probably just make it private to
-  // BugReporter.
-  const Stmt* getStmt() const;
-
-  const llvm::StringRef getDescription() const { return Description; }
-
-  const llvm::StringRef getShortDescription() const {
-    return ShortDescription.empty() ? Description : ShortDescription;
-  }
-
-  // FIXME: Is this needed?
-  virtual std::pair<const char**,const char**> getExtraDescriptiveText() {
-    return std::make_pair((const char**)0,(const char**)0);
-  }
-
-  // FIXME: Perhaps move this into a subclass.
-  virtual PathDiagnosticPiece* getEndPath(BugReporterContext& BRC,
-                                          const ExplodedNode* N);
-
-  /// getLocation - Return the "definitive" location of the reported bug.
-  ///  While a bug can span an entire path, usually there is a specific
-  ///  location that can be used to identify where the key issue occured.
-  ///  This location is used by clients rendering diagnostics.
-  virtual SourceLocation getLocation() const;
-
-  /// getRanges - Returns the source ranges associated with this bug.
-  virtual void getRanges(const SourceRange*& beg, const SourceRange*& end);
-
-  virtual PathDiagnosticPiece* VisitNode(const ExplodedNode* N,
-                                         const ExplodedNode* PrevN,
-                                         BugReporterContext& BR);
-
-  virtual void registerInitialVisitors(BugReporterContext& BRC,
-                                       const ExplodedNode* N) {}
-};
-
-//===----------------------------------------------------------------------===//
-// BugTypes (collections of related reports).
-//===----------------------------------------------------------------------===//
-
-class BugReportEquivClass : public llvm::FoldingSetNode {
-  // List of *owned* BugReport objects.
-  std::list<BugReport*> Reports;
-
-  friend class BugReporter;
-  void AddReport(BugReport* R) { Reports.push_back(R); }
-public:
-  BugReportEquivClass(BugReport* R) { Reports.push_back(R); }
-  ~BugReportEquivClass();
-
-  void Profile(llvm::FoldingSetNodeID& ID) const {
-    assert(!Reports.empty());
-    (*Reports.begin())->Profile(ID);
-  }
-
-  class iterator {
-    std::list<BugReport*>::iterator impl;
-  public:
-    iterator(std::list<BugReport*>::iterator i) : impl(i) {}
-    iterator& operator++() { ++impl; return *this; }
-    bool operator==(const iterator& I) const { return I.impl == impl; }
-    bool operator!=(const iterator& I) const { return I.impl != impl; }
-    BugReport* operator*() const { return *impl; }
-    BugReport* operator->() const { return *impl; }
-  };
-
-  class const_iterator {
-    std::list<BugReport*>::const_iterator impl;
-  public:
-    const_iterator(std::list<BugReport*>::const_iterator i) : impl(i) {}
-    const_iterator& operator++() { ++impl; return *this; }
-    bool operator==(const const_iterator& I) const { return I.impl == impl; }
-    bool operator!=(const const_iterator& I) const { return I.impl != impl; }
-    const BugReport* operator*() const { return *impl; }
-    const BugReport* operator->() const { return *impl; }
-  };
-
-  iterator begin() { return iterator(Reports.begin()); }
-  iterator end() { return iterator(Reports.end()); }
-
-  const_iterator begin() const { return const_iterator(Reports.begin()); }
-  const_iterator end() const { return const_iterator(Reports.end()); }
-};
-
-
-//===----------------------------------------------------------------------===//
-// Specialized subclasses of BugReport.
-//===----------------------------------------------------------------------===//
-
-// FIXME: Collapse this with the default BugReport class.
-class RangedBugReport : public BugReport {
-  std::vector<SourceRange> Ranges;
-public:
-  RangedBugReport(BugType& D, llvm::StringRef description, ExplodedNode *n)
-    : BugReport(D, description, n) {}
-
-  RangedBugReport(BugType& D, llvm::StringRef shortDescription,
-                  llvm::StringRef description, ExplodedNode *n)
-  : BugReport(D, shortDescription, description, n) {}
-
-  ~RangedBugReport();
-
-  // FIXME: Move this out of line.
-  void addRange(SourceRange R) {
-    assert(R.isValid());
-    Ranges.push_back(R);
-  }
-
-  // FIXME: Move this out of line.
-  void getRanges(const SourceRange*& beg, const SourceRange*& end) {
-
-    if (Ranges.empty()) {
-      beg = NULL;
-      end = NULL;
-    }
-    else {
-      beg = &Ranges[0];
-      end = beg + Ranges.size();
-    }
-  }
-};
-
-class EnhancedBugReport : public RangedBugReport {
-public:
-  typedef void (*VisitorCreator)(BugReporterContext &BRcC, const void *data,
-                                 const ExplodedNode *N);
-
-private:
-  typedef std::vector<std::pair<VisitorCreator, const void*> > Creators;
-  Creators creators;
-
-public:
-  EnhancedBugReport(BugType& D, llvm::StringRef description, ExplodedNode *n)
-   : RangedBugReport(D, description, n) {}
-
-  EnhancedBugReport(BugType& D, llvm::StringRef shortDescription,
-                   llvm::StringRef description, ExplodedNode *n)
-    : RangedBugReport(D, shortDescription, description, n) {}
-
-  ~EnhancedBugReport() {}
-
-  void registerInitialVisitors(BugReporterContext& BRC, const ExplodedNode* N) {
-    for (Creators::iterator I = creators.begin(), E = creators.end(); I!=E; ++I)
-      I->first(BRC, I->second, N);
-  }
-
-  void addVisitorCreator(VisitorCreator creator, const void *data) {
-    creators.push_back(std::make_pair(creator, data));
-  }
-};
-
-//===----------------------------------------------------------------------===//
-// BugReporter and friends.
-//===----------------------------------------------------------------------===//
-
-class BugReporterData {
-public:
-  virtual ~BugReporterData();
-  virtual Diagnostic& getDiagnostic() = 0;
-  virtual PathDiagnosticClient* getPathDiagnosticClient() = 0;
-  virtual ASTContext& getASTContext() = 0;
-  virtual SourceManager& getSourceManager() = 0;
-};
-
-class BugReporter {
-public:
-  enum Kind { BaseBRKind, GRBugReporterKind };
-
-private:
-  typedef llvm::ImmutableSet<BugType*> BugTypesTy;
-  BugTypesTy::Factory F;
-  BugTypesTy BugTypes;
-
-  const Kind kind;
-  BugReporterData& D;
-
-  void FlushReport(BugReportEquivClass& EQ);
-
-protected:
-  BugReporter(BugReporterData& d, Kind k) : BugTypes(F.GetEmptySet()), kind(k), D(d) {}
-
-public:
-  BugReporter(BugReporterData& d) : BugTypes(F.GetEmptySet()), kind(BaseBRKind), D(d) {}
-  virtual ~BugReporter();
-
-  void FlushReports();
-
-  Kind getKind() const { return kind; }
-
-  Diagnostic& getDiagnostic() {
-    return D.getDiagnostic();
-  }
-
-  PathDiagnosticClient* getPathDiagnosticClient() {
-    return D.getPathDiagnosticClient();
-  }
-
-  typedef BugTypesTy::iterator iterator;
-  iterator begin() { return BugTypes.begin(); }
-  iterator end() { return BugTypes.end(); }
-
-  ASTContext& getContext() { return D.getASTContext(); }
-
-  SourceManager& getSourceManager() { return D.getSourceManager(); }
-
-  virtual void GeneratePathDiagnostic(PathDiagnostic& PD,
-                                      BugReportEquivClass& EQ) {}
-
-  void Register(BugType *BT);
-
-  void EmitReport(BugReport *R);
-
-  void EmitBasicReport(llvm::StringRef BugName, llvm::StringRef BugStr,
-                       SourceLocation Loc,
-                       SourceRange* RangeBeg, unsigned NumRanges);
-
-  void EmitBasicReport(llvm::StringRef BugName, llvm::StringRef BugCategory,
-                       llvm::StringRef BugStr, SourceLocation Loc,
-                       SourceRange* RangeBeg, unsigned NumRanges);
-
-
-  void EmitBasicReport(llvm::StringRef BugName, llvm::StringRef BugStr,
-                       SourceLocation Loc) {
-    EmitBasicReport(BugName, BugStr, Loc, 0, 0);
-  }
-
-  void EmitBasicReport(llvm::StringRef BugName, llvm::StringRef BugCategory,
-                       llvm::StringRef BugStr, SourceLocation Loc) {
-    EmitBasicReport(BugName, BugCategory, BugStr, Loc, 0, 0);
-  }
-
-  void EmitBasicReport(llvm::StringRef BugName, llvm::StringRef BugStr,
-                       SourceLocation Loc, SourceRange R) {
-    EmitBasicReport(BugName, BugStr, Loc, &R, 1);
-  }
-
-  void EmitBasicReport(llvm::StringRef BugName, llvm::StringRef Category,
-                       llvm::StringRef BugStr, SourceLocation Loc,
-                       SourceRange R) {
-    EmitBasicReport(BugName, Category, BugStr, Loc, &R, 1);
-  }
-
-  static bool classof(const BugReporter* R) { return true; }
-};
-
-// FIXME: Get rid of GRBugReporter.  It's the wrong abstraction.
-class GRBugReporter : public BugReporter {
-  GRExprEngine& Eng;
-  llvm::SmallSet<SymbolRef, 10> NotableSymbols;
-public:
-  GRBugReporter(BugReporterData& d, GRExprEngine& eng)
-    : BugReporter(d, GRBugReporterKind), Eng(eng) {}
-
-  virtual ~GRBugReporter();
-
-  /// getEngine - Return the analysis engine used to analyze a given
-  ///  function or method.
-  GRExprEngine &getEngine() { return Eng; }
-
-  /// getGraph - Get the exploded graph created by the analysis engine
-  ///  for the analyzed method or function.
-  ExplodedGraph &getGraph();
-
-  /// getStateManager - Return the state manager used by the analysis
-  ///  engine.
-  GRStateManager &getStateManager();
-
-  virtual void GeneratePathDiagnostic(PathDiagnostic& PD,
-                                      BugReportEquivClass& R);
-
-  void addNotableSymbol(SymbolRef Sym) {
-    NotableSymbols.insert(Sym);
-  }
-
-  bool isNotable(SymbolRef Sym) const {
-    return (bool) NotableSymbols.count(Sym);
-  }
-
-  /// classof - Used by isa<>, cast<>, and dyn_cast<>.
-  static bool classof(const BugReporter* R) {
-    return R->getKind() == GRBugReporterKind;
-  }
-};
-
-class BugReporterContext {
-  GRBugReporter &BR;
-  // Not the most efficient data structure, but we use an ImmutableList for the
-  // Callbacks because it is safe to make additions to list during iteration.
-  llvm::ImmutableList<BugReporterVisitor*>::Factory F;
-  llvm::ImmutableList<BugReporterVisitor*> Callbacks;
-  llvm::FoldingSet<BugReporterVisitor> CallbacksSet;
-public:
-  BugReporterContext(GRBugReporter& br) : BR(br), Callbacks(F.GetEmptyList()) {}
-  virtual ~BugReporterContext();
-
-  void addVisitor(BugReporterVisitor* visitor);
-
-  typedef llvm::ImmutableList<BugReporterVisitor*>::iterator visitor_iterator;
-  visitor_iterator visitor_begin() { return Callbacks.begin(); }
-  visitor_iterator visitor_end() { return Callbacks.end(); }
-
-  GRBugReporter& getBugReporter() { return BR; }
-
-  ExplodedGraph &getGraph() { return BR.getGraph(); }
-
-  void addNotableSymbol(SymbolRef Sym) {
-    // FIXME: For now forward to GRBugReporter.
-    BR.addNotableSymbol(Sym);
-  }
-
-  bool isNotable(SymbolRef Sym) const {
-    // FIXME: For now forward to GRBugReporter.
-    return BR.isNotable(Sym);
-  }
-
-  GRStateManager& getStateManager() {
-    return BR.getStateManager();
-  }
-
-  ValueManager& getValueManager() {
-    return getStateManager().getValueManager();
-  }
-
-  ASTContext& getASTContext() {
-    return BR.getContext();
-  }
-
-  SourceManager& getSourceManager() {
-    return BR.getSourceManager();
-  }
-
-  virtual BugReport::NodeResolver& getNodeResolver() = 0;
-};
-
-class DiagBugReport : public RangedBugReport {
-  std::list<std::string> Strs;
-  FullSourceLoc L;
-public:
-  DiagBugReport(BugType& D, llvm::StringRef desc, FullSourceLoc l) :
-  RangedBugReport(D, desc, 0), L(l) {}
-
-  virtual ~DiagBugReport() {}
-
-  // FIXME: Move out-of-line (virtual function).
-  SourceLocation getLocation() const { return L; }
-
-  void addString(llvm::StringRef s) { Strs.push_back(s); }
-
-  typedef std::list<std::string>::const_iterator str_iterator;
-  str_iterator str_begin() const { return Strs.begin(); }
-  str_iterator str_end() const { return Strs.end(); }
-};
-
-//===----------------------------------------------------------------------===//
-//===----------------------------------------------------------------------===//
-
-namespace bugreporter {
-
-const Stmt *GetDerefExpr(const ExplodedNode *N);
-const Stmt *GetDenomExpr(const ExplodedNode *N);
-const Stmt *GetCalleeExpr(const ExplodedNode *N);
-const Stmt *GetRetValExpr(const ExplodedNode *N);
-
-void registerTrackNullOrUndefValue(BugReporterContext& BRC, const void *stmt,
-                                   const ExplodedNode* N);
-
-void registerFindLastStore(BugReporterContext& BRC, const void *memregion,
-                           const ExplodedNode *N);
-
-void registerNilReceiverVisitor(BugReporterContext &BRC);
-
-void registerVarDeclsLastStore(BugReporterContext &BRC, const void *stmt,
-                               const ExplodedNode *N);
-
-} // end namespace clang::bugreporter
-
-//===----------------------------------------------------------------------===//
-
-} // end clang namespace
-
-#endif
diff --git a/include/clang/Checker/BugReporter/BugType.h b/include/clang/Checker/BugReporter/BugType.h
deleted file mode 100644
index afc07c8..0000000
--- a/include/clang/Checker/BugReporter/BugType.h
+++ /dev/null
@@ -1,72 +0,0 @@
-//===---  BugType.h - Bug Information Desciption ----------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-//  This file defines BugType, a class representing a bug type.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_ANALYSIS_BUGTYPE
-#define LLVM_CLANG_ANALYSIS_BUGTYPE
-
-#include "clang/Checker/BugReporter/BugReporter.h"
-#include "llvm/ADT/FoldingSet.h"
-#include <string>
-
-namespace clang {
-
-class ExplodedNode;
-class GRExprEngine;
-
-class BugType {
-private:
-  const std::string Name;
-  const std::string Category;
-  llvm::FoldingSet<BugReportEquivClass> EQClasses;
-  friend class BugReporter;
-  bool SuppressonSink;
-public:
-  BugType(llvm::StringRef name, llvm::StringRef cat)
-    : Name(name), Category(cat), SuppressonSink(false) {}
-  virtual ~BugType();
-
-  // FIXME: Should these be made strings as well?
-  llvm::StringRef getName() const { return Name; }
-  llvm::StringRef getCategory() const { return Category; }
-  
-  /// isSuppressOnSink - Returns true if bug reports associated with this bug
-  ///  type should be suppressed if the end node of the report is post-dominated
-  ///  by a sink node.
-  bool isSuppressOnSink() const { return SuppressonSink; }
-  void setSuppressOnSink(bool x) { SuppressonSink = x; }
-
-  virtual void FlushReports(BugReporter& BR);
-
-  typedef llvm::FoldingSet<BugReportEquivClass>::iterator iterator;
-  iterator begin() { return EQClasses.begin(); }
-  iterator end() { return EQClasses.end(); }
-
-  typedef llvm::FoldingSet<BugReportEquivClass>::const_iterator const_iterator;
-  const_iterator begin() const { return EQClasses.begin(); }
-  const_iterator end() const { return EQClasses.end(); }
-};
-
-class BuiltinBug : public BugType {
-  const std::string desc;
-public:
-  BuiltinBug(const char *name, const char *description)
-    : BugType(name, "Logic error"), desc(description) {}
-  
-  BuiltinBug(const char *name)
-    : BugType(name, "Logic error"), desc(name) {}
-  
-  llvm::StringRef getDescription() const { return desc; }
-};
-
-} // end clang namespace
-#endif
diff --git a/include/clang/Checker/BugReporter/PathDiagnostic.h b/include/clang/Checker/BugReporter/PathDiagnostic.h
deleted file mode 100644
index 24c75ce..0000000
--- a/include/clang/Checker/BugReporter/PathDiagnostic.h
+++ /dev/null
@@ -1,494 +0,0 @@
-//===--- PathDiagnostic.h - Path-Specific Diagnostic Handling ---*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-//  This file defines the PathDiagnostic-related interfaces.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_PATH_DIAGNOSTIC_H
-#define LLVM_CLANG_PATH_DIAGNOSTIC_H
-
-#include "clang/Basic/Diagnostic.h"
-#include "llvm/ADT/FoldingSet.h"
-#include <deque>
-#include <iterator>
-#include <string>
-#include <vector>
-
-namespace clang {
-
-class Decl;
-class SourceManager;
-class Stmt;
-
-//===----------------------------------------------------------------------===//
-// High-level interface for handlers of path-sensitive diagnostics.
-//===----------------------------------------------------------------------===//
-
-class PathDiagnostic;
-
-class PathDiagnosticClient : public DiagnosticClient  {
-public:
-  PathDiagnosticClient() {}
-
-  virtual ~PathDiagnosticClient() {}
-  
-  virtual void
-  FlushDiagnostics(llvm::SmallVectorImpl<std::string> *FilesMade = 0) = 0;
-  
-  void FlushDiagnostics(llvm::SmallVectorImpl<std::string> &FilesMade) {
-    FlushDiagnostics(&FilesMade);
-  }
-  
-  virtual llvm::StringRef getName() const = 0;
-  
-  virtual void HandleDiagnostic(Diagnostic::Level DiagLevel,
-                                const DiagnosticInfo &Info);
-  virtual void HandlePathDiagnostic(const PathDiagnostic* D) = 0;
-
-  enum PathGenerationScheme { Minimal, Extensive };
-  virtual PathGenerationScheme getGenerationScheme() const { return Minimal; }
-  virtual bool supportsLogicalOpControlFlow() const { return false; }
-  virtual bool supportsAllBlockEdges() const { return false; }
-  virtual bool useVerboseDescription() const { return true; }
-};
-
-//===----------------------------------------------------------------------===//
-// Path-sensitive diagnostics.
-//===----------------------------------------------------------------------===//
-
-class PathDiagnosticRange : public SourceRange {
-public:
-  const bool isPoint;
-
-  PathDiagnosticRange(const SourceRange &R, bool isP = false)
-    : SourceRange(R), isPoint(isP) {}
-};
-
-class PathDiagnosticLocation {
-private:
-  enum Kind { RangeK, SingleLocK, StmtK, DeclK } K;
-  SourceRange R;
-  const Stmt *S;
-  const Decl *D;
-  const SourceManager *SM;
-public:
-  PathDiagnosticLocation()
-    : K(SingleLocK), S(0), D(0), SM(0) {}
-
-  PathDiagnosticLocation(FullSourceLoc L)
-    : K(SingleLocK), R(L, L), S(0), D(0), SM(&L.getManager()) {}
-
-  PathDiagnosticLocation(const Stmt *s, const SourceManager &sm)
-    : K(StmtK), S(s), D(0), SM(&sm) {}
-
-  PathDiagnosticLocation(SourceRange r, const SourceManager &sm)
-    : K(RangeK), R(r), S(0), D(0), SM(&sm) {}
-
-  PathDiagnosticLocation(const Decl *d, const SourceManager &sm)
-    : K(DeclK), S(0), D(d), SM(&sm) {}
-
-  bool operator==(const PathDiagnosticLocation &X) const {
-    return K == X.K && R == X.R && S == X.S && D == X.D;
-  }
-
-  bool operator!=(const PathDiagnosticLocation &X) const {
-    return K != X.K || R != X.R || S != X.S || D != X.D;;
-  }
-
-  PathDiagnosticLocation& operator=(const PathDiagnosticLocation &X) {
-    K = X.K;
-    R = X.R;
-    S = X.S;
-    D = X.D;
-    SM = X.SM;
-    return *this;
-  }
-
-  bool isValid() const {
-    return SM != 0;
-  }
-
-  const SourceManager& getSourceManager() const { assert(isValid());return *SM;}
-
-  FullSourceLoc asLocation() const;
-  PathDiagnosticRange asRange() const;
-  const Stmt *asStmt() const { assert(isValid()); return S; }
-  const Decl *asDecl() const { assert(isValid()); return D; }
-
-  bool hasRange() const { return K == StmtK || K == RangeK || K == DeclK; }
-
-  void invalidate() {
-    *this = PathDiagnosticLocation();
-  }
-
-  void flatten();
-
-  const SourceManager& getManager() const { assert(isValid()); return *SM; }
-  
-  void Profile(llvm::FoldingSetNodeID &ID) 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 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:
-  enum Kind { ControlFlow, Event, Macro };
-  enum DisplayHint { Above, Below };
-
-private:
-  const std::string str;
-  std::vector<FixItHint> FixItHints;
-  const Kind kind;
-  const DisplayHint Hint;
-  std::vector<SourceRange> ranges;
-
-  // Do not implement:
-  PathDiagnosticPiece();
-  PathDiagnosticPiece(const PathDiagnosticPiece &P);
-  PathDiagnosticPiece& operator=(const PathDiagnosticPiece &P);
-
-protected:
-  PathDiagnosticPiece(llvm::StringRef s, Kind k, DisplayHint hint = Below);
-
-  PathDiagnosticPiece(Kind k, DisplayHint hint = Below);
-
-public:
-  virtual ~PathDiagnosticPiece();
-
-  const std::string& getString() const { return str; }
-
-  /// getDisplayHint - Return a hint indicating where the diagnostic should
-  ///  be displayed by the PathDiagnosticClient.
-  DisplayHint getDisplayHint() const { return Hint; }
-
-  virtual PathDiagnosticLocation getLocation() const = 0;
-  virtual void flattenLocations() = 0;
-
-  Kind getKind() const { return kind; }
-
-  void addRange(SourceRange R) { ranges.push_back(R); }
-
-  void addRange(SourceLocation B, SourceLocation E) {
-    ranges.push_back(SourceRange(B,E));
-  }
-
-  void addFixItHint(const FixItHint& Hint) {
-    FixItHints.push_back(Hint);
-  }
-
-  typedef const SourceRange* range_iterator;
-
-  range_iterator ranges_begin() const {
-    return ranges.empty() ? NULL : &ranges[0];
-  }
-
-  range_iterator ranges_end() const {
-    return ranges_begin() + ranges.size();
-  }
-
-  typedef const FixItHint *fixit_iterator;
-
-  fixit_iterator fixit_begin() const {
-    return FixItHints.empty()? 0 : &FixItHints[0];
-  }
-
-  fixit_iterator fixit_end() const {
-    return FixItHints.empty()? 0
-                   : &FixItHints[0] + FixItHints.size();
-  }
-
-  static inline bool classof(const PathDiagnosticPiece* P) {
-    return true;
-  }
-  
-  virtual void Profile(llvm::FoldingSetNodeID &ID) const;
-};
-
-class PathDiagnosticSpotPiece : public PathDiagnosticPiece {
-private:
-  PathDiagnosticLocation Pos;
-public:
-  PathDiagnosticSpotPiece(const PathDiagnosticLocation &pos,
-                          llvm::StringRef s,
-                          PathDiagnosticPiece::Kind k,
-                          bool addPosRange = true)
-  : PathDiagnosticPiece(s, k), Pos(pos) {
-    assert(Pos.asLocation().isValid() &&
-           "PathDiagnosticSpotPiece's must have a valid location.");
-    if (addPosRange && Pos.hasRange()) addRange(Pos.asRange());
-  }
-
-  PathDiagnosticLocation getLocation() const { return Pos; }
-  virtual void flattenLocations() { Pos.flatten(); }
-  
-  virtual void Profile(llvm::FoldingSetNodeID &ID) const;
-};
-
-class PathDiagnosticEventPiece : public PathDiagnosticSpotPiece {
-
-public:
-  PathDiagnosticEventPiece(const PathDiagnosticLocation &pos,
-                           llvm::StringRef s, bool addPosRange = true)
-    : PathDiagnosticSpotPiece(pos, s, Event, addPosRange) {}
-
-  ~PathDiagnosticEventPiece();
-
-  static inline bool classof(const PathDiagnosticPiece* P) {
-    return P->getKind() == Event;
-  }
-};
-
-class PathDiagnosticControlFlowPiece : public PathDiagnosticPiece {
-  std::vector<PathDiagnosticLocationPair> LPairs;
-public:
-  PathDiagnosticControlFlowPiece(const PathDiagnosticLocation &startPos,
-                                 const PathDiagnosticLocation &endPos,
-                                 llvm::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();
-
-  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 push_back(const PathDiagnosticLocationPair &X) { LPairs.push_back(X); }
-
-  virtual PathDiagnosticLocation getLocation() const {
-    return getStartLocation();
-  }
-
-  typedef std::vector<PathDiagnosticLocationPair>::iterator iterator;
-  iterator begin() { return LPairs.begin(); }
-  iterator end()   { return LPairs.end(); }
-
-  virtual void flattenLocations() {
-    for (iterator I=begin(), E=end(); I!=E; ++I) I->flatten();
-  }
-
-  typedef std::vector<PathDiagnosticLocationPair>::const_iterator
-          const_iterator;
-  const_iterator begin() const { return LPairs.begin(); }
-  const_iterator end() const   { return LPairs.end(); }
-
-  static inline bool classof(const PathDiagnosticPiece* P) {
-    return P->getKind() == ControlFlow;
-  }
-  
-  virtual void Profile(llvm::FoldingSetNodeID &ID) const;
-};
-
-class PathDiagnosticMacroPiece : public PathDiagnosticSpotPiece {
-  std::vector<PathDiagnosticPiece*> SubPieces;
-public:
-  PathDiagnosticMacroPiece(const PathDiagnosticLocation &pos)
-    : PathDiagnosticSpotPiece(pos, "", Macro) {}
-
-  ~PathDiagnosticMacroPiece();
-
-  bool containsEvent() const;
-
-  void push_back(PathDiagnosticPiece* P) { SubPieces.push_back(P); }
-
-  typedef std::vector<PathDiagnosticPiece*>::iterator iterator;
-  iterator begin() { return SubPieces.begin(); }
-  iterator end() { return SubPieces.end(); }
-
-  virtual void flattenLocations() {
-    PathDiagnosticSpotPiece::flattenLocations();
-    for (iterator I=begin(), E=end(); I!=E; ++I) (*I)->flattenLocations();
-  }
-
-  typedef std::vector<PathDiagnosticPiece*>::const_iterator const_iterator;
-  const_iterator begin() const { return SubPieces.begin(); }
-  const_iterator end() const { return SubPieces.end(); }
-
-  static inline bool classof(const PathDiagnosticPiece* P) {
-    return P->getKind() == Macro;
-  }
-  
-  virtual void Profile(llvm::FoldingSetNodeID &ID) const;
-};
-
-/// 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::deque<PathDiagnosticPiece*> path;
-  unsigned Size;
-  std::string BugType;
-  std::string Desc;
-  std::string Category;
-  std::deque<std::string> OtherDesc;
-
-public:
-  PathDiagnostic();
-
-  PathDiagnostic(llvm::StringRef bugtype, llvm::StringRef desc,
-                 llvm::StringRef category);
-
-  ~PathDiagnostic();
-
-  llvm::StringRef getDescription() const { return Desc; }
-  llvm::StringRef getBugType() const { return BugType; }
-  llvm::StringRef getCategory() const { return Category; }
-
-  typedef std::deque<std::string>::const_iterator meta_iterator;
-  meta_iterator meta_begin() const { return OtherDesc.begin(); }
-  meta_iterator meta_end() const { return OtherDesc.end(); }
-  void addMeta(llvm::StringRef s) { OtherDesc.push_back(s); }
-
-  PathDiagnosticLocation getLocation() const {
-    assert(Size > 0 && "getLocation() requires a non-empty PathDiagnostic.");
-    return rbegin()->getLocation();
-  }
-
-  void push_front(PathDiagnosticPiece* piece) {
-    assert(piece);
-    path.push_front(piece);
-    ++Size;
-  }
-
-  void push_back(PathDiagnosticPiece* piece) {
-    assert(piece);
-    path.push_back(piece);
-    ++Size;
-  }
-
-  PathDiagnosticPiece* back() {
-    return path.back();
-  }
-
-  const PathDiagnosticPiece* back() const {
-    return path.back();
-  }
-
-  unsigned size() const { return Size; }
-  bool empty() const { return Size == 0; }
-
-  void resetPath(bool deletePieces = true);
-
-  class iterator {
-  public:
-    typedef std::deque<PathDiagnosticPiece*>::iterator ImplTy;
-
-    typedef PathDiagnosticPiece              value_type;
-    typedef value_type&                      reference;
-    typedef value_type*                      pointer;
-    typedef ptrdiff_t                        difference_type;
-    typedef std::bidirectional_iterator_tag  iterator_category;
-
-  private:
-    ImplTy I;
-
-  public:
-    iterator(const ImplTy& i) : I(i) {}
-
-    bool operator==(const iterator& X) const { return I == X.I; }
-    bool operator!=(const iterator& X) const { return I != X.I; }
-
-    PathDiagnosticPiece& operator*() const { return **I; }
-    PathDiagnosticPiece* operator->() const { return *I; }
-
-    iterator& operator++() { ++I; return *this; }
-    iterator& operator--() { --I; return *this; }
-  };
-
-  class const_iterator {
-  public:
-    typedef std::deque<PathDiagnosticPiece*>::const_iterator ImplTy;
-
-    typedef const PathDiagnosticPiece        value_type;
-    typedef value_type&                      reference;
-    typedef value_type*                      pointer;
-    typedef ptrdiff_t                        difference_type;
-    typedef std::bidirectional_iterator_tag  iterator_category;
-
-  private:
-    ImplTy I;
-
-  public:
-    const_iterator(const ImplTy& i) : I(i) {}
-
-    bool operator==(const const_iterator& X) const { return I == X.I; }
-    bool operator!=(const const_iterator& X) const { return I != X.I; }
-
-    reference operator*() const { return **I; }
-    pointer operator->() const { return *I; }
-
-    const_iterator& operator++() { ++I; return *this; }
-    const_iterator& operator--() { --I; return *this; }
-  };
-
-  typedef std::reverse_iterator<iterator>       reverse_iterator;
-  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-
-  // forward iterator creation methods.
-
-  iterator begin() { return path.begin(); }
-  iterator end() { return path.end(); }
-
-  const_iterator begin() const { return path.begin(); }
-  const_iterator end() const { return path.end(); }
-
-  // reverse iterator creation methods.
-  reverse_iterator rbegin()            { return reverse_iterator(end()); }
-  const_reverse_iterator rbegin() const{ return const_reverse_iterator(end()); }
-  reverse_iterator rend()              { return reverse_iterator(begin()); }
-  const_reverse_iterator rend() const { return const_reverse_iterator(begin());}
-
-  void flattenLocations() {
-    for (iterator I = begin(), E = end(); I != E; ++I) I->flattenLocations();
-  }
-  
-  void Profile(llvm::FoldingSetNodeID &ID) const;
-};  
-} //end clang namespace
-#endif