diff --git a/include/clang/Analysis/PathSensitive/BasicValueFactory.h b/include/clang/Analysis/PathSensitive/BasicValueFactory.h
index 70fbe1d..bf6bb8c 100644
--- a/include/clang/Analysis/PathSensitive/BasicValueFactory.h
+++ b/include/clang/Analysis/PathSensitive/BasicValueFactory.h
@@ -84,7 +84,7 @@
     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 d62fe61..5613ad8 100644
--- a/include/clang/Analysis/PathSensitive/BugReporter.h
+++ b/include/clang/Analysis/PathSensitive/BugReporter.h
@@ -236,7 +236,7 @@
   
 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 @@
   
   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 54cdecb..cec7f69 100644
--- a/include/clang/Analysis/PathSensitive/ConstraintManager.h
+++ b/include/clang/Analysis/PathSensitive/ConstraintManager.h
@@ -26,7 +26,7 @@
 class GRState;
 class GRStateManager;
 class SVal;
-class SymbolID;
+class SymbolRef;
 
 class ConstraintManager {
 public:
@@ -38,11 +38,11 @@
                                        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 6efafd6..71990b0 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 @@
                                         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 @@
     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 35df7df..22e3bda 100644
--- a/include/clang/Analysis/PathSensitive/MemRegion.h
+++ b/include/clang/Analysis/PathSensitive/MemRegion.h
@@ -140,17 +140,17 @@
 ///  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 @@
 ///  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 @@
   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 ca78f66..45435b0 100644
--- a/include/clang/Analysis/PathSensitive/SVals.h
+++ b/include/clang/Analysis/PathSensitive/SVals.h
@@ -102,7 +102,7 @@
   
   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 @@
       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 @@
   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 @@
   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 a272f05..5e654a8 100644
--- a/include/clang/Analysis/PathSensitive/Store.h
+++ b/include/clang/Analysis/PathSensitive/Store.h
@@ -35,8 +35,8 @@
 
 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 1f548b4..9d495be 100644
--- a/include/clang/Analysis/PathSensitive/SymbolManager.h
+++ b/include/clang/Analysis/PathSensitive/SymbolManager.h
@@ -27,11 +27,11 @@
 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 @@
 } // 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 @@
   
 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 @@
   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 @@
   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 @@
   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 @@
   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 @@
   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 @@
 // 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 @@
 
 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 @@
   
   ~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 f4290ff..7c303b2 100644
--- a/lib/Analysis/BasicConstraintManager.cpp
+++ b/lib/Analysis/BasicConstraintManager.cpp
@@ -22,8 +22,8 @@
 
 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 @@
   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 @@
 
   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 @@
 }
 
 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 @@
 }
 
 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 @@
 
 // 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 @@
 }
 
 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 @@
 }
 
 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 @@
 }
 
 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 @@
   };
 }
 
-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 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 @@
   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 @@
   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 @@
   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 7ce305e..2c7d6a3 100644
--- a/lib/Analysis/BasicValueFactory.cpp
+++ b/lib/Analysis/BasicValueFactory.cpp
@@ -98,7 +98,7 @@
 }
 
 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 905c697..8274ce7 100644
--- a/lib/Analysis/BugReporter.cpp
+++ b/lib/Analysis/BugReporter.cpp
@@ -326,7 +326,7 @@
 class VISIBILITY_HIDDEN NotableSymbolHandler 
   : public StoreManager::BindingsHandler {
     
-  SymbolID Sym;
+  SymbolRef Sym;
   const GRState* PrevSt;
   Stmt* S;
   GRStateManager& VMgr;
@@ -336,14 +336,14 @@
     
 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 @@
 }
 
 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 @@
 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 @@
     : 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 461754e..cb0cbd1 100644
--- a/lib/Analysis/CFRefCount.cpp
+++ b/lib/Analysis/CFRefCount.cpp
@@ -1267,7 +1267,7 @@
 // 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 @@
 // 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 @@
 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 @@
   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 @@
                            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 @@
                                      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 @@
   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 @@
         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 @@
           
           // 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 @@
   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 @@
       
       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 @@
     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 @@
       
     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 @@
     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 @@
   // (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 @@
 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 @@
   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 @@
   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 @@
   // 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 @@
   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 @@
     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 @@
   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 @@
   //===---------===//
   
   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 @@
         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 @@
 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 @@
 
 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 @@
   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 @@
   // 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 5d4136d..b3b311a 100644
--- a/lib/Analysis/GRExprEngine.cpp
+++ b/lib/Analysis/GRExprEngine.cpp
@@ -1799,11 +1799,11 @@
       // 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 @@
           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 @@
           // 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 783bccc..c1f455b 100644
--- a/lib/Analysis/GRSimpleVals.cpp
+++ b/lib/Analysis/GRSimpleVals.cpp
@@ -415,7 +415,7 @@
   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 83ab508..221ab06 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 86f8571..d771526 100644
--- a/lib/Analysis/MemRegion.cpp
+++ b/lib/Analysis/MemRegion.cpp
@@ -90,7 +90,7 @@
   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 @@
 }
 
 /// 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 07399f4..563a1fe 100644
--- a/lib/Analysis/RegionStore.cpp
+++ b/lib/Analysis/RegionStore.cpp
@@ -734,7 +734,7 @@
 
     // 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 524904d..6ee311c 100644
--- a/lib/Analysis/SVals.cpp
+++ b/lib/Analysis/SVals.cpp
@@ -29,9 +29,9 @@
   // 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 c49d127..0132029 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 @@
   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 @@
   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 @@
   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 @@
   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;