Rename SymbolID to SymbolRef. This is a precursor to some overhauling of the representation of symbolic values.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@60575 91177308-0d34-0410-b5e6-96231b3b80d8

19 files changed, 149 insertions, 149 deletions

diff --git a/include/clang/Analysis/PathSensitive/BasicValueFactory.h b/include/clang/Analysis/PathSensitive/BasicValueFactory.h
index 70fbe1de83..bf6bb8c807 100644
--- a/include/clang/Analysis/PathSensitive/BasicValueFactory.h
+++ b/include/clang/Analysis/PathSensitive/BasicValueFactory.h
@@ -84,7 +84,7 @@ public:
     return getValue(b ? 1 : 0, Ctx.getTypeSize(Ctx.IntTy), false);
   }
 
-  const SymIntConstraint& getConstraint(SymbolID sym, BinaryOperator::Opcode Op,
+  const SymIntConstraint& getConstraint(SymbolRef sym, BinaryOperator::Opcode Op,
                                         const llvm::APSInt& V);
 
   const CompoundValData* getCompoundValData(QualType T, 
diff --git a/include/clang/Analysis/PathSensitive/BugReporter.h b/include/clang/Analysis/PathSensitive/BugReporter.h
index d62fe61f71..5613ad839b 100644
--- a/include/clang/Analysis/PathSensitive/BugReporter.h
+++ b/include/clang/Analysis/PathSensitive/BugReporter.h
@@ -236,7 +236,7 @@ public:
   
 class GRBugReporter : public BugReporter {
   GRExprEngine& Eng;
-  llvm::SmallSet<SymbolID, 10> NotableSymbols;
+  llvm::SmallSet<SymbolRef, 10> NotableSymbols;
 public:
   
   GRBugReporter(BugReporterData& d, GRExprEngine& eng)
@@ -260,11 +260,11 @@ public:
   
   virtual void GeneratePathDiagnostic(PathDiagnostic& PD, BugReport& R);
 
-  void addNotableSymbol(SymbolID Sym) {
+  void addNotableSymbol(SymbolRef Sym) {
     NotableSymbols.insert(Sym);
   }
   
-  bool isNotable(SymbolID Sym) const {
+  bool isNotable(SymbolRef Sym) const {
     return (bool) NotableSymbols.count(Sym);
   }
     
diff --git a/include/clang/Analysis/PathSensitive/ConstraintManager.h b/include/clang/Analysis/PathSensitive/ConstraintManager.h
index 54cdecbf21..cec7f69df3 100644
--- a/include/clang/Analysis/PathSensitive/ConstraintManager.h
+++ b/include/clang/Analysis/PathSensitive/ConstraintManager.h
@@ -26,7 +26,7 @@ namespace clang {
 class GRState;
 class GRStateManager;
 class SVal;
-class SymbolID;
+class SymbolRef;
 
 class ConstraintManager {
 public:
@@ -38,11 +38,11 @@ public:
                                        SVal UpperBound, bool Assumption,
                                        bool& isFeasible) = 0;
 
-  virtual const GRState* AddNE(const GRState* St, SymbolID sym, 
+  virtual const GRState* AddNE(const GRState* St, SymbolRef sym, 
                                const llvm::APSInt& V) = 0;
-  virtual const llvm::APSInt* getSymVal(const GRState* St, SymbolID sym) = 0;
+  virtual const llvm::APSInt* getSymVal(const GRState* St, SymbolRef sym) = 0;
 
-  virtual bool isEqual(const GRState* St, SymbolID sym, 
+  virtual bool isEqual(const GRState* St, SymbolRef sym, 
                        const llvm::APSInt& V) const = 0;
 
   virtual const GRState* RemoveDeadBindings(const GRState* St,
diff --git a/include/clang/Analysis/PathSensitive/GRState.h b/include/clang/Analysis/PathSensitive/GRState.h
index 6efafd6f0c..71990b0e65 100644
--- a/include/clang/Analysis/PathSensitive/GRState.h
+++ b/include/clang/Analysis/PathSensitive/GRState.h
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-//  This file defines SymbolID, ExprBindKey, and GRState*
+//  This file defines SymbolRef, ExprBindKey, and GRState*
 //
 //===----------------------------------------------------------------------===//
 
@@ -535,11 +535,11 @@ public:
                                         isFeasible);
   }
 
-  const GRState* AddNE(const GRState* St, SymbolID sym, const llvm::APSInt& V) {
+  const GRState* AddNE(const GRState* St, SymbolRef sym, const llvm::APSInt& V) {
     return ConstraintMgr->AddNE(St, sym, V);
   }
 
-  const llvm::APSInt* getSymVal(const GRState* St, SymbolID sym) {
+  const llvm::APSInt* getSymVal(const GRState* St, SymbolRef sym) {
     return ConstraintMgr->getSymVal(St, sym);
   }
 
@@ -605,7 +605,7 @@ public:
     return GRStateRef(Mgr->Unbind(St, LV), *Mgr);
   }
   
-  GRStateRef AddNE(SymbolID sym, const llvm::APSInt& V) {
+  GRStateRef AddNE(SymbolRef sym, const llvm::APSInt& V) {
     return GRStateRef(Mgr->AddNE(St, sym, V), *Mgr);
   }
   
diff --git a/include/clang/Analysis/PathSensitive/MemRegion.h b/include/clang/Analysis/PathSensitive/MemRegion.h
index 35df7df5f4..22e3bda05f 100644
--- a/include/clang/Analysis/PathSensitive/MemRegion.h
+++ b/include/clang/Analysis/PathSensitive/MemRegion.h
@@ -140,17 +140,17 @@ public:
 ///  regions do not need to be typed.
 class SymbolicRegion : public MemRegion {
 protected:
-  const SymbolID sym;
+  const SymbolRef sym;
 
 public:
-  SymbolicRegion(const SymbolID s) : MemRegion(SymbolicRegionKind), sym(s) {}
+  SymbolicRegion(const SymbolRef s) : MemRegion(SymbolicRegionKind), sym(s) {}
     
-  SymbolID getSymbol() const {
+  SymbolRef getSymbol() const {
     return sym;
   }
     
   void Profile(llvm::FoldingSetNodeID& ID) const;
-  static void ProfileRegion(llvm::FoldingSetNodeID& ID, SymbolID sym);
+  static void ProfileRegion(llvm::FoldingSetNodeID& ID, SymbolRef sym);
   
   void print(llvm::raw_ostream& os) const;
   
@@ -507,9 +507,9 @@ public:
 ///  the sizes of dynamically allocated chunks of memory with variable size.
 class SymbolicExtent : public RegionExtent {
 public:
-  SymbolicExtent(SymbolID S) : RegionExtent(S.getNumber() << 1, Sym) {}
+  SymbolicExtent(SymbolRef S) : RegionExtent(S.getNumber() << 1, Sym) {}
 
-  SymbolID getSymbol() const { return SymbolID(getData() >> 1); }
+  SymbolRef getSymbol() const { return SymbolRef(getData() >> 1); }
 
   // Implement isa<T> support.
   static inline bool classof(const RegionExtent* E) {
@@ -567,7 +567,7 @@ public:
   getCompoundLiteralRegion(const CompoundLiteralExpr* CL);  
   
   /// getSymbolicRegion - Retrieve or create a "symbolic" memory region.
-  SymbolicRegion* getSymbolicRegion(const SymbolID sym);
+  SymbolicRegion* getSymbolicRegion(const SymbolRef sym);
 
   StringRegion* getStringRegion(const StringLiteral* Str);
 
diff --git a/include/clang/Analysis/PathSensitive/SVals.h b/include/clang/Analysis/PathSensitive/SVals.h
index ca78f66099..45435b0dae 100644
--- a/include/clang/Analysis/PathSensitive/SVals.h
+++ b/include/clang/Analysis/PathSensitive/SVals.h
@@ -102,7 +102,7 @@ public:
   
   class symbol_iterator {
     const enum { One, Many } HowMany;
-    union { uintptr_t sym; const SymbolID* sptr; };
+    union { uintptr_t sym; const SymbolRef* sptr; };
   public:
     
     bool operator==(const symbol_iterator& X) {
@@ -122,16 +122,16 @@ public:
       return *this;
     }
     
-    SymbolID operator*() const {
+    SymbolRef operator*() const {
       if (HowMany)
         return *sptr;
       
-      return SymbolID(sym);
+      return SymbolRef(sym);
     }
     
-    symbol_iterator(SymbolID x) : HowMany(One), sym(x.getNumber()) {}
+    symbol_iterator(SymbolRef x) : HowMany(One), sym(x.getNumber()) {}
     symbol_iterator() : HowMany(One), sym(~0x0) {}
-    symbol_iterator(const SymbolID* x) : HowMany(Many), sptr(x) {}
+    symbol_iterator(const SymbolRef* x) : HowMany(Many), sptr(x) {}
   };
   
   symbol_iterator symbol_begin() const;
@@ -238,8 +238,8 @@ public:
   SymbolVal(unsigned SymID)
     : NonLoc(SymbolValKind, reinterpret_cast<void*>((uintptr_t) SymID)) {}
   
-  SymbolID getSymbol() const {
-    return (SymbolID) reinterpret_cast<uintptr_t>(Data);
+  SymbolRef getSymbol() const {
+    return (SymbolRef) reinterpret_cast<uintptr_t>(Data);
   }
   
   static inline bool classof(const SVal* V) {
@@ -371,8 +371,8 @@ public:
   SymbolVal(unsigned SymID)
   : Loc(SymbolValKind, reinterpret_cast<void*>((uintptr_t) SymID)) {}
   
-  SymbolID getSymbol() const {
-    return (SymbolID) reinterpret_cast<uintptr_t>(Data);
+  SymbolRef getSymbol() const {
+    return (SymbolRef) reinterpret_cast<uintptr_t>(Data);
   }
   
   static inline bool classof(const SVal* V) {
diff --git a/include/clang/Analysis/PathSensitive/Store.h b/include/clang/Analysis/PathSensitive/Store.h
index a272f05867..5e654a86bd 100644
--- a/include/clang/Analysis/PathSensitive/Store.h
+++ b/include/clang/Analysis/PathSensitive/Store.h
@@ -35,8 +35,8 @@ class ObjCIvarDecl;
 
 class StoreManager {
 public:
-  typedef llvm::SmallSet<SymbolID, 20>      LiveSymbolsTy;
-  typedef llvm::DenseSet<SymbolID>          DeadSymbolsTy;
+  typedef llvm::SmallSet<SymbolRef, 20>      LiveSymbolsTy;
+  typedef llvm::DenseSet<SymbolRef>          DeadSymbolsTy;
   
   virtual ~StoreManager() {}
   
diff --git a/include/clang/Analysis/PathSensitive/SymbolManager.h b/include/clang/Analysis/PathSensitive/SymbolManager.h
index 1f548b4645..9d495bee5f 100644
--- a/include/clang/Analysis/PathSensitive/SymbolManager.h
+++ b/include/clang/Analysis/PathSensitive/SymbolManager.h
@@ -27,11 +27,11 @@ namespace clang {
 class MemRegion;
 class SymbolManager;
 
-class SymbolID {
+class SymbolRef {
   unsigned Data;
 public:
-  SymbolID() : Data(~0U - 2) {}
-  SymbolID(unsigned x) : Data(x) {}
+  SymbolRef() : Data(~0U - 2) {}
+  SymbolRef(unsigned x) : Data(x) {}
     
   bool isInitialized() const { return Data != (unsigned) (~0U - 2); }
   operator unsigned() const { return getNumber(); }
@@ -46,17 +46,17 @@ public:
 } // end clang namespace
 
 namespace llvm {
-  template <> struct DenseMapInfo<clang::SymbolID> {
-    static inline clang::SymbolID getEmptyKey() {
-      return clang::SymbolID(~0U);
+  template <> struct DenseMapInfo<clang::SymbolRef> {
+    static inline clang::SymbolRef getEmptyKey() {
+      return clang::SymbolRef(~0U);
     }
-    static inline clang::SymbolID getTombstoneKey() {
-      return clang::SymbolID(~0U - 1);
+    static inline clang::SymbolRef getTombstoneKey() {
+      return clang::SymbolRef(~0U - 1);
     }
-    static unsigned getHashValue(clang::SymbolID X) {
+    static unsigned getHashValue(clang::SymbolRef X) {
       return X.getNumber();
     }
-    static bool isEqual(clang::SymbolID X, clang::SymbolID Y) {
+    static bool isEqual(clang::SymbolRef X, clang::SymbolRef Y) {
       return X.getNumber() == Y.getNumber();
     }
     static bool isPod() { return true; }
@@ -74,17 +74,17 @@ public:
   
 private:
   Kind K;
-  SymbolID Sym;
+  SymbolRef Sym;
   
 protected:
-  SymbolData(Kind k, SymbolID sym) : K(k), Sym(sym) {}  
+  SymbolData(Kind k, SymbolRef sym) : K(k), Sym(sym) {}  
 
 public:
   virtual ~SymbolData() {}
   
   Kind getKind() const { return K; }  
   
-  SymbolID getSymbol() const { return Sym; }
+  SymbolRef getSymbol() const { return Sym; }
     
   QualType getType(const SymbolManager& SymMgr) const;
   
@@ -98,7 +98,7 @@ class SymbolDataParmVar : public SymbolData {
   ParmVarDecl *VD;
 
 public:  
-  SymbolDataParmVar(SymbolID MySym, ParmVarDecl* vd)
+  SymbolDataParmVar(SymbolRef MySym, ParmVarDecl* vd)
     : SymbolData(ParmKind, MySym), VD(vd) {}
   
   ParmVarDecl* getDecl() const { return VD; }  
@@ -122,7 +122,7 @@ class SymbolDataGlobalVar : public SymbolData {
   VarDecl *VD;
 
 public:
-  SymbolDataGlobalVar(SymbolID MySym, VarDecl* vd) :
+  SymbolDataGlobalVar(SymbolRef MySym, VarDecl* vd) :
     SymbolData(GlobalKind, MySym), VD(vd) {}
   
   VarDecl* getDecl() const { return VD; }
@@ -147,7 +147,7 @@ class SymbolDataElement : public SymbolData {
   const llvm::APSInt* Idx;
 
 public:
-  SymbolDataElement(SymbolID MySym, const MemRegion* r, const llvm::APSInt* idx)
+  SymbolDataElement(SymbolRef MySym, const MemRegion* r, const llvm::APSInt* idx)
     : SymbolData(ElementKind, MySym), R(r), Idx(idx) {}
 
   static void Profile(llvm::FoldingSetNodeID& profile, const MemRegion* R, 
@@ -170,7 +170,7 @@ class SymbolDataField : public SymbolData {
   const FieldDecl* D;
 
 public:
-  SymbolDataField(SymbolID MySym, const MemRegion* r, const FieldDecl* d)
+  SymbolDataField(SymbolRef MySym, const MemRegion* r, const FieldDecl* d)
     : SymbolData(FieldKind, MySym), R(r), D(d) {}
 
   static void Profile(llvm::FoldingSetNodeID& profile, const MemRegion* R,
@@ -194,7 +194,7 @@ class SymbolConjured : public SymbolData {
   unsigned Count;
 
 public:
-  SymbolConjured(SymbolID Sym, Stmt* s, QualType t, unsigned count)
+  SymbolConjured(SymbolRef Sym, Stmt* s, QualType t, unsigned count)
     : SymbolData(ConjuredKind, Sym), S(s), T(t), Count(count) {}
   
   Stmt* getStmt() const { return S; }
@@ -223,21 +223,21 @@ public:
 // Constraints on symbols.  Usually wrapped by SValues.
 
 class SymIntConstraint : public llvm::FoldingSetNode {
-  SymbolID Symbol;
+  SymbolRef Symbol;
   BinaryOperator::Opcode Op;
   const llvm::APSInt& Val;
 public:  
-  SymIntConstraint(SymbolID sym, BinaryOperator::Opcode op, 
+  SymIntConstraint(SymbolRef sym, BinaryOperator::Opcode op, 
                    const llvm::APSInt& V)
   : Symbol(sym),
   Op(op), Val(V) {}
   
   BinaryOperator::Opcode getOpcode() const { return Op; }
-  const SymbolID& getSymbol() const { return Symbol; }
+  const SymbolRef& getSymbol() const { return Symbol; }
   const llvm::APSInt& getInt() const { return Val; }
   
   static inline void Profile(llvm::FoldingSetNodeID& ID,
-                             SymbolID Symbol,
+                             SymbolRef Symbol,
                              BinaryOperator::Opcode Op,
                              const llvm::APSInt& Val) {
     Symbol.Profile(ID);
@@ -253,7 +253,7 @@ public:
 
 class SymbolManager {
   typedef llvm::FoldingSet<SymbolData> DataSetTy;
-  typedef llvm::DenseMap<SymbolID, SymbolData*> DataMapTy;
+  typedef llvm::DenseMap<SymbolRef, SymbolData*> DataMapTy;
   
   DataSetTy DataSet;
   DataMapTy DataMap;
@@ -267,17 +267,17 @@ public:
   
   ~SymbolManager();
   
-  SymbolID getSymbol(VarDecl* D);
-  SymbolID getElementSymbol(const MemRegion* R, const llvm::APSInt* Idx);
-  SymbolID getFieldSymbol(const MemRegion* R, const FieldDecl* D);
-  SymbolID getConjuredSymbol(Stmt* E, QualType T, unsigned VisitCount);
-  SymbolID getConjuredSymbol(Expr* E, unsigned VisitCount) {
+  SymbolRef getSymbol(VarDecl* D);
+  SymbolRef getElementSymbol(const MemRegion* R, const llvm::APSInt* Idx);
+  SymbolRef getFieldSymbol(const MemRegion* R, const FieldDecl* D);
+  SymbolRef getConjuredSymbol(Stmt* E, QualType T, unsigned VisitCount);
+  SymbolRef getConjuredSymbol(Expr* E, unsigned VisitCount) {
     return getConjuredSymbol(E, E->getType(), VisitCount);
   }
   
-  const SymbolData& getSymbolData(SymbolID ID) const;
+  const SymbolData& getSymbolData(SymbolRef ID) const;
   
-  QualType getType(SymbolID ID) const {
+  QualType getType(SymbolRef ID) const {
     return getSymbolData(ID).getType(*this);
   }
 };
diff --git a/lib/Analysis/BasicConstraintManager.cpp b/lib/Analysis/BasicConstraintManager.cpp
index f4290ffb67..7c303b2ac3 100644
--- a/lib/Analysis/BasicConstraintManager.cpp
+++ b/lib/Analysis/BasicConstraintManager.cpp
@@ -22,8 +22,8 @@ using namespace clang;
 
 namespace {
 
-typedef llvm::ImmutableMap<SymbolID,GRState::IntSetTy> ConstNotEqTy;
-typedef llvm::ImmutableMap<SymbolID,const llvm::APSInt*> ConstEqTy;
+typedef llvm::ImmutableMap<SymbolRef,GRState::IntSetTy> ConstNotEqTy;
+typedef llvm::ImmutableMap<SymbolRef,const llvm::APSInt*> ConstEqTy;
 
 // BasicConstraintManager only tracks equality and inequality constraints of
 // constants and integer variables.
@@ -52,34 +52,34 @@ public:
   const GRState* AssumeSymInt(const GRState* St, bool Assumption,
                               const SymIntConstraint& C, bool& isFeasible);
 
-  const GRState* AssumeSymNE(const GRState* St, SymbolID sym,
+  const GRState* AssumeSymNE(const GRState* St, SymbolRef sym,
                                 const llvm::APSInt& V, bool& isFeasible);
 
-  const GRState* AssumeSymEQ(const GRState* St, SymbolID sym,
+  const GRState* AssumeSymEQ(const GRState* St, SymbolRef sym,
                                 const llvm::APSInt& V, bool& isFeasible);
 
-  const GRState* AssumeSymLT(const GRState* St, SymbolID sym,
+  const GRState* AssumeSymLT(const GRState* St, SymbolRef sym,
                                     const llvm::APSInt& V, bool& isFeasible);
 
-  const GRState* AssumeSymGT(const GRState* St, SymbolID sym,
+  const GRState* AssumeSymGT(const GRState* St, SymbolRef sym,
                              const llvm::APSInt& V, bool& isFeasible);
 
-  const GRState* AssumeSymGE(const GRState* St, SymbolID sym,
+  const GRState* AssumeSymGE(const GRState* St, SymbolRef sym,
                              const llvm::APSInt& V, bool& isFeasible);
 
-  const GRState* AssumeSymLE(const GRState* St, SymbolID sym,
+  const GRState* AssumeSymLE(const GRState* St, SymbolRef sym,
                              const llvm::APSInt& V, bool& isFeasible);
 
   const GRState* AssumeInBound(const GRState* St, SVal Idx, SVal UpperBound,
                                bool Assumption, bool& isFeasible);
 
-  const GRState* AddEQ(const GRState* St, SymbolID sym, const llvm::APSInt& V);
+  const GRState* AddEQ(const GRState* St, SymbolRef sym, const llvm::APSInt& V);
 
-  const GRState* AddNE(const GRState* St, SymbolID sym, const llvm::APSInt& V);
+  const GRState* AddNE(const GRState* St, SymbolRef sym, const llvm::APSInt& V);
 
-  const llvm::APSInt* getSymVal(const GRState* St, SymbolID sym);
-  bool isNotEqual(const GRState* St, SymbolID sym, const llvm::APSInt& V) const;
-  bool isEqual(const GRState* St, SymbolID sym, const llvm::APSInt& V) const;
+  const llvm::APSInt* getSymVal(const GRState* St, SymbolRef sym);
+  bool isNotEqual(const GRState* St, SymbolRef sym, const llvm::APSInt& V) const;
+  bool isEqual(const GRState* St, SymbolRef sym, const llvm::APSInt& V) const;
 
   const GRState* RemoveDeadBindings(const GRState* St,
                                     StoreManager::LiveSymbolsTy& LSymbols,
@@ -189,7 +189,7 @@ BasicConstraintManager::AssumeAux(const GRState* St,NonLoc Cond,
 
   case nonloc::SymbolValKind: {
     nonloc::SymbolVal& SV = cast<nonloc::SymbolVal>(Cond);
-    SymbolID sym = SV.getSymbol();
+    SymbolRef sym = SV.getSymbol();
 
     if (Assumption)
       return AssumeSymNE(St, sym, BasicVals.getValue(0, SymMgr.getType(sym)),
@@ -266,7 +266,7 @@ BasicConstraintManager::AssumeSymInt(const GRState* St, bool Assumption,
 }
 
 const GRState*
-BasicConstraintManager::AssumeSymNE(const GRState* St, SymbolID sym,
+BasicConstraintManager::AssumeSymNE(const GRState* St, SymbolRef sym,
                                     const llvm::APSInt& V, bool& isFeasible) {
   // First, determine if sym == X, where X != V.
   if (const llvm::APSInt* X = getSymVal(St, sym)) {
@@ -287,7 +287,7 @@ BasicConstraintManager::AssumeSymNE(const GRState* St, SymbolID sym,
 }
 
 const GRState*
-BasicConstraintManager::AssumeSymEQ(const GRState* St, SymbolID sym,
+BasicConstraintManager::AssumeSymEQ(const GRState* St, SymbolRef sym,
                                     const llvm::APSInt& V, bool& isFeasible) {
   // First, determine if sym == X, where X != V.
   if (const llvm::APSInt* X = getSymVal(St, sym)) {
@@ -310,7 +310,7 @@ BasicConstraintManager::AssumeSymEQ(const GRState* St, SymbolID sym,
 
 // These logic will be handled in another ConstraintManager.
 const GRState*
-BasicConstraintManager::AssumeSymLT(const GRState* St, SymbolID sym,
+BasicConstraintManager::AssumeSymLT(const GRState* St, SymbolRef sym,
                                     const llvm::APSInt& V, bool& isFeasible) {
   
   // Is 'V' the smallest possible value?
@@ -325,7 +325,7 @@ BasicConstraintManager::AssumeSymLT(const GRState* St, SymbolID sym,
 }
 
 const GRState*
-BasicConstraintManager::AssumeSymGT(const GRState* St, SymbolID sym,
+BasicConstraintManager::AssumeSymGT(const GRState* St, SymbolRef sym,
                                     const llvm::APSInt& V, bool& isFeasible) {
 
   // Is 'V' the largest possible value?
@@ -340,7 +340,7 @@ BasicConstraintManager::AssumeSymGT(const GRState* St, SymbolID sym,
 }
 
 const GRState*
-BasicConstraintManager::AssumeSymGE(const GRState* St, SymbolID sym,
+BasicConstraintManager::AssumeSymGE(const GRState* St, SymbolRef sym,
                                     const llvm::APSInt& V, bool& isFeasible) {
 
   // Reject a path if the value of sym is a constant X and !(X >= V).
@@ -369,7 +369,7 @@ BasicConstraintManager::AssumeSymGE(const GRState* St, SymbolID sym,
 }
 
 const GRState*
-BasicConstraintManager::AssumeSymLE(const GRState* St, SymbolID sym,
+BasicConstraintManager::AssumeSymLE(const GRState* St, SymbolRef sym,
                                     const llvm::APSInt& V, bool& isFeasible) {
 
   // Reject a path if the value of sym is a constant X and !(X <= V).
@@ -439,14 +439,14 @@ namespace clang {
   };
 }
 
-const GRState* BasicConstraintManager::AddEQ(const GRState* St, SymbolID sym,
+const GRState* BasicConstraintManager::AddEQ(const GRState* St, SymbolRef sym,
                                              const llvm::APSInt& V) {
   // Create a new state with the old binding replaced.
   GRStateRef state(St, StateMgr);
   return state.set<ConstEqTy>(sym, &V);
 }
 
-const GRState* BasicConstraintManager::AddNE(const GRState* St, SymbolID sym,
+const GRState* BasicConstraintManager::AddNE(const GRState* St, SymbolRef sym,
                                              const llvm::APSInt& V) {
 
   GRStateRef state(St, StateMgr);
@@ -464,12 +464,12 @@ const GRState* BasicConstraintManager::AddNE(const GRState* St, SymbolID sym,
 }
 
 const llvm::APSInt* BasicConstraintManager::getSymVal(const GRState* St,
-                                                      SymbolID sym) {
+                                                      SymbolRef sym) {
   const ConstEqTy::data_type* T = St->get<ConstEqTy>(sym);
   return T ? *T : NULL;  
 }
 
-bool BasicConstraintManager::isNotEqual(const GRState* St, SymbolID sym, 
+bool BasicConstraintManager::isNotEqual(const GRState* St, SymbolRef sym, 
                                         const llvm::APSInt& V) const {
 
   // Retrieve the NE-set associated with the given symbol.
@@ -479,7 +479,7 @@ bool BasicConstraintManager::isNotEqual(const GRState* St, SymbolID sym,
   return T ? T->contains(&V) : false;
 }
 
-bool BasicConstraintManager::isEqual(const GRState* St, SymbolID sym,
+bool BasicConstraintManager::isEqual(const GRState* St, SymbolRef sym,
                                      const llvm::APSInt& V) const {
   // Retrieve the EQ-set associated with the given symbol.
   const ConstEqTy::data_type* T = St->get<ConstEqTy>(sym);
@@ -497,7 +497,7 @@ const GRState* BasicConstraintManager::RemoveDeadBindings(const GRState* St,
   ConstEqTy::Factory& CEFactory = state.get_context<ConstEqTy>();
 
   for (ConstEqTy::iterator I = CE.begin(), E = CE.end(); I!=E; ++I) {
-    SymbolID sym = I.getKey();        
+    SymbolRef sym = I.getKey();        
     if (!LSymbols.count(sym)) {
       DSymbols.insert(sym);
       CE = CEFactory.Remove(CE, sym);
@@ -509,7 +509,7 @@ const GRState* BasicConstraintManager::RemoveDeadBindings(const GRState* St,
   ConstNotEqTy::Factory& CNEFactory = state.get_context<ConstNotEqTy>();
 
   for (ConstNotEqTy::iterator I = CNE.begin(), E = CNE.end(); I != E; ++I) {
-    SymbolID sym = I.getKey();    
+    SymbolRef sym = I.getKey();    
     if (!LSymbols.count(sym)) {
       DSymbols.insert(sym);
       CNE = CNEFactory.Remove(CNE, sym);
diff --git a/lib/Analysis/BasicValueFactory.cpp b/lib/Analysis/BasicValueFactory.cpp
index 7ce305e4cf..2c7d6a37c1 100644
--- a/lib/Analysis/BasicValueFactory.cpp
+++ b/lib/Analysis/BasicValueFactory.cpp
@@ -98,7 +98,7 @@ const llvm::APSInt& BasicValueFactory::getValue(uint64_t X, QualType T) {
 }
 
 const SymIntConstraint&
-BasicValueFactory::getConstraint(SymbolID sym, BinaryOperator::Opcode Op,
+BasicValueFactory::getConstraint(SymbolRef sym, BinaryOperator::Opcode Op,
                             const llvm::APSInt& V) {
   
   llvm::FoldingSetNodeID ID;
diff --git a/lib/Analysis/BugReporter.cpp b/lib/Analysis/BugReporter.cpp
index 905c697ffb..8274ce71ff 100644
--- a/lib/Analysis/BugReporter.cpp
+++ b/lib/Analysis/BugReporter.cpp
@@ -326,7 +326,7 @@ namespace {
 class VISIBILITY_HIDDEN NotableSymbolHandler 
   : public StoreManager::BindingsHandler {
     
-  SymbolID Sym;
+  SymbolRef Sym;
   const GRState* PrevSt;
   Stmt* S;
   GRStateManager& VMgr;
@@ -336,14 +336,14 @@ class VISIBILITY_HIDDEN NotableSymbolHandler
     
 public:
   
-  NotableSymbolHandler(SymbolID sym, const GRState* prevst, Stmt* s,
+  NotableSymbolHandler(SymbolRef sym, const GRState* prevst, Stmt* s,
                        GRStateManager& vmgr, ExplodedNode<GRState>* pred,
                        PathDiagnostic& pd, BugReporter& br)
     : Sym(sym), PrevSt(prevst), S(s), VMgr(vmgr), Pred(pred), PD(pd), BR(br) {}
                         
   bool HandleBinding(StoreManager& SMgr, Store store, MemRegion* R, SVal V) {
 
-    SymbolID ScanSym;
+    SymbolRef ScanSym;
     
     if (loc::SymbolVal* SV = dyn_cast<loc::SymbolVal>(&V))
       ScanSym = SV->getSymbol();
@@ -412,7 +412,7 @@ public:
 }
 
 static void HandleNotableSymbol(ExplodedNode<GRState>* N, Stmt* S,
-                                SymbolID Sym, BugReporter& BR,
+                                SymbolRef Sym, BugReporter& BR,
                                 PathDiagnostic& PD) {
   
   ExplodedNode<GRState>* Pred = N->pred_empty() ? 0 : *N->pred_begin();
@@ -432,7 +432,7 @@ namespace {
 class VISIBILITY_HIDDEN ScanNotableSymbols
   : public StoreManager::BindingsHandler {
     
-  llvm::SmallSet<SymbolID, 10> AlreadyProcessed;
+  llvm::SmallSet<SymbolRef, 10> AlreadyProcessed;
   ExplodedNode<GRState>* N;
   Stmt* S;
   GRBugReporter& BR;
@@ -444,7 +444,7 @@ public:
     : N(n), S(s), BR(br), PD(pd) {}
   
   bool HandleBinding(StoreManager& SMgr, Store store, MemRegion* R, SVal V) {
-    SymbolID ScanSym;
+    SymbolRef ScanSym;
   
     if (loc::SymbolVal* SV = dyn_cast<loc::SymbolVal>(&V))
       ScanSym = SV->getSymbol();
diff --git a/lib/Analysis/CFRefCount.cpp b/lib/Analysis/CFRefCount.cpp
index 461754efb8..cb0cbd1681 100644
--- a/lib/Analysis/CFRefCount.cpp
+++ b/lib/Analysis/CFRefCount.cpp
@@ -1267,7 +1267,7 @@ void RefVal::print(std::ostream& Out) const {
 // RefBindings - State used to track object reference counts.
 //===----------------------------------------------------------------------===//
   
-typedef llvm::ImmutableMap<SymbolID, RefVal> RefBindings;
+typedef llvm::ImmutableMap<SymbolRef, RefVal> RefBindings;
 static int RefBIndex = 0;
 
 namespace clang {
@@ -1281,8 +1281,8 @@ namespace clang {
 // ARBindings - State used to track objects in autorelease pools.
 //===----------------------------------------------------------------------===//
 
-typedef llvm::ImmutableSet<SymbolID> ARPoolContents;
-typedef llvm::ImmutableList< std::pair<SymbolID, ARPoolContents*> > ARBindings;
+typedef llvm::ImmutableSet<SymbolRef> ARPoolContents;
+typedef llvm::ImmutableList< std::pair<SymbolRef, ARPoolContents*> > ARBindings;
 static int AutoRBIndex = 0;
 
 namespace clang {
@@ -1301,13 +1301,13 @@ namespace {
 class VISIBILITY_HIDDEN CFRefCount : public GRSimpleVals {
 public:
   // Type definitions.  
-  typedef llvm::DenseMap<GRExprEngine::NodeTy*,std::pair<Expr*, SymbolID> >
+  typedef llvm::DenseMap<GRExprEngine::NodeTy*,std::pair<Expr*, SymbolRef> >
           ReleasesNotOwnedTy;
 
   typedef ReleasesNotOwnedTy UseAfterReleasesTy;
     
   typedef llvm::DenseMap<GRExprEngine::NodeTy*,
-                         std::vector<std::pair<SymbolID,bool> >*>
+                         std::vector<std::pair<SymbolRef,bool> >*>
           LeaksTy;
 
   class BindingsPrinter : public GRState::Printer {
@@ -1324,10 +1324,10 @@ private:
   ReleasesNotOwnedTy   ReleasesNotOwned;
   LeaksTy              Leaks;
   
-  RefBindings Update(RefBindings B, SymbolID sym, RefVal V, ArgEffect E,
+  RefBindings Update(RefBindings B, SymbolRef sym, RefVal V, ArgEffect E,
                      RefVal::Kind& hasErr, RefBindings::Factory& RefBFactory);
   
-  RefVal::Kind& Update(GRStateRef& state, SymbolID sym, RefVal V,
+  RefVal::Kind& Update(GRStateRef& state, SymbolRef sym, RefVal V,
                        ArgEffect E, RefVal::Kind& hasErr) {
     
     state = state.set<RefBindings>(Update(state.get<RefBindings>(), sym, V, 
@@ -1341,11 +1341,11 @@ private:
                            Expr* NodeExpr, Expr* ErrorExpr,                        
                            ExplodedNode<GRState>* Pred,
                            const GRState* St,
-                           RefVal::Kind hasErr, SymbolID Sym);
+                           RefVal::Kind hasErr, SymbolRef Sym);
   
   std::pair<GRStateRef, bool>
   HandleSymbolDeath(GRStateManager& VMgr, const GRState* St,
-                    const Decl* CD, SymbolID sid, RefVal V, bool& hasLeak);
+                    const Decl* CD, SymbolRef sid, RefVal V, bool& hasLeak);
   
 public:
   
@@ -1487,7 +1487,7 @@ void CFRefCount::ProcessNonLeakError(ExplodedNodeSet<GRState>& Dst,
                                      Expr* NodeExpr, Expr* ErrorExpr,                        
                                      ExplodedNode<GRState>* Pred,
                                      const GRState* St,
-                                     RefVal::Kind hasErr, SymbolID Sym) {
+                                     RefVal::Kind hasErr, SymbolRef Sym) {
   Builder.BuildSinks = true;
   GRExprEngine::NodeTy* N  = Builder.MakeNode(Dst, NodeExpr, Pred, St);
 
@@ -1555,13 +1555,13 @@ void CFRefCount::EvalSummary(ExplodedNodeSet<GRState>& Dst,
   RefVal::Kind hasErr = (RefVal::Kind) 0;
   unsigned idx = 0;
   Expr* ErrorExpr = NULL;
-  SymbolID ErrorSym = 0;                                        
+  SymbolRef ErrorSym = 0;                                        
   
   for (ExprIterator I = arg_beg; I != arg_end; ++I, ++idx) {    
     SVal V = state.GetSVal(*I);
     
     if (isa<loc::SymbolVal>(V)) {
-      SymbolID Sym = cast<loc::SymbolVal>(V).getSymbol();
+      SymbolRef Sym = cast<loc::SymbolVal>(V).getSymbol();
       if (RefBindings::data_type* T = state.get<RefBindings>(Sym))
         if (Update(state, Sym, *T, GetArgE(Summ, idx), hasErr)) {
           ErrorExpr = *I;
@@ -1594,7 +1594,7 @@ void CFRefCount::EvalSummary(ExplodedNodeSet<GRState>& Dst,
         SVal X = state.GetSVal(*MR);
         
         if (isa<loc::SymbolVal>(X)) {
-          SymbolID Sym = cast<loc::SymbolVal>(X).getSymbol();
+          SymbolRef Sym = cast<loc::SymbolVal>(X).getSymbol();
           state = state.remove<RefBindings>(Sym);
         }
         
@@ -1606,7 +1606,7 @@ void CFRefCount::EvalSummary(ExplodedNodeSet<GRState>& Dst,
           
           // FIXME: handle structs.
           if (Loc::IsLocType(T) || (T->isIntegerType() && T->isScalarType())) {
-            SymbolID NewSym =
+            SymbolRef NewSym =
               Eng.getSymbolManager().getConjuredSymbol(*I, T, Count);
             
             state = state.BindLoc(*MR,
@@ -1635,7 +1635,7 @@ void CFRefCount::EvalSummary(ExplodedNodeSet<GRState>& Dst,
   if (!ErrorExpr && Receiver) {
     SVal V = state.GetSVal(Receiver);
     if (isa<loc::SymbolVal>(V)) {
-      SymbolID Sym = cast<loc::SymbolVal>(V).ge