Index: include/clang/Analysis/PathSensitive/GRState.h
===================================================================
--- include/clang/Analysis/PathSensitive/GRState.h	(revision 57042)
+++ include/clang/Analysis/PathSensitive/GRState.h	(working copy)
@@ -343,8 +343,8 @@
     return MRMgr.getVarRegion(D);
   }
   
-  lval::MemRegionVal getLVal(const VarDecl* D) {
-    return lval::MemRegionVal(getRegion(D));
+  lval::VarRegionVal getLVal(const VarDecl* D) {
+    return lval::VarRegionVal(getRegion(D));
   }
   
   // Methods that query & manipulate the Environment.
Index: include/clang/Analysis/PathSensitive/RValues.h
===================================================================
--- include/clang/Analysis/PathSensitive/RValues.h	(revision 57042)
+++ include/clang/Analysis/PathSensitive/RValues.h	(working copy)
@@ -25,6 +25,7 @@
 namespace clang {
   
 class MemRegion;
+class VarRegion;
 class GRStateManager;
   
 class RVal {
@@ -288,7 +289,7 @@
 
 namespace lval {
   
-enum Kind { SymbolValKind, GotoLabelKind, MemRegionKind, FuncValKind,
+enum Kind { SymbolValKind, GotoLabelKind, VarRegionKind, FuncValKind,
             ConcreteIntKind, StringLiteralValKind, FieldOffsetKind,
             ArrayOffsetKind };
 
@@ -330,30 +331,30 @@
 };
   
 
-class MemRegionVal : public LVal {
+class VarRegionVal : public LVal {
 public:
-  MemRegionVal(const MemRegion* r) : LVal(MemRegionKind, r) {}
+  VarRegionVal(const VarRegion* r) : LVal(VarRegionKind, r) {}
 
-  MemRegion* getRegion() const {
-    return static_cast<MemRegion*>(Data);
+  VarRegion* getRegion() const {
+    return static_cast<VarRegion*>(Data);
   }
   
-  inline bool operator==(const MemRegionVal& R) const {
+  inline bool operator==(const VarRegionVal& R) const {
     return getRegion() == R.getRegion();
   }
   
-  inline bool operator!=(const MemRegionVal& R) const {
+  inline bool operator!=(const VarRegionVal& R) const {
     return getRegion() != R.getRegion();
   }
   
   // Implement isa<T> support.
   static inline bool classof(const RVal* V) {
     return V->getBaseKind() == LValKind &&
-           V->getSubKind() == MemRegionKind;
+           V->getSubKind() == VarRegionKind;
   }
   
   static inline bool classof(const LVal* V) {
-    return V->getSubKind() == MemRegionKind;
+    return V->getSubKind() == VarRegionKind;
   }    
 };
 
Index: lib/Analysis/BasicStore.cpp
===================================================================
--- lib/Analysis/BasicStore.cpp	(revision 57042)
+++ lib/Analysis/BasicStore.cpp	(working copy)
@@ -74,13 +74,9 @@
   
   switch (LV.getSubKind()) {
 
-    case lval::MemRegionKind: {
-      VarRegion* R =
-        dyn_cast<VarRegion>(cast<lval::MemRegionVal>(LV).getRegion());
-      
-      if (!R)
-        return UnknownVal();
-        
+    case lval::VarRegionKind: {
+      VarRegion* R = cast<lval::VarRegionVal>(LV).getRegion();
+
       VarBindingsTy B(static_cast<const VarBindingsTy::TreeTy*>(St));      
       VarBindingsTy::data_type* T = B.lookup(R->getDecl());      
       return T ? *T : UnknownVal();
@@ -116,13 +112,9 @@
 
 Store BasicStoreManager::SetRVal(Store store, LVal LV, RVal V) {    
   switch (LV.getSubKind()) {      
-    case lval::MemRegionKind: {
-      VarRegion* R =
-        dyn_cast<VarRegion>(cast<lval::MemRegionVal>(LV).getRegion());
+    case lval::VarRegionKind: {
+      VarRegion* R = cast<lval::VarRegionVal>(LV).getRegion();
       
-      if (!R)
-        return store;
-      
       VarBindingsTy B = GetVarBindings(store);
       return V.isUnknown()
         ? VBFactory.Remove(B, R->getDecl()).getRoot()
@@ -136,9 +128,8 @@
 
 Store BasicStoreManager::Remove(Store store, LVal LV) {
   switch (LV.getSubKind()) {
-    case lval::MemRegionKind: {
-      VarRegion* R =
-      dyn_cast<VarRegion>(cast<lval::MemRegionVal>(LV).getRegion());
+    case lval::VarRegionKind: {
+      VarRegion* R = cast<lval::VarRegionVal>(LV).getRegion();
       
       if (!R)
         return store;
@@ -184,24 +175,24 @@
     Marked.insert(R);    
     // FIXME: Do we need the QualType here, since regions are partially
     // typed?
-    RVal X = GetRVal(store, lval::MemRegionVal(R), QualType());      
+    RVal X = GetRVal(store, lval::VarRegionVal(R), QualType());      
     
     for (symbol_iterator SI=X.symbol_begin(), SE=X.symbol_end(); SI!=SE; ++SI)
       LSymbols.insert(*SI);
     
-    if (!isa<lval::MemRegionVal>(X))
+    if (!isa<lval::VarRegionVal>(X))
       continue;
     
-    const lval::MemRegionVal& LVD = cast<lval::MemRegionVal>(X);
-    RegionRoots.push_back(cast<VarRegion>(LVD.getRegion()));
+    const lval::VarRegionVal& LVD = cast<lval::VarRegionVal>(X);
+    RegionRoots.push_back(LVD.getRegion());
   }
   
   // Remove dead variable bindings.  
   for (VarBindingsTy::iterator I=B.begin(), E=B.end(); I!=E ; ++I) {
-    const VarRegion* R = cast<VarRegion>(StMgr.getRegion(I.getKey()));
+    const VarRegion* R = StMgr.getRegion(I.getKey());
     
     if (!Marked.count(R)) {
-      store = Remove(store, lval::MemRegionVal(R));
+      store = Remove(store, lval::VarRegionVal(R));
       RVal X = I.getData();
       
       for (symbol_iterator SI=X.symbol_begin(), SE=X.symbol_end(); SI!=SE; ++SI)
Index: lib/Analysis/BugReporter.cpp
===================================================================
--- lib/Analysis/BugReporter.cpp	(revision 57042)
+++ lib/Analysis/BugReporter.cpp	(working copy)
@@ -356,7 +356,7 @@
       return true;
     
     // Check if the previous state has this binding.    
-    RVal X = VMgr.GetRVal(PrevSt, lval::MemRegionVal(R));
+    RVal X = VMgr.GetRVal(PrevSt, lval::VarRegionVal(cast<VarRegion>(R)));
     
     if (X == V) // Same binding?
       return true;
Index: lib/Analysis/BasicConstraintManager.cpp
===================================================================
--- lib/Analysis/BasicConstraintManager.cpp	(revision 57042)
+++ lib/Analysis/BasicConstraintManager.cpp	(working copy)
@@ -129,7 +129,7 @@
       return AssumeSymEQ(St, cast<lval::SymbolVal>(Cond).getSymbol(),
                          BasicVals.getZeroWithPtrWidth(), isFeasible);
 
-  case lval::MemRegionKind:
+  case lval::VarRegionKind:
   case lval::FuncValKind:
   case lval::GotoLabelKind:
   case lval::StringLiteralValKind:
Index: lib/Analysis/BasicObjCFoundationChecks.cpp
===================================================================
--- lib/Analysis/BasicObjCFoundationChecks.cpp	(revision 57042)
+++ lib/Analysis/BasicObjCFoundationChecks.cpp	(working copy)
@@ -498,7 +498,7 @@
   
   // FIXME: Eventually we should handle arbitrary locations.  We can do this
   //  by having an enhanced memory model that does low-level typing.
-  lval::MemRegionVal* LV = dyn_cast<lval::MemRegionVal>(&TheValueExpr);
+  lval::VarRegionVal* LV = dyn_cast<lval::VarRegionVal>(&TheValueExpr);
 
   if (!LV)
     return false;