Makes most methods in SVals.h conform to the naming guide. Reviewed

by kremenek.


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

18 files changed, 46 insertions, 47 deletions

diff --git a/include/clang/StaticAnalyzer/Core/PathSensitive/BasicValueFactory.h b/include/clang/StaticAnalyzer/Core/PathSensitive/BasicValueFactory.h
index 25605ab775..02517e38b4 100644
--- a/include/clang/StaticAnalyzer/Core/PathSensitive/BasicValueFactory.h
+++ b/include/clang/StaticAnalyzer/Core/PathSensitive/BasicValueFactory.h
@@ -104,9 +104,9 @@ public:
   }
   
   const llvm::APSInt &Convert(QualType T, const llvm::APSInt &From) {
-    assert(T->isIntegerType() || Loc::IsLocType(T));
+    assert(T->isIntegerType() || Loc::isLocType(T));
     unsigned bitwidth = Ctx.getTypeSize(T);
-    bool isUnsigned = T->isUnsignedIntegerType() || Loc::IsLocType(T);
+    bool isUnsigned = T->isUnsignedIntegerType() || Loc::isLocType(T);
     
     if (isUnsigned == From.isUnsigned() && bitwidth == From.getBitWidth())
       return From;
@@ -128,14 +128,14 @@ public:
   }
 
   inline const llvm::APSInt& getMaxValue(QualType T) {
-    assert(T->isIntegerType() || Loc::IsLocType(T));
-    bool isUnsigned = T->isUnsignedIntegerType() || Loc::IsLocType(T);
+    assert(T->isIntegerType() || Loc::isLocType(T));
+    bool isUnsigned = T->isUnsignedIntegerType() || Loc::isLocType(T);
     return getValue(llvm::APSInt::getMaxValue(Ctx.getTypeSize(T), isUnsigned));
   }
 
   inline const llvm::APSInt& getMinValue(QualType T) {
-    assert(T->isIntegerType() || Loc::IsLocType(T));
-    bool isUnsigned = T->isUnsignedIntegerType() || Loc::IsLocType(T);
+    assert(T->isIntegerType() || Loc::isLocType(T));
+    bool isUnsigned = T->isUnsignedIntegerType() || Loc::isLocType(T);
     return getValue(llvm::APSInt::getMinValue(Ctx.getTypeSize(T), isUnsigned));
   }
 
diff --git a/include/clang/StaticAnalyzer/Core/PathSensitive/GRState.h b/include/clang/StaticAnalyzer/Core/PathSensitive/GRState.h
index f1f814a6cb..80a89e0b78 100644
--- a/include/clang/StaticAnalyzer/Core/PathSensitive/GRState.h
+++ b/include/clang/StaticAnalyzer/Core/PathSensitive/GRState.h
@@ -705,7 +705,7 @@ inline SVal GRState::getSVal(const Stmt* Ex) const {
 inline SVal GRState::getSValAsScalarOrLoc(const Stmt *S) const {
   if (const Expr *Ex = dyn_cast<Expr>(S)) {
     QualType T = Ex->getType();
-    if (Loc::IsLocType(T) || T->isIntegerType())
+    if (Loc::isLocType(T) || T->isIntegerType())
       return getSVal(S);
   }
 
diff --git a/include/clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h b/include/clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h
index 7ccaed78c6..9c18711742 100644
--- a/include/clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h
+++ b/include/clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h
@@ -190,7 +190,7 @@ public:
   }
 
   DefinedSVal makeIntVal(uint64_t X, QualType T) {
-    if (Loc::IsLocType(T))
+    if (Loc::isLocType(T))
       return loc::ConcreteInt(BasicVals.getValue(X, T));
 
     return nonloc::ConcreteInt(BasicVals.getValue(X, T));
diff --git a/include/clang/StaticAnalyzer/Core/PathSensitive/SVals.h b/include/clang/StaticAnalyzer/Core/PathSensitive/SVals.h
index 5b8228d8e0..1d1cd0b8f9 100644
--- a/include/clang/StaticAnalyzer/Core/PathSensitive/SVals.h
+++ b/include/clang/StaticAnalyzer/Core/PathSensitive/SVals.h
@@ -63,7 +63,6 @@ protected:
   ///  The higher bits are an unsigned "kind" value.
   unsigned Kind;
 
-protected:
   explicit SVal(const void* d, bool isLoc, unsigned ValKind)
   : Data(d), Kind((isLoc ? LocKind : NonLocKind) | (ValKind << BaseBits)) {}
 
@@ -81,6 +80,8 @@ public:
   inline BaseKind getBaseKind() const { return (BaseKind) (Kind & BaseMask); }
   inline unsigned getSubKind() const { return (Kind & ~BaseMask) >> BaseBits; }
 
+  // This method is required for using SVal in a FoldingSetNode.  It
+  // extracts a unique signature for this SVal object.
   inline void Profile(llvm::FoldingSetNodeID& ID) const {
     ID.AddInteger((unsigned) getRawKind());
     ID.AddPointer(Data);
@@ -262,7 +263,7 @@ public:
     return V->getBaseKind() == LocKind;
   }
 
-  static inline bool IsLocType(QualType T) {
+  static inline bool isLocType(QualType T) {
     return T->isAnyPointerType() || T->isBlockPointerType() || 
            T->isReferenceType();
   }
@@ -456,7 +457,7 @@ public:
     return static_cast<const MemRegion*>(Data);
   }
 
-  const MemRegion* StripCasts() const;
+  const MemRegion* stripCasts() const;
 
   template <typename REGION>
   const REGION* getRegionAs() const {
diff --git a/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp b/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp
index 66cd359785..a1037b9713 100644
--- a/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp
+++ b/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp
@@ -291,7 +291,7 @@ void CFNumberCreateChecker::PreVisitCallExpr(CheckerContext &C,
   if (!LV)
     return;
 
-  const TypedRegion* R = dyn_cast<TypedRegion>(LV->StripCasts());
+  const TypedRegion* R = dyn_cast<TypedRegion>(LV->stripCasts());
   if (!R)
     return;
 
diff --git a/lib/StaticAnalyzer/Checkers/ExprEngine.cpp b/lib/StaticAnalyzer/Checkers/ExprEngine.cpp
index bde7c4395a..99e120d303 100644
--- a/lib/StaticAnalyzer/Checkers/ExprEngine.cpp
+++ b/lib/StaticAnalyzer/Checkers/ExprEngine.cpp
@@ -2280,7 +2280,7 @@ void ExprEngine::VisitObjCForCollectionStmtAux(const ObjCForCollectionStmt* S,
         //  container.  We will do this with dispatch logic to the store.
         //  For now, just 'conjure' up a symbolic value.
         QualType T = R->getValueType();
-        assert(Loc::IsLocType(T));
+        assert(Loc::isLocType(T));
         unsigned Count = Builder->getCurrentBlockCount();
         SymbolRef Sym = SymMgr.getConjuredSymbol(elem, T, Count);
         SVal V = svalBuilder.makeLoc(Sym);
@@ -2798,7 +2798,7 @@ void ExprEngine::VisitInitListExpr(const InitListExpr* E, ExplodedNode* Pred,
     return;
   }
 
-  if (Loc::IsLocType(T) || T->isIntegerType()) {
+  if (Loc::isLocType(T) || T->isIntegerType()) {
     assert (E->getNumInits() == 1);
     ExplodedNodeSet Tmp;
     const Expr* Init = E->getInit(0);
@@ -3103,7 +3103,7 @@ void ExprEngine::VisitUnaryOperator(const UnaryOperator* U,
         // If the value is a location, ++/-- should always preserve
         // non-nullness.  Check if the original value was non-null, and if so
         // propagate that constraint.
-        if (Loc::IsLocType(U->getType())) {
+        if (Loc::isLocType(U->getType())) {
           DefinedOrUnknownSVal Constraint =
             svalBuilder.evalEQ(state, V2,svalBuilder.makeZeroVal(U->getType()));
 
diff --git a/lib/StaticAnalyzer/Core/BasicStore.cpp b/lib/StaticAnalyzer/Core/BasicStore.cpp
index 105b505242..987e790585 100644
--- a/lib/StaticAnalyzer/Core/BasicStore.cpp
+++ b/lib/StaticAnalyzer/Core/BasicStore.cpp
@@ -252,7 +252,7 @@ Store BasicStoreManager::Bind(Store store, Loc loc, SVal V) {
     // a pointer.  We may wish to flag a type error here if the types
     // are incompatible.  This may also cause lots of breakage
     // elsewhere. Food for thought.
-    if (TyR->isBoundable() && Loc::IsLocType(TyR->getValueType()))
+    if (TyR->isBoundable() && Loc::isLocType(TyR->getValueType()))
       V = X->getLoc();
   }
 
@@ -464,7 +464,7 @@ Store BasicStoreManager::BindDeclInternal(Store store, const VarRegion* VR,
       //     unsigned) zero;
       if (!InitVal) {
         QualType T = VD->getType();
-        if (Loc::IsLocType(T))
+        if (Loc::isLocType(T))
           store = Bind(store, loc::MemRegionVal(VR),
                        loc::ConcreteInt(BasicVals.getValue(0, T)));
         else if (T->isIntegerType() && T->isScalarType())
diff --git a/lib/StaticAnalyzer/Core/BasicValueFactory.cpp b/lib/StaticAnalyzer/Core/BasicValueFactory.cpp
index 7eb2fe4dc5..6315d83d89 100644
--- a/lib/StaticAnalyzer/Core/BasicValueFactory.cpp
+++ b/lib/StaticAnalyzer/Core/BasicValueFactory.cpp
@@ -99,7 +99,7 @@ const llvm::APSInt& BasicValueFactory::getValue(uint64_t X, unsigned BitWidth,
 const llvm::APSInt& BasicValueFactory::getValue(uint64_t X, QualType T) {
 
   unsigned bits = Ctx.getTypeSize(T);
-  llvm::APSInt V(bits, T->isUnsignedIntegerType() || Loc::IsLocType(T));
+  llvm::APSInt V(bits, T->isUnsignedIntegerType() || Loc::isLocType(T));
   V = X;
   return getValue(V);
 }
@@ -286,5 +286,3 @@ BasicValueFactory::getPersistentSValPair(const SVal& V1, const SVal& V2) {
 const SVal* BasicValueFactory::getPersistentSVal(SVal X) {
   return &getPersistentSValWithData(X, 0).first;
 }
-
-
diff --git a/lib/StaticAnalyzer/Core/BugReporter.cpp b/lib/StaticAnalyzer/Core/BugReporter.cpp
index 431c5d7506..d945639ee4 100644
--- a/lib/StaticAnalyzer/Core/BugReporter.cpp
+++ b/lib/StaticAnalyzer/Core/BugReporter.cpp
@@ -446,7 +446,7 @@ public:
     // Create the diagnostic.
     FullSourceLoc L(S->getLocStart(), BR.getSourceManager());
 
-    if (Loc::IsLocType(VD->getType())) {
+    if (Loc::isLocType(VD->getType())) {
       std::string msg = "'" + std::string(VD->getNameAsString()) +
       "' now aliases '" + MostRecent->getNameAsString() + "'";
 
diff --git a/lib/StaticAnalyzer/Core/CFRefCount.cpp b/lib/StaticAnalyzer/Core/CFRefCount.cpp
index 92bd4116a7..b3721d7659 100644
--- a/lib/StaticAnalyzer/Core/CFRefCount.cpp
+++ b/lib/StaticAnalyzer/Core/CFRefCount.cpp
@@ -2679,7 +2679,7 @@ void CFRefCount::evalSummary(ExplodedNodeSet& Dst,
       // that are returned by value.
 
       QualType T = callOrMsg.getResultType(Eng.getContext());
-      if (Loc::IsLocType(T) || (T->isIntegerType() && T->isScalarType())) {
+      if (Loc::isLocType(T) || (T->isIntegerType() && T->isScalarType())) {
         unsigned Count = Builder.getCurrentBlockCount();
         SValBuilder &svalBuilder = Eng.getSValBuilder();
         SVal X = svalBuilder.getConjuredSymbolVal(NULL, Ex, T, Count);
diff --git a/lib/StaticAnalyzer/Core/GRState.cpp b/lib/StaticAnalyzer/Core/GRState.cpp
index 80f2ae082b..80c8bbf195 100644
--- a/lib/StaticAnalyzer/Core/GRState.cpp
+++ b/lib/StaticAnalyzer/Core/GRState.cpp
@@ -165,7 +165,7 @@ SVal GRState::getSValAsScalarOrLoc(const MemRegion *R) const {
 
   if (const TypedRegion *TR = dyn_cast<TypedRegion>(R)) {
     QualType T = TR->getValueType();
-    if (Loc::IsLocType(T) || T->isIntegerType())
+    if (Loc::isLocType(T) || T->isIntegerType())
       return getSVal(R);
   }
 
diff --git a/lib/StaticAnalyzer/Core/ObjCMessage.cpp b/lib/StaticAnalyzer/Core/ObjCMessage.cpp
index a27a5b6be8..2e370d62e4 100644
--- a/lib/StaticAnalyzer/Core/ObjCMessage.cpp
+++ b/lib/StaticAnalyzer/Core/ObjCMessage.cpp
@@ -93,7 +93,7 @@ SVal CallOrObjCMessage::getArgSValAsScalarOrLoc(unsigned i) const {
   assert(i < getNumArgs());
   if (CallE) return State->getSValAsScalarOrLoc(CallE->getArg(i));
   QualType argT = Msg.getArgType(i);
-  if (Loc::IsLocType(argT) || argT->isIntegerType())
+  if (Loc::isLocType(argT) || argT->isIntegerType())
     return Msg.getArgSVal(i, State);
   return UnknownVal();
 }
diff --git a/lib/StaticAnalyzer/Core/RegionStore.cpp b/lib/StaticAnalyzer/Core/RegionStore.cpp
index a6a55933ad..dc31715ccb 100644
--- a/lib/StaticAnalyzer/Core/RegionStore.cpp
+++ b/lib/StaticAnalyzer/Core/RegionStore.cpp
@@ -1333,7 +1333,7 @@ Store RegionStoreManager::setImplicitDefaultValue(Store store,
   RegionBindings B = GetRegionBindings(store);
   SVal V;
 
-  if (Loc::IsLocType(T))
+  if (Loc::isLocType(T))
     V = svalBuilder.makeNull();
   else if (T->isIntegerType())
     V = svalBuilder.makeZeroVal(T);
diff --git a/lib/StaticAnalyzer/Core/SValBuilder.cpp b/lib/StaticAnalyzer/Core/SValBuilder.cpp
index b2ffcbda71..796613383b 100644
--- a/lib/StaticAnalyzer/Core/SValBuilder.cpp
+++ b/lib/StaticAnalyzer/Core/SValBuilder.cpp
@@ -26,7 +26,7 @@ using namespace ento;
 //===----------------------------------------------------------------------===//
 
 DefinedOrUnknownSVal SValBuilder::makeZeroVal(QualType T) {
-  if (Loc::IsLocType(T))
+  if (Loc::isLocType(T))
     return makeNull();
 
   if (T->isIntegerType())
@@ -43,14 +43,14 @@ NonLoc SValBuilder::makeNonLoc(const SymExpr *lhs, BinaryOperator::Opcode op,
   // The Environment ensures we always get a persistent APSInt in
   // BasicValueFactory, so we don't need to get the APSInt from
   // BasicValueFactory again.
-  assert(!Loc::IsLocType(T));
+  assert(!Loc::isLocType(T));
   return nonloc::SymExprVal(SymMgr.getSymIntExpr(lhs, op, v, T));
 }
 
 NonLoc SValBuilder::makeNonLoc(const SymExpr *lhs, BinaryOperator::Opcode op,
                                 const SymExpr *rhs, QualType T) {
   assert(SymMgr.getType(lhs) == SymMgr.getType(rhs));
-  assert(!Loc::IsLocType(T));
+  assert(!Loc::isLocType(T));
   return nonloc::SymExprVal(SymMgr.getSymSymExpr(lhs, op, rhs, T));
 }
 
@@ -78,7 +78,7 @@ SValBuilder::getRegionValueSymbolVal(const TypedRegion* R) {
 
   SymbolRef sym = SymMgr.getRegionValueSymbol(R);
 
-  if (Loc::IsLocType(T))
+  if (Loc::isLocType(T))
     return loc::MemRegionVal(MemMgr.getSymbolicRegion(sym));
 
   return nonloc::SymbolVal(sym);
@@ -94,7 +94,7 @@ DefinedOrUnknownSVal SValBuilder::getConjuredSymbolVal(const void *SymbolTag,
 
   SymbolRef sym = SymMgr.getConjuredSymbol(E, Count, SymbolTag);
 
-  if (Loc::IsLocType(T))
+  if (Loc::isLocType(T))
     return loc::MemRegionVal(MemMgr.getSymbolicRegion(sym));
 
   return nonloc::SymbolVal(sym);
@@ -110,7 +110,7 @@ DefinedOrUnknownSVal SValBuilder::getConjuredSymbolVal(const void *SymbolTag,
 
   SymbolRef sym = SymMgr.getConjuredSymbol(E, T, Count, SymbolTag);
 
-  if (Loc::IsLocType(T))
+  if (Loc::isLocType(T))
     return loc::MemRegionVal(MemMgr.getSymbolicRegion(sym));
 
   return nonloc::SymbolVal(sym);
@@ -124,7 +124,7 @@ DefinedSVal SValBuilder::getMetadataSymbolVal(const void *SymbolTag,
 
   SymbolRef sym = SymMgr.getMetadataSymbol(MR, E, T, Count, SymbolTag);
 
-  if (Loc::IsLocType(T))
+  if (Loc::isLocType(T))
     return loc::MemRegionVal(MemMgr.getSymbolicRegion(sym));
 
   return nonloc::SymbolVal(sym);
@@ -140,7 +140,7 @@ SValBuilder::getDerivedRegionValueSymbolVal(SymbolRef parentSymbol,
 
   SymbolRef sym = SymMgr.getDerivedSymbol(parentSymbol, R);
 
-  if (Loc::IsLocType(T))
+  if (Loc::isLocType(T))
     return loc::MemRegionVal(MemMgr.getSymbolicRegion(sym));
 
   return nonloc::SymbolVal(sym);
@@ -216,11 +216,11 @@ SVal SValBuilder::evalCast(SVal val, QualType castTy, QualType originalTy) {
     return evalCastNL(cast<NonLoc>(val), castTy);
 
   // Check for casts from pointers to integers.
-  if (castTy->isIntegerType() && Loc::IsLocType(originalTy))
+  if (castTy->isIntegerType() && Loc::isLocType(originalTy))
     return evalCastL(cast<Loc>(val), castTy);
 
   // Check for casts from integers to pointers.
-  if (Loc::IsLocType(castTy) && originalTy->isIntegerType()) {
+  if (Loc::isLocType(castTy) && originalTy->isIntegerType()) {
     if (nonloc::LocAsInteger *LV = dyn_cast<nonloc::LocAsInteger>(&val)) {
       if (const MemRegion *R = LV->getLoc().getAsRegion()) {
         StoreManager &storeMgr = StateMgr.getStoreManager();
@@ -234,7 +234,7 @@ SVal SValBuilder::evalCast(SVal val, QualType castTy, QualType originalTy) {
 
   // Just pass through function and block pointers.
   if (originalTy->isBlockPointerType() || originalTy->isFunctionPointerType()) {
-    assert(Loc::IsLocType(castTy));
+    assert(Loc::isLocType(castTy));
     return val;
   }
 
@@ -264,7 +264,7 @@ SVal SValBuilder::evalCast(SVal val, QualType castTy, QualType originalTy) {
     // FIXME: We should handle the case where we strip off view layers to get
     //  to a desugared type.
 
-    if (!Loc::IsLocType(castTy)) {
+    if (!Loc::isLocType(castTy)) {
       // FIXME: There can be gross cases where one casts the result of a function
       // (that returns a pointer) to some other value that happens to fit
       // within that pointer value.  We currently have no good way to
@@ -291,7 +291,7 @@ SVal SValBuilder::evalCast(SVal val, QualType castTy, QualType originalTy) {
     //    return bar(x)+1; // no-warning
     //  }
 
-    assert(Loc::IsLocType(originalTy) || originalTy->isFunctionType() ||
+    assert(Loc::isLocType(originalTy) || originalTy->isFunctionType() ||
            originalTy->isBlockPointerType());
 
     StoreManager &storeMgr = StateMgr.getStoreManager();
diff --git a/lib/StaticAnalyzer/Core/SVals.cpp b/lib/StaticAnalyzer/Core/SVals.cpp
index cc7231bc2c..cc866d0127 100644
--- a/lib/StaticAnalyzer/Core/SVals.cpp
+++ b/lib/StaticAnalyzer/Core/SVals.cpp
@@ -68,7 +68,7 @@ SymbolRef SVal::getAsLocSymbol() const {
     return X->getLoc().getAsLocSymbol();
 
   if (const loc::MemRegionVal *X = dyn_cast<loc::MemRegionVal>(this)) {
-    const MemRegion *R = X->StripCasts();
+    const MemRegion *R = X->stripCasts();
     if (const SymbolicRegion *SymR = dyn_cast<SymbolicRegion>(R))
       return SymR->getSymbol();
   }
@@ -128,7 +128,7 @@ const MemRegion *SVal::getAsRegion() const {
   return 0;
 }
 
-const MemRegion *loc::MemRegionVal::StripCasts() const {
+const MemRegion *loc::MemRegionVal::stripCasts() const {
   const MemRegion *R = getRegion();
   return R ?  R->StripCasts() : NULL;
 }
diff --git a/lib/StaticAnalyzer/Core/SimpleConstraintManager.cpp b/lib/StaticAnalyzer/Core/SimpleConstraintManager.cpp
index cca32e7b86..e0b61ab580 100644
--- a/lib/StaticAnalyzer/Core/SimpleConstraintManager.cpp
+++ b/lib/StaticAnalyzer/Core/SimpleConstraintManager.cpp
@@ -261,9 +261,9 @@ const GRState *SimpleConstraintManager::assumeSymRel(const GRState *state,
   ASTContext &Ctx = StateMgr.getContext();
 
   QualType T = Sym->getType(Ctx);
-  assert(T->isIntegerType() || Loc::IsLocType(T));
+  assert(T->isIntegerType() || Loc::isLocType(T));
   unsigned bitwidth = Ctx.getTypeSize(T);
-  bool isSymUnsigned = T->isUnsignedIntegerType() || Loc::IsLocType(T);
+  bool isSymUnsigned = T->isUnsignedIntegerType() || Loc::isLocType(T);
 
   // Convert the adjustment.
   Adjustment.setIsUnsigned(isSymUnsigned);
diff --git a/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp b/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp
index 2642f58cd6..9a46bd6d69 100644
--- a/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp
+++ b/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp
@@ -59,7 +59,7 @@ SValBuilder *ento::createSimpleSValBuilder(llvm::BumpPtrAllocator &alloc,
 
 SVal SimpleSValBuilder::evalCastNL(NonLoc val, QualType castTy) {
 
-  bool isLocType = Loc::IsLocType(castTy);
+  bool isLocType = Loc::isLocType(castTy);
 
   if (nonloc::LocAsInteger *LI = dyn_cast<nonloc::LocAsInteger>(&val)) {
     if (isLocType)
@@ -97,7 +97,7 @@ SVal SimpleSValBuilder::evalCastNL(NonLoc val, QualType castTy) {
     return UnknownVal();
 
   llvm::APSInt i = cast<nonloc::ConcreteInt>(val).getValue();
-  i.setIsUnsigned(castTy->isUnsignedIntegerType() || Loc::IsLocType(castTy));
+  i.setIsUnsigned(castTy->isUnsignedIntegerType() || Loc::isLocType(castTy));
   i = i.extOrTrunc(Context.getTypeSize(castTy));
 
   if (isLocType)
@@ -114,7 +114,7 @@ SVal SimpleSValBuilder::evalCastL(Loc val, QualType castTy) {
   //   can be introduced by the frontend for corner cases, e.g
   //   casting from va_list* to __builtin_va_list&.
   //
-  if (Loc::IsLocType(castTy) || castTy->isReferenceType())
+  if (Loc::isLocType(castTy) || castTy->isReferenceType())
     return val;
 
   // FIXME: Handle transparent unions where a value can be "transparently"
@@ -129,7 +129,7 @@ SVal SimpleSValBuilder::evalCastL(Loc val, QualType castTy) {
       return makeLocAsInteger(val, BitWidth);
 
     llvm::APSInt i = cast<loc::ConcreteInt>(val).getValue();
-    i.setIsUnsigned(castTy->isUnsignedIntegerType() || Loc::IsLocType(castTy));
+    i.setIsUnsigned(castTy->isUnsignedIntegerType() || Loc::isLocType(castTy));
     i = i.extOrTrunc(BitWidth);
     return makeIntVal(i);
   }
diff --git a/lib/StaticAnalyzer/Core/SymbolManager.cpp b/lib/StaticAnalyzer/Core/SymbolManager.cpp
index f4ed806402..c1ca1cfcdc 100644
--- a/lib/StaticAnalyzer/Core/SymbolManager.cpp
+++ b/lib/StaticAnalyzer/Core/SymbolManager.cpp
@@ -235,7 +235,7 @@ SymbolManager::~SymbolManager() {}
 bool SymbolManager::canSymbolicate(QualType T) {
   T = T.getCanonicalType();
 
-  if (Loc::IsLocType(T))
+  if (Loc::isLocType(T))
     return true;
 
   if (T->isIntegerType())