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

11 files changed, 89 insertions, 89 deletions

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).getSymbol();
+      SymbolRef Sym = cast<loc::SymbolVal>(V).getSymbol();
       if (const RefVal* T = state.get<RefBindings>(Sym))
         if (Update(state, Sym, *T, GetReceiverE(Summ), hasErr)) {
           ErrorExpr = Receiver;
@@ -1671,7 +1671,7 @@ void CFRefCount::EvalSummary(ExplodedNodeSet<GRState>& Dst,
       
       if (Loc::IsLocType(T) || (T->isIntegerType() && T->isScalarType())) {
         unsigned Count = Builder.getCurrentBlockCount();
-        SymbolID Sym = Eng.getSymbolManager().getConjuredSymbol(Ex, Count);
+        SymbolRef Sym = Eng.getSymbolManager().getConjuredSymbol(Ex, Count);
         
         SVal X = Loc::IsLocType(Ex->getType())
                ? cast<SVal>(loc::SymbolVal(Sym)) 
@@ -1702,7 +1702,7 @@ void CFRefCount::EvalSummary(ExplodedNodeSet<GRState>& Dst,
     case RetEffect::OwnedAllocatedSymbol:
     case RetEffect::OwnedSymbol: {
       unsigned Count = Builder.getCurrentBlockCount();
-      SymbolID Sym = Eng.getSymbolManager().getConjuredSymbol(Ex, Count);
+      SymbolRef Sym = Eng.getSymbolManager().getConjuredSymbol(Ex, Count);
       QualType RetT = GetReturnType(Ex, Eng.getContext());
       
       state = state.set<RefBindings>(Sym, RefVal::makeOwned(RetT));
@@ -1722,7 +1722,7 @@ void CFRefCount::EvalSummary(ExplodedNodeSet<GRState>& Dst,
       
     case RetEffect::NotOwnedSymbol: {
       unsigned Count = Builder.getCurrentBlockCount();
-      SymbolID Sym = Eng.getSymbolManager().getConjuredSymbol(Ex, Count);
+      SymbolRef Sym = Eng.getSymbolManager().getConjuredSymbol(Ex, Count);
       QualType RetT = GetReturnType(Ex, Eng.getContext());
       
       state = state.set<RefBindings>(Sym, RefVal::makeNotOwned(RetT));
@@ -1770,7 +1770,7 @@ void CFRefCount::EvalObjCMessageExpr(ExplodedNodeSet<GRState>& Dst,
     SVal V = Eng.getStateManager().GetSVal(St, Receiver );
 
     if (isa<loc::SymbolVal>(V)) {
-      SymbolID Sym = cast<loc::SymbolVal>(V).getSymbol();
+      SymbolRef Sym = cast<loc::SymbolVal>(V).getSymbol();
       
       if (const RefVal* T  = St->get<RefBindings>(Sym)) {
         QualType Ty = T->getType();
@@ -1839,7 +1839,7 @@ void CFRefCount::EvalStore(ExplodedNodeSet<GRState>& Dst,
   // (3) we are binding to a memregion with stack storage that the store
   //     does not understand.
   
-  SymbolID Sym = cast<loc::SymbolVal>(Val).getSymbol();
+  SymbolRef Sym = cast<loc::SymbolVal>(Val).getSymbol();
   GRStateRef state(St, Eng.getStateManager());
 
   if (!isa<loc::MemRegionVal>(TargetLV))
@@ -1878,7 +1878,7 @@ void CFRefCount::EvalStore(ExplodedNodeSet<GRState>& Dst,
 std::pair<GRStateRef,bool>
 CFRefCount::HandleSymbolDeath(GRStateManager& VMgr,
                               const GRState* St, const Decl* CD,
-                              SymbolID sid,
+                              SymbolRef sid,
                               RefVal V, bool& hasLeak) {
 
   GRStateRef state(St, VMgr);
@@ -1913,7 +1913,7 @@ void CFRefCount::EvalEndPath(GRExprEngine& Eng,
   const GRState* St = Builder.getState();
   RefBindings B = St->get<RefBindings>();
   
-  llvm::SmallVector<std::pair<SymbolID, bool>, 10> Leaked;
+  llvm::SmallVector<std::pair<SymbolRef, bool>, 10> Leaked;
   const Decl* CodeDecl = &Eng.getGraph().getCodeDecl();
   
   for (RefBindings::iterator I = B.begin(), E = B.end(); I != E; ++I) {
@@ -1935,11 +1935,11 @@ void CFRefCount::EvalEndPath(GRExprEngine& Eng,
   if (!N)
     return;
     
-  std::vector<std::pair<SymbolID,bool> >*& LeaksAtNode = Leaks[N];
+  std::vector<std::pair<SymbolRef,bool> >*& LeaksAtNode = Leaks[N];
   assert (!LeaksAtNode);
-  LeaksAtNode = new std::vector<std::pair<SymbolID,bool> >();
+  LeaksAtNode = new std::vector<std::pair<SymbolRef,bool> >();
   
-  for (llvm::SmallVector<std::pair<SymbolID,bool>, 10>::iterator
+  for (llvm::SmallVector<std::pair<SymbolRef,bool>, 10>::iterator
        I = Leaked.begin(), E = Leaked.end(); I != E; ++I)
     (*LeaksAtNode).push_back(*I);
 }
@@ -1957,7 +1957,7 @@ void CFRefCount::EvalDeadSymbols(ExplodedNodeSet<GRState>& Dst,
   // FIXME: a lot of copy-and-paste from EvalEndPath.  Refactor.
   
   RefBindings B = St->get<RefBindings>();
-  llvm::SmallVector<std::pair<SymbolID,bool>, 10> Leaked;
+  llvm::SmallVector<std::pair<SymbolRef,bool>, 10> Leaked;
   
   for (GRStateManager::DeadSymbolsTy::const_iterator
        I=Dead.begin(), E=Dead.end(); I!=E; ++I) {
@@ -1986,11 +1986,11 @@ void CFRefCount::EvalDeadSymbols(ExplodedNodeSet<GRState>& Dst,
   if (!N)
     return;
   
-  std::vector<std::pair<SymbolID,bool> >*& LeaksAtNode = Leaks[N];
+  std::vector<std::pair<SymbolRef,bool> >*& LeaksAtNode = Leaks[N];
   assert (!LeaksAtNode);
-  LeaksAtNode = new std::vector<std::pair<SymbolID,bool> >();
+  LeaksAtNode = new std::vector<std::pair<SymbolRef,bool> >();
   
-  for (llvm::SmallVector<std::pair<SymbolID,bool>, 10>::iterator
+  for (llvm::SmallVector<std::pair<SymbolRef,bool>, 10>::iterator
        I = Leaked.begin(), E = Leaked.end(); I != E; ++I)
     (*LeaksAtNode).push_back(*I);    
 }
@@ -2013,7 +2013,7 @@ void CFRefCount::EvalReturn(ExplodedNodeSet<GRState>& Dst,
     return;
   
   // Get the reference count binding (if any).
-  SymbolID Sym = cast<loc::SymbolVal>(V).getSymbol();
+  SymbolRef Sym = cast<loc::SymbolVal>(V).getSymbol();
   const RefVal* T = state.get<RefBindings>(Sym);
   
   if (!T)
@@ -2084,7 +2084,7 @@ const GRState* CFRefCount::EvalAssume(GRStateManager& VMgr,
   return state;
 }
 
-RefBindings CFRefCount::Update(RefBindings B, SymbolID sym,
+RefBindings CFRefCount::Update(RefBindings B, SymbolRef sym,
                                RefVal V, ArgEffect E,
                                RefVal::Kind& hasErr,
                                RefBindings::Factory& RefBFactory) {
@@ -2270,9 +2270,9 @@ namespace {
   //===---------===//
   
   class VISIBILITY_HIDDEN CFRefReport : public RangedBugReport {
-    SymbolID Sym;
+    SymbolRef Sym;
   public:
-    CFRefReport(CFRefBug& D, ExplodedNode<GRState> *n, SymbolID sym)
+    CFRefReport(CFRefBug& D, ExplodedNode<GRState> *n, SymbolRef sym)
       : RangedBugReport(D, n), Sym(sym) {}
         
     virtual ~CFRefReport() {}
@@ -2293,7 +2293,7 @@ namespace {
         beg = end = 0;
     }
     
-    SymbolID getSymbol() const { return Sym; }
+    SymbolRef getSymbol() const { return Sym; }
     
     virtual PathDiagnosticPiece* getEndPath(BugReporter& BR,
                                             ExplodedNode<GRState>* N);
@@ -2491,12 +2491,12 @@ PathDiagnosticPiece* CFRefReport::VisitNode(ExplodedNode<GRState>* N,
 namespace {
 class VISIBILITY_HIDDEN FindUniqueBinding :
   public StoreManager::BindingsHandler {
-    SymbolID Sym;
+    SymbolRef Sym;
     MemRegion* Binding;
     bool First;
     
   public:
-    FindUniqueBinding(SymbolID sym) : Sym(sym), Binding(0), First(true) {}
+    FindUniqueBinding(SymbolRef sym) : Sym(sym), Binding(0), First(true) {}
     
   bool HandleBinding(StoreManager& SMgr, Store store, MemRegion* R, SVal val) {
     if (const loc::SymbolVal* SV = dyn_cast<loc::SymbolVal>(&val)) {
@@ -2527,7 +2527,7 @@ class VISIBILITY_HIDDEN FindUniqueBinding :
 
 static std::pair<ExplodedNode<GRState>*,MemRegion*>
 GetAllocationSite(GRStateManager* StateMgr, ExplodedNode<GRState>* N,
-                  SymbolID Sym) {
+                  SymbolRef Sym) {
 
   // Find both first node that referred to the tracked symbol and the
   // memory location that value was store to.
@@ -2678,7 +2678,7 @@ void Leak::EmitWarnings(BugReporter& BR) {
   for (CFRefCount::leaks_iterator I = TF.leaks_begin(),
        E = TF.leaks_end(); I != E; ++I) {
     
-    std::vector<std::pair<SymbolID, bool> >& SymV = *(I->second);
+    std::vector<std::pair<SymbolRef, bool> >& SymV = *(I->second);
     unsigned n = SymV.size();
     
     for (unsigned i = 0; i < n; ++i) {
@@ -2701,7 +2701,7 @@ bool Leak::isCached(BugReport& R) {
   // With leaks, we want to unique them by the location where they were
   // allocated, and only report a single path.
   
-  SymbolID Sym = static_cast<CFRefReport&>(R).getSymbol();
+  SymbolRef Sym = static_cast<CFRefReport&>(R).getSymbol();
 
   ExplodedNode<GRState>* AllocNode =
     GetAllocationSite(0, R.getEndNode(), Sym).first;
diff --git a/lib/Analysis/GRExprEngine.cpp b/lib/Analysis/GRExprEngine.cpp
index 5d4136de76..b3b311a02c 100644
--- a/lib/Analysis/GRExprEngine.cpp
+++ b/lib/Analysis/GRExprEngine.cpp
@@ -1799,11 +1799,11 @@ void GRExprEngine::VisitDeclStmt(DeclStmt* DS, NodeTy* Pred, NodeSet& Dst) {
       // UnknownVal.
       if (InitVal.isUnknown()) {
         if (Loc::IsLocType(T)) {
-          SymbolID Sym = SymMgr.getConjuredSymbol(InitEx, Count);        
+          SymbolRef Sym = SymMgr.getConjuredSymbol(InitEx, Count);        
           InitVal = loc::SymbolVal(Sym);
         }
         else if (T->isIntegerType() && T->isScalarType()) {
-          SymbolID Sym = SymMgr.getConjuredSymbol(InitEx, Count);        
+          SymbolRef Sym = SymMgr.getConjuredSymbol(InitEx, Count);        
           InitVal = nonloc::SymbolVal(Sym);                    
         }
       }        
@@ -2399,7 +2399,7 @@ void GRExprEngine::VisitBinaryOperator(BinaryOperator* B,
           if (RightV.isUnknown() && (Loc::IsLocType(T) || 
                                   (T->isScalarType() && T->isIntegerType()))) {
             unsigned Count = Builder->getCurrentBlockCount();
-            SymbolID Sym = SymMgr.getConjuredSymbol(B->getRHS(), Count);
+            SymbolRef Sym = SymMgr.getConjuredSymbol(B->getRHS(), Count);
             
             RightV = Loc::IsLocType(T) 
                    ? cast<SVal>(loc::SymbolVal(Sym)) 
@@ -2562,7 +2562,7 @@ void GRExprEngine::VisitBinaryOperator(BinaryOperator* B,
           // The symbolic value is actually for the type of the left-hand side
           // expression, not the computation type, as this is the value the
           // LValue on the LHS will bind to.
-          SymbolID Sym = SymMgr.getConjuredSymbol(B->getRHS(), LTy, Count);
+          SymbolRef Sym = SymMgr.getConjuredSymbol(B->getRHS(), LTy, Count);
           LHSVal = Loc::IsLocType(LTy) 
                  ? cast<SVal>(loc::SymbolVal(Sym)) 
                  : cast<SVal>(nonloc::SymbolVal(Sym));
diff --git a/lib/Analysis/GRSimpleVals.cpp b/lib/Analysis/GRSimpleVals.cpp
index 783bccc7d7..c1f455b2af 100644
--- a/lib/Analysis/GRSimpleVals.cpp
+++ b/lib/Analysis/GRSimpleVals.cpp
@@ -415,7 +415,7 @@ void GRSimpleVals::EvalCall(ExplodedNodeSet<GRState>& Dst,
   QualType T = CE->getType();  
   if (Loc::IsLocType(T) || (T->isIntegerType() && T->isScalarType())) {    
     unsigned Count = Builder.getCurrentBlockCount();
-    SymbolID Sym = Eng.getSymbolManager().getConjuredSymbol(CE, Count);
+    SymbolRef Sym = Eng.getSymbolManager().getConjuredSymbol(CE, Count);
         
     SVal X = Loc::IsLocType(CE->getType())
              ? cast<SVal>(loc::SymbolVal(Sym)) 
diff --git a/lib/Analysis/GRState.cpp b/lib/Analysis/GRState.cpp
index 83ab508117..221ab064d3 100644
--- a/lib/Analysis/GRState.cpp
+++ b/lib/Analysis/GRState.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-//  This file defines SymbolID, ExprBindKey, and GRState*
+//  This file defines SymbolRef, ExprBindKey, and GRState*
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/lib/Analysis/MemRegion.cpp b/lib/Analysis/MemRegion.cpp
index 86f8571bc9..d771526958 100644
--- a/lib/Analysis/MemRegion.cpp
+++ b/lib/Analysis/MemRegion.cpp
@@ -90,7 +90,7 @@ void DeclRegion::Profile(llvm::FoldingSetNodeID& ID) const {
   DeclRegion::ProfileRegion(ID, D, superRegion, getKind());
 }
 
-void SymbolicRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, SymbolID sym) {
+void SymbolicRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, SymbolRef sym) {
   ID.AddInteger((unsigned) MemRegion::SymbolicRegionKind);
   ID.AddInteger(sym.getNumber());
 }
@@ -300,7 +300,7 @@ ElementRegion* MemRegionManager::getElementRegion(SVal Idx,
 }
 
 /// getSymbolicRegion - Retrieve or create a "symbolic" memory region.
-SymbolicRegion* MemRegionManager::getSymbolicRegion(const SymbolID sym) {
+SymbolicRegion* MemRegionManager::getSymbolicRegion(const SymbolRef sym) {
   
   llvm::FoldingSetNodeID ID;
   SymbolicRegion::ProfileRegion(ID, sym);
diff --git a/lib/Analysis/RegionStore.cpp b/lib/Analysis/RegionStore.cpp
index 07399f41ef..563a1fe9b7 100644
--- a/lib/Analysis/RegionStore.cpp
+++ b/lib/Analysis/RegionStore.cpp
@@ -734,7 +734,7 @@ Store RegionStoreManager::RemoveDeadBindings(const GRState* state, Stmt* Loc,
 
     // Mark all non-live symbols that this region references as dead.
     if (const SymbolicRegion* SymR = dyn_cast<SymbolicRegion>(R)) {
-      SymbolID Sym = SymR->getSymbol();
+      SymbolRef Sym = SymR->getSymbol();
       if (!LSymbols.count(Sym)) DSymbols.insert(Sym);
     }
 
diff --git a/lib/Analysis/SVals.cpp b/lib/Analysis/SVals.cpp
index 524904dafa..6ee311c0dd 100644
--- a/lib/Analysis/SVals.cpp
+++ b/lib/Analysis/SVals.cpp
@@ -29,9 +29,9 @@ SVal::symbol_iterator SVal::symbol_begin() const {
   // FIXME: This is a rat's nest.  Cleanup.
 
   if (isa<loc::SymbolVal>(this))
-    return symbol_iterator(SymbolID((uintptr_t)Data));
+    return symbol_iterator(SymbolRef((uintptr_t)Data));
   else if (isa<nonloc::SymbolVal>(this))
-    return symbol_iterator(SymbolID((uintptr_t)Data));
+    return symbol_iterator(SymbolRef((uintptr_t)Data));
   else if (isa<nonloc::SymIntConstraintVal>(this)) {
     const SymIntConstraint& C =
       cast<nonloc::SymIntConstraintVal>(this)->getConstraint();    
diff --git a/lib/Analysis/SymbolManager.cpp b/lib/Analysis/SymbolManager.cpp
index c49d12730b..013202990a 100644
--- a/lib/Analysis/SymbolManager.cpp
+++ b/lib/Analysis/SymbolManager.cpp
@@ -16,7 +16,7 @@
 
 using namespace clang;
 
-SymbolID SymbolManager::getSymbol(VarDecl* D) {
+SymbolRef SymbolManager::getSymbol(VarDecl* D) {
 
   assert (isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D) || 
           D->hasGlobalStorage());
@@ -52,7 +52,7 @@ SymbolID SymbolManager::getSymbol(VarDecl* D) {
   return SymbolCounter++;
 }  
 
-SymbolID SymbolManager::getElementSymbol(const MemRegion* R, 
+SymbolRef SymbolManager::getElementSymbol(const MemRegion* R, 
                                          const llvm::APSInt* Idx){
   llvm::FoldingSetNodeID ID;
   SymbolDataElement::Profile(ID, R, Idx);
@@ -70,7 +70,7 @@ SymbolID SymbolManager::getElementSymbol(const MemRegion* R,
   return SymbolCounter++;
 }
 
-SymbolID SymbolManager::getFieldSymbol(const MemRegion* R, const FieldDecl* D) {
+SymbolRef SymbolManager::getFieldSymbol(const MemRegion* R, const FieldDecl* D) {
   llvm::FoldingSetNodeID ID;
   SymbolDataField::Profile(ID, R, D);
   void* InsertPos;
@@ -87,7 +87,7 @@ SymbolID SymbolManager::getFieldSymbol(const MemRegion* R, const FieldDecl* D) {
   return SymbolCounter++;
 }
 
-SymbolID SymbolManager::getConjuredSymbol(Stmt* E, QualType T, unsigned Count) {
+SymbolRef SymbolManager::getConjuredSymbol(Stmt* E, QualType T, unsigned Count) {
   
   llvm::FoldingSetNodeID profile;
   SymbolConjured::Profile(profile, E, T, Count);
@@ -107,7 +107,7 @@ SymbolID SymbolManager::getConjuredSymbol(Stmt* E, QualType T, unsigned Count) {
   return SymbolCounter++;
 }
 
-const SymbolData& SymbolManager::getSymbolData(SymbolID Sym) const {  
+const SymbolData& SymbolManager::getSymbolData(SymbolRef Sym) const {  
   DataMapTy::const_iterator I = DataMap.find(Sym);
   assert (I != DataMap.end());  
   return *I->second;