[clang][analyzer][NFC] Remove unnecessary casts around Allocate function calls

[steakhal]

Makes sense.

clang/lib/StaticAnalyzer/Core/BasicValueFactory.cpp

const llvm::APSInt& BasicValueFactory::getValue(const llvm::APSInt& X) {
   void *InsertPos;
 
   using FoldNodeTy = llvm::FoldingSetNodeWrapper<llvm::APSInt>;
 
   X.Profile(ID);
   FoldNodeTy* P = APSIntSet.FindNodeOrInsertPos(ID, InsertPos);
 
   if (!P) {
-    P = (FoldNodeTy*) BPAlloc.Allocate<FoldNodeTy>();
+    P = BPAlloc.Allocate<FoldNodeTy>();
     new (P) FoldNodeTy(X);
     APSIntSet.InsertNode(P, InsertPos);
   }
 
   return *P;
 }
 
 const llvm::APSInt& BasicValueFactory::getValue(const llvm::APInt& X,
BasicValueFactory::getCompoundValData(QualType T,
                                       llvm::ImmutableList<SVal> Vals) {
   llvm::FoldingSetNodeID ID;
   CompoundValData::Profile(ID, T, Vals);
   void *InsertPos;
 
   CompoundValData* D = CompoundValDataSet.FindNodeOrInsertPos(ID, InsertPos);
 
   if (!D) {
-    D = (CompoundValData*) BPAlloc.Allocate<CompoundValData>();
+    D = BPAlloc.Allocate<CompoundValData>();
     new (D) CompoundValData(T, Vals);
     CompoundValDataSet.InsertNode(D, InsertPos);
   }
 
   return D;
 }
 
 const LazyCompoundValData*
 BasicValueFactory::getLazyCompoundValData(const StoreRef &store,
                                           const TypedValueRegion *region) {
   llvm::FoldingSetNodeID ID;
   LazyCompoundValData::Profile(ID, store, region);
   void *InsertPos;
 
   LazyCompoundValData *D =
     LazyCompoundValDataSet.FindNodeOrInsertPos(ID, InsertPos);
 
   if (!D) {
-    D = (LazyCompoundValData*) BPAlloc.Allocate<LazyCompoundValData>();
+    D = BPAlloc.Allocate<LazyCompoundValData>();
     new (D) LazyCompoundValData(store, region);
     LazyCompoundValDataSet.InsertNode(D, InsertPos);
   }
 
   return D;
 }
 
 const PointerToMemberData *BasicValueFactory::getPointerToMemberData(
     const NamedDecl *ND, llvm::ImmutableList<const CXXBaseSpecifier *> L) {
   llvm::FoldingSetNodeID ID;
   PointerToMemberData::Profile(ID, ND, L);
   void *InsertPos;
 
   PointerToMemberData *D =
       PointerToMemberDataSet.FindNodeOrInsertPos(ID, InsertPos);
 
   if (!D) {
-    D = (PointerToMemberData *)BPAlloc.Allocate<PointerToMemberData>();
+    D = BPAlloc.Allocate<PointerToMemberData>();
     new (D) PointerToMemberData(ND, L);
     PointerToMemberDataSet.InsertNode(D, InsertPos);
   }
 
   return D;
 }
 
 LLVM_ATTRIBUTE_UNUSED bool hasNoRepeatedElements(
BasicValueFactory::getPersistentSValWithData(const SVal& V, uintptr_t Data) {
 
   PersistentSValsTy& Map = *((PersistentSValsTy*) PersistentSVals);
 
   using FoldNodeTy = llvm::FoldingSetNodeWrapper<SValData>;
 
   FoldNodeTy* P = Map.FindNodeOrInsertPos(ID, InsertPos);
 
   if (!P) {
-    P = (FoldNodeTy*) BPAlloc.Allocate<FoldNodeTy>();
+    P = BPAlloc.Allocate<FoldNodeTy>();
     new (P) FoldNodeTy(std::make_pair(V, Data));
     Map.InsertNode(P, InsertPos);
   }
 
   return P->getValue();
 }
 
 const std::pair<SVal, SVal>&
 BasicValueFactory::getPersistentSValPair(const SVal& V1, const SVal& V2) {
   // Lazily create the folding set.
   if (!PersistentSValPairs) PersistentSValPairs = new PersistentSValPairsTy();
 
   llvm::FoldingSetNodeID ID;
   void *InsertPos;
   V1.Profile(ID);
   V2.Profile(ID);
 
   PersistentSValPairsTy& Map = *((PersistentSValPairsTy*) PersistentSValPairs);
 
   using FoldNodeTy = llvm::FoldingSetNodeWrapper<SValPair>;
 
   FoldNodeTy* P = Map.FindNodeOrInsertPos(ID, InsertPos);
 
   if (!P) {
-    P = (FoldNodeTy*) BPAlloc.Allocate<FoldNodeTy>();
+    P = BPAlloc.Allocate<FoldNodeTy>();
     new (P) FoldNodeTy(std::make_pair(V1, V2));
     Map.InsertNode(P, InsertPos);
   }
 
   return P->getValue();
 }
 
 const SVal* BasicValueFactory::getPersistentSVal(SVal X) {
   return &getPersistentSValWithData(X, 0).first;
 }

clang/lib/StaticAnalyzer/Core/ExplodedGraph.cpp

ExplodedNode *ExplodedGraph::getNode(const ProgramPoint &L,
 
   if (!V) {
     if (!FreeNodes.empty()) {
       V = FreeNodes.back();
       FreeNodes.pop_back();
     }
     else {
       // Allocate a new node.
-      V = (NodeTy*) getAllocator().Allocate<NodeTy>();
+      V = getAllocator().Allocate<NodeTy>();
     }
 
     ++NumNodes;
     new (V) NodeTy(L, State, NumNodes, IsSink);
 
     if (ReclaimNodeInterval)
       ChangedNodes.push_back(V);
 
     // Insert the node into the node set and return it.
     Nodes.InsertNode(V, InsertPos);
 
     if (IsNew) *IsNew = true;
   }
   else
     if (IsNew) *IsNew = false;
 
   return V;
 }
 
 ExplodedNode *ExplodedGraph::createUncachedNode(const ProgramPoint &L,
                                                 ProgramStateRef State,
                                                 int64_t Id,
                                                 bool IsSink) {
-  NodeTy *V = (NodeTy *) getAllocator().Allocate<NodeTy>();
+  NodeTy *V = getAllocator().Allocate<NodeTy>();
   new (V) NodeTy(L, State, Id, IsSink);
   return V;
 }
 
 std::unique_ptr<ExplodedGraph>
 ExplodedGraph::trim(ArrayRef<const NodeTy *> Sinks,
                     InterExplodedGraphMap *ForwardMap,
                     InterExplodedGraphMap *InverseMap) const {

clang/lib/StaticAnalyzer/Core/ProgramState.cpp

if (ProgramState *I = StateSet.FindNodeOrInsertPos(ID, InsertPos))
     return I;
 
   ProgramState *newState = nullptr;
   if (!freeStates.empty()) {
     newState = freeStates.back();
     freeStates.pop_back();
   }
   else {
-    newState = (ProgramState*) Alloc.Allocate<ProgramState>();
+    newState = Alloc.Allocate<ProgramState>();
   }
   new (newState) ProgramState(State);
   StateSet.InsertNode(newState, InsertPos);
   return newState;
 }
 
 ProgramStateRef ProgramState::makeWithStore(const StoreRef &store) const {
   ProgramState NewSt(*this);

clang/lib/StaticAnalyzer/Core/SymbolManager.cpp

 
 const SymbolRegionValue*
 SymbolManager::getRegionValueSymbol(const TypedValueRegion* R) {
   llvm::FoldingSetNodeID profile;
   SymbolRegionValue::Profile(profile, R);
   void *InsertPos;
   SymExpr *SD = DataSet.FindNodeOrInsertPos(profile, InsertPos);
   if (!SD) {
-    SD = (SymExpr*) BPAlloc.Allocate<SymbolRegionValue>();
+    SD = BPAlloc.Allocate<SymbolRegionValue>();
     new (SD) SymbolRegionValue(SymbolCounter, R);
     DataSet.InsertNode(SD, InsertPos);
     ++SymbolCounter;
   }
 
   return cast<SymbolRegionValue>(SD);
 }
 
 const SymbolConjured* SymbolManager::conjureSymbol(const Stmt *E,
                                                    const LocationContext *LCtx,
                                                    QualType T,
                                                    unsigned Count,
                                                    const void *SymbolTag) {
   llvm::FoldingSetNodeID profile;
   SymbolConjured::Profile(profile, E, T, Count, LCtx, SymbolTag);
   void *InsertPos;
   SymExpr *SD = DataSet.FindNodeOrInsertPos(profile, InsertPos);
   if (!SD) {
-    SD = (SymExpr*) BPAlloc.Allocate<SymbolConjured>();
+    SD = BPAlloc.Allocate<SymbolConjured>();
     new (SD) SymbolConjured(SymbolCounter, E, LCtx, T, Count, SymbolTag);
     DataSet.InsertNode(SD, InsertPos);
     ++SymbolCounter;
   }
 
   return cast<SymbolConjured>(SD);
 }
 
 const SymbolDerived*
 SymbolManager::getDerivedSymbol(SymbolRef parentSymbol,
                                 const TypedValueRegion *R) {
   llvm::FoldingSetNodeID profile;
   SymbolDerived::Profile(profile, parentSymbol, R);
   void *InsertPos;
   SymExpr *SD = DataSet.FindNodeOrInsertPos(profile, InsertPos);
   if (!SD) {
-    SD = (SymExpr*) BPAlloc.Allocate<SymbolDerived>();
+    SD = BPAlloc.Allocate<SymbolDerived>();
     new (SD) SymbolDerived(SymbolCounter, parentSymbol, R);
     DataSet.InsertNode(SD, InsertPos);
     ++SymbolCounter;
   }
 
   return cast<SymbolDerived>(SD);
 }
 
 const SymbolExtent*
 SymbolManager::getExtentSymbol(const SubRegion *R) {
   llvm::FoldingSetNodeID profile;
   SymbolExtent::Profile(profile, R);
   void *InsertPos;
   SymExpr *SD = DataSet.FindNodeOrInsertPos(profile, InsertPos);
   if (!SD) {
-    SD = (SymExpr*) BPAlloc.Allocate<SymbolExtent>();
+    SD = BPAlloc.Allocate<SymbolExtent>();
     new (SD) SymbolExtent(SymbolCounter, R);
     DataSet.InsertNode(SD, InsertPos);
     ++SymbolCounter;
   }
 
   return cast<SymbolExtent>(SD);
 }
 
 const SymbolMetadata *
 SymbolManager::getMetadataSymbol(const MemRegion* R, const Stmt *S, QualType T,
                                  const LocationContext *LCtx,
                                  unsigned Count, const void *SymbolTag) {
   llvm::FoldingSetNodeID profile;
   SymbolMetadata::Profile(profile, R, S, T, LCtx, Count, SymbolTag);
   void *InsertPos;
   SymExpr *SD = DataSet.FindNodeOrInsertPos(profile, InsertPos);
   if (!SD) {
-    SD = (SymExpr*) BPAlloc.Allocate<SymbolMetadata>();
+    SD = BPAlloc.Allocate<SymbolMetadata>();
     new (SD) SymbolMetadata(SymbolCounter, R, S, T, LCtx, Count, SymbolTag);
     DataSet.InsertNode(SD, InsertPos);
     ++SymbolCounter;
   }
 
   return cast<SymbolMetadata>(SD);
 }
 
 const SymbolCast*
 SymbolManager::getCastSymbol(const SymExpr *Op,
                              QualType From, QualType To) {
   llvm::FoldingSetNodeID ID;
   SymbolCast::Profile(ID, Op, From, To);
   void *InsertPos;
   SymExpr *data = DataSet.FindNodeOrInsertPos(ID, InsertPos);
   if (!data) {
-    data = (SymbolCast*) BPAlloc.Allocate<SymbolCast>();
+    data = BPAlloc.Allocate<SymbolCast>();
     new (data) SymbolCast(Op, From, To);
     DataSet.InsertNode(data, InsertPos);
   }
 
   return cast<SymbolCast>(data);
 }
 
 const SymIntExpr *SymbolManager::getSymIntExpr(const SymExpr *lhs,
                                                BinaryOperator::Opcode op,
                                                const llvm::APSInt& v,
                                                QualType t) {
   llvm::FoldingSetNodeID ID;
   SymIntExpr::Profile(ID, lhs, op, v, t);
   void *InsertPos;
   SymExpr *data = DataSet.FindNodeOrInsertPos(ID, InsertPos);
 
   if (!data) {
-    data = (SymIntExpr*) BPAlloc.Allocate<SymIntExpr>();
+    data = BPAlloc.Allocate<SymIntExpr>();
     new (data) SymIntExpr(lhs, op, v, t);
     DataSet.InsertNode(data, InsertPos);
   }
 
   return cast<SymIntExpr>(data);
 }
 
 const IntSymExpr *SymbolManager::getIntSymExpr(const llvm::APSInt& lhs,
                                                BinaryOperator::Opcode op,
                                                const SymExpr *rhs,
                                                QualType t) {
   llvm::FoldingSetNodeID ID;
   IntSymExpr::Profile(ID, lhs, op, rhs, t);
   void *InsertPos;
   SymExpr *data = DataSet.FindNodeOrInsertPos(ID, InsertPos);
 
   if (!data) {
-    data = (IntSymExpr*) BPAlloc.Allocate<IntSymExpr>();
+    data = BPAlloc.Allocate<IntSymExpr>();
     new (data) IntSymExpr(lhs, op, rhs, t);
     DataSet.InsertNode(data, InsertPos);
   }
 
   return cast<IntSymExpr>(data);
 }
 
 const SymSymExpr *SymbolManager::getSymSymExpr(const SymExpr *lhs,
                                                BinaryOperator::Opcode op,
                                                const SymExpr *rhs,
                                                QualType t) {
   llvm::FoldingSetNodeID ID;
   SymSymExpr::Profile(ID, lhs, op, rhs, t);
   void *InsertPos;
   SymExpr *data = DataSet.FindNodeOrInsertPos(ID, InsertPos);
 
   if (!data) {
-    data = (SymSymExpr*) BPAlloc.Allocate<SymSymExpr>();
+    data = BPAlloc.Allocate<SymSymExpr>();
     new (data) SymSymExpr(lhs, op, rhs, t);
     DataSet.InsertNode(data, InsertPos);
   }
 
   return cast<SymSymExpr>(data);
 }
 
 const UnarySymExpr *SymbolManager::getUnarySymExpr(const SymExpr *Operand,
                                                    UnaryOperator::Opcode Opc,
                                                    QualType T) {
   llvm::FoldingSetNodeID ID;
   UnarySymExpr::Profile(ID, Operand, Opc, T);
   void *InsertPos;
   SymExpr *data = DataSet.FindNodeOrInsertPos(ID, InsertPos);
   if (!data) {
-    data = (UnarySymExpr *)BPAlloc.Allocate<UnarySymExpr>();
+    data = BPAlloc.Allocate<UnarySymExpr>();
     new (data) UnarySymExpr(Operand, Opc, T);
     DataSet.InsertNode(data, InsertPos);
   }
 
   return cast<UnarySymExpr>(data);
 }
 
 QualType SymbolConjured::getType() const {