Last step of template cleanup: merge *BuilderImpl to *Builder.

Some Builders need further cleanup.


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

1 files changed, 177 insertions, 177 deletions

diff --git a/lib/Analysis/GRExprEngine.cpp b/lib/Analysis/GRExprEngine.cpp
index bf24248251..47f77ce3bd 100644
--- a/lib/Analysis/GRExprEngine.cpp
+++ b/lib/Analysis/GRExprEngine.cpp
@@ -82,7 +82,7 @@ public:
     AllStmts = F.Concat(A, AllStmts);    
   }
 
-  virtual bool Audit(NodeTy* N, GRStateManager& VMgr) {
+  virtual bool Audit(ExplodedNode* N, GRStateManager& VMgr) {
     // First handle the auditors that accept all statements.
     bool isSink = false;
     for (Checks::iterator I = AllStmts.begin(), E = AllStmts.end(); I!=E; ++I)
@@ -107,25 +107,26 @@ public:
 // Checker worklist routines.
 //===----------------------------------------------------------------------===//
   
-void GRExprEngine::CheckerVisit(Stmt *S, NodeSet &Dst, NodeSet &Src,
-                                bool isPrevisit) {
+void GRExprEngine::CheckerVisit(Stmt *S, ExplodedNodeSet &Dst, 
+                                ExplodedNodeSet &Src, bool isPrevisit) {
   
   if (Checkers.empty()) {
     Dst = Src;
     return;
   }
   
-  NodeSet Tmp;
-  NodeSet *PrevSet = &Src;
+  ExplodedNodeSet Tmp;
+  ExplodedNodeSet *PrevSet = &Src;
   
   for (std::vector<Checker*>::iterator I = Checkers.begin(), E = Checkers.end();
        I != E; ++I) {
 
-    NodeSet *CurrSet = (I+1 == E) ? &Dst : (PrevSet == &Tmp) ? &Src : &Tmp;
+    ExplodedNodeSet *CurrSet = (I+1 == E) ? &Dst 
+                                          : (PrevSet == &Tmp) ? &Src : &Tmp;
     CurrSet->clear();
     Checker *checker = *I;
     
-    for (NodeSet::iterator NI = PrevSet->begin(), NE = PrevSet->end();
+    for (ExplodedNodeSet::iterator NI = PrevSet->begin(), NE = PrevSet->end();
          NI != NE; ++NI)
       checker->GR_Visit(*CurrSet, *Builder, *this, S, *NI, isPrevisit);
     
@@ -231,7 +232,7 @@ const GRState* GRExprEngine::getInitialState() {
 // Top-level transfer function logic (Dispatcher).
 //===----------------------------------------------------------------------===//
 
-void GRExprEngine::ProcessStmt(Stmt* S, StmtNodeBuilder& builder) {
+void GRExprEngine::ProcessStmt(Stmt* S, GRStmtNodeBuilder& builder) {
   
   PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),
                                 S->getLocStart(),
@@ -255,7 +256,7 @@ void GRExprEngine::ProcessStmt(Stmt* S, StmtNodeBuilder& builder) {
                            : EntryNode->getState();
 
   // Process any special transfer function for dead symbols.
-  NodeSet Tmp;
+  ExplodedNodeSet Tmp;
   
   if (!SymReaper.hasDeadSymbols())
     Tmp.Add(EntryNode);
@@ -275,9 +276,9 @@ void GRExprEngine::ProcessStmt(Stmt* S, StmtNodeBuilder& builder) {
   
   bool HasAutoGenerated = false;
 
-  for (NodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) {
+  for (ExplodedNodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) {
 
-    NodeSet Dst;
+    ExplodedNodeSet Dst;
     
     // Set the cleaned state.  
     Builder->SetCleanedState(*I == EntryNode ? CleanedState : GetState(*I));
@@ -306,7 +307,7 @@ void GRExprEngine::ProcessStmt(Stmt* S, StmtNodeBuilder& builder) {
   Builder = NULL;
 }
 
-void GRExprEngine::Visit(Stmt* S, NodeTy* Pred, NodeSet& Dst) {  
+void GRExprEngine::Visit(Stmt* S, ExplodedNode* Pred, ExplodedNodeSet& Dst) {  
   PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),
                                 S->getLocStart(),
                                 "Error evaluating statement");
@@ -351,7 +352,7 @@ void GRExprEngine::Visit(Stmt* S, NodeTy* Pred, NodeSet& Dst) {
       }
 
       if (EagerlyAssume && (B->isRelationalOp() || B->isEqualityOp())) {
-        NodeSet Tmp;
+        ExplodedNodeSet Tmp;
         VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Tmp);
         EvalEagerlyAssume(Dst, Tmp, cast<Expr>(S));        
       }
@@ -477,7 +478,7 @@ void GRExprEngine::Visit(Stmt* S, NodeTy* Pred, NodeSet& Dst) {
     case Stmt::UnaryOperatorClass: {
       UnaryOperator *U = cast<UnaryOperator>(S);
       if (EagerlyAssume && (U->getOpcode() == UnaryOperator::LNot)) {
-        NodeSet Tmp;
+        ExplodedNodeSet Tmp;
         VisitUnaryOperator(U, Pred, Tmp, false);
         EvalEagerlyAssume(Dst, Tmp, U);
       }
@@ -488,7 +489,8 @@ void GRExprEngine::Visit(Stmt* S, NodeTy* Pred, NodeSet& Dst) {
   }
 }
 
-void GRExprEngine::VisitLValue(Expr* Ex, NodeTy* Pred, NodeSet& Dst) {
+void GRExprEngine::VisitLValue(Expr* Ex, ExplodedNode* Pred, 
+                               ExplodedNodeSet& Dst) {
   
   Ex = Ex->IgnoreParens();
   
@@ -574,12 +576,9 @@ bool GRExprEngine::ProcessBlockEntrance(CFGBlock* B, const GRState*,
 // Generic node creation.
 //===----------------------------------------------------------------------===//
 
-GRExprEngine::NodeTy* GRExprEngine::MakeNode(NodeSet& Dst, Stmt* S,
-                                             NodeTy* Pred,
-                                             const GRState* St,
-                                             ProgramPoint::Kind K,
-                                             const void *tag) {
-  
+ExplodedNode* GRExprEngine::MakeNode(ExplodedNodeSet& Dst, Stmt* S,
+                                     ExplodedNode* Pred, const GRState* St,
+                                     ProgramPoint::Kind K, const void *tag) {
   assert (Builder && "GRStmtNodeBuilder not present.");
   SaveAndRestore<const void*> OldTag(Builder->Tag);
   Builder->Tag = tag;
@@ -685,7 +684,7 @@ static SVal RecoverCastedSymbol(GRStateManager& StateMgr, const GRState* state,
 }
 
 void GRExprEngine::ProcessBranch(Stmt* Condition, Stmt* Term,
-                                 BranchNodeBuilder& builder) {
+                                 GRBranchNodeBuilder& builder) {
   
   // Remove old bindings for subexpressions.
   const GRState* PrevState =
@@ -731,7 +730,7 @@ void GRExprEngine::ProcessBranch(Stmt* Condition, Stmt* Term,
     }
       
     case SVal::UndefinedKind: {      
-      NodeTy* N = builder.generateNode(PrevState, true);
+      ExplodedNode* N = builder.generateNode(PrevState, true);
 
       if (N) {
         N->markAsSink();
@@ -762,7 +761,7 @@ void GRExprEngine::ProcessBranch(Stmt* Condition, Stmt* Term,
 
 /// ProcessIndirectGoto - Called by GRCoreEngine.  Used to generate successor
 ///  nodes by processing the 'effects' of a computed goto jump.
-void GRExprEngine::ProcessIndirectGoto(IndirectGotoNodeBuilder& builder) {
+void GRExprEngine::ProcessIndirectGoto(GRIndirectGotoNodeBuilder& builder) {
 
   const GRState *state = builder.getState();  
   SVal V = state->getSVal(builder.getTarget());
@@ -774,7 +773,7 @@ void GRExprEngine::ProcessIndirectGoto(IndirectGotoNodeBuilder& builder) {
   //   (3) We have no clue about the label.  Dispatch to all targets.
   //
   
-  typedef IndirectGotoNodeBuilder::iterator iterator;
+  typedef GRIndirectGotoNodeBuilder::iterator iterator;
 
   if (isa<loc::GotoLabel>(V)) {
     LabelStmt* L = cast<loc::GotoLabel>(V).getLabel();
@@ -792,7 +791,7 @@ void GRExprEngine::ProcessIndirectGoto(IndirectGotoNodeBuilder& builder) {
 
   if (isa<loc::ConcreteInt>(V) || isa<UndefinedVal>(V)) {
     // Dispatch to the first target and mark it as a sink.
-    NodeTy* N = builder.generateNode(builder.begin(), state, true);
+    ExplodedNode* N = builder.generateNode(builder.begin(), state, true);
     UndefBranches.insert(N);
     return;
   }
@@ -806,7 +805,7 @@ void GRExprEngine::ProcessIndirectGoto(IndirectGotoNodeBuilder& builder) {
 
 
 void GRExprEngine::VisitGuardedExpr(Expr* Ex, Expr* L, Expr* R,
-                                    NodeTy* Pred, NodeSet& Dst) {
+                                    ExplodedNode* Pred, ExplodedNodeSet& Dst) {
   
   assert (Ex == CurrentStmt && getCFG().isBlkExpr(Ex));
   
@@ -825,14 +824,14 @@ void GRExprEngine::VisitGuardedExpr(Expr* Ex, Expr* L, Expr* R,
 
 /// ProcessSwitch - Called by GRCoreEngine.  Used to generate successor
 ///  nodes by processing the 'effects' of a switch statement.
-void GRExprEngine::ProcessSwitch(SwitchNodeBuilder& builder) {  
-  typedef SwitchNodeBuilder::iterator iterator;  
+void GRExprEngine::ProcessSwitch(GRSwitchNodeBuilder& builder) {  
+  typedef GRSwitchNodeBuilder::iterator iterator;  
   const GRState* state = builder.getState();  
   Expr* CondE = builder.getCondition();
   SVal  CondV = state->getSVal(CondE);
 
   if (CondV.isUndef()) {
-    NodeTy* N = builder.generateDefaultCaseNode(state, true);
+    ExplodedNode* N = builder.generateDefaultCaseNode(state, true);
     UndefBranches.insert(N);
     return;
   }
@@ -912,8 +911,8 @@ void GRExprEngine::ProcessSwitch(SwitchNodeBuilder& builder) {
 // Transfer functions: logical operations ('&&', '||').
 //===----------------------------------------------------------------------===//
 
-void GRExprEngine::VisitLogicalExpr(BinaryOperator* B, NodeTy* Pred,
-                                    NodeSet& Dst) {
+void GRExprEngine::VisitLogicalExpr(BinaryOperator* B, ExplodedNode* Pred,
+                                    ExplodedNodeSet& Dst) {
   
   assert(B->getOpcode() == BinaryOperator::LAnd ||
          B->getOpcode() == BinaryOperator::LOr);
@@ -967,8 +966,8 @@ void GRExprEngine::VisitLogicalExpr(BinaryOperator* B, NodeTy* Pred,
 // Transfer functions: Loads and stores.
 //===----------------------------------------------------------------------===//
 
-void GRExprEngine::VisitDeclRefExpr(DeclRefExpr* Ex, NodeTy* Pred, NodeSet& Dst,
-                                    bool asLValue) {
+void GRExprEngine::VisitDeclRefExpr(DeclRefExpr* Ex, ExplodedNode* Pred, 
+                                    ExplodedNodeSet& Dst, bool asLValue) {
   
   const GRState* state = GetState(Pred);
 
@@ -1005,12 +1004,13 @@ void GRExprEngine::VisitDeclRefExpr(DeclRefExpr* Ex, NodeTy* Pred, NodeSet& Dst,
 }
 
 /// VisitArraySubscriptExpr - Transfer function for array accesses
-void GRExprEngine::VisitArraySubscriptExpr(ArraySubscriptExpr* A, NodeTy* Pred,
-                                           NodeSet& Dst, bool asLValue) {
+void GRExprEngine::VisitArraySubscriptExpr(ArraySubscriptExpr* A, 
+                                           ExplodedNode* Pred,
+                                           ExplodedNodeSet& Dst, bool asLValue){
   
   Expr* Base = A->getBase()->IgnoreParens();
   Expr* Idx  = A->getIdx()->IgnoreParens();
-  NodeSet Tmp;
+  ExplodedNodeSet Tmp;
   
   if (Base->getType()->isVectorType()) {
     // For vector types get its lvalue.
@@ -1022,11 +1022,11 @@ void GRExprEngine::VisitArraySubscriptExpr(ArraySubscriptExpr* A, NodeTy* Pred,
   else  
     Visit(Base, Pred, Tmp);   // Get Base's rvalue, which should be an LocVal.
   
-  for (NodeSet::iterator I1=Tmp.begin(), E1=Tmp.end(); I1!=E1; ++I1) {    
-    NodeSet Tmp2;
+  for (ExplodedNodeSet::iterator I1=Tmp.begin(), E1=Tmp.end(); I1!=E1; ++I1) {
+    ExplodedNodeSet Tmp2;
     Visit(Idx, *I1, Tmp2);     // Evaluate the index.
       
-    for (NodeSet::iterator I2=Tmp2.begin(), E2=Tmp2.end(); I2!=E2; ++I2) {
+    for (ExplodedNodeSet::iterator I2=Tmp2.begin(),E2=Tmp2.end();I2!=E2; ++I2) {
       const GRState* state = GetState(*I2);
       SVal V = state->getLValue(A->getType(), state->getSVal(Base),
                                 state->getSVal(Idx));
@@ -1041,11 +1041,11 @@ void GRExprEngine::VisitArraySubscriptExpr(ArraySubscriptExpr* A, NodeTy* Pred,
 }
 
 /// VisitMemberExpr - Transfer function for member expressions.
-void GRExprEngine::VisitMemberExpr(MemberExpr* M, NodeTy* Pred,
-                                   NodeSet& Dst, bool asLValue) {
+void GRExprEngine::VisitMemberExpr(MemberExpr* M, ExplodedNode* Pred,
+                                   ExplodedNodeSet& Dst, bool asLValue) {
   
   Expr* Base = M->getBase()->IgnoreParens();
-  NodeSet Tmp;
+  ExplodedNodeSet Tmp;
   
   if (M->isArrow()) 
     Visit(Base, Pred, Tmp);        // p->f = ...  or   ... = p->f
@@ -1056,7 +1056,7 @@ void GRExprEngine::VisitMemberExpr(MemberExpr* M, NodeTy* Pred,
   if (!Field) // FIXME: skipping member expressions for non-fields
     return;
 
-  for (NodeSet::iterator I = Tmp.begin(), E = Tmp.end(); I != E; ++I) {
+  for (ExplodedNodeSet::iterator I = Tmp.begin(), E = Tmp.end(); I != E; ++I) {
     const GRState* state = GetState(*I);
     // FIXME: Should we insert some assumption logic in here to determine
     // if "Base" is a valid piece of memory?  Before we put this assumption
@@ -1073,7 +1073,7 @@ void GRExprEngine::VisitMemberExpr(MemberExpr* M, NodeTy* Pred,
 
 /// EvalBind - Handle the semantics of binding a value to a specific location.
 ///  This method is used by EvalStore and (soon) VisitDeclStmt, and others.
-void GRExprEngine::EvalBind(NodeSet& Dst, Expr* Ex, NodeTy* Pred,
+void GRExprEngine::EvalBind(ExplodedNodeSet& Dst, Expr* Ex, ExplodedNode* Pred,
                             const GRState* state, SVal location, SVal Val) {
 
   const GRState* newState = 0;
@@ -1105,7 +1105,7 @@ void GRExprEngine::EvalBind(NodeSet& Dst, Expr* Ex, NodeTy* Pred,
 ///  @param state The current simulation state
 ///  @param location The location to store the value
 ///  @param Val The value to be stored
-void GRExprEngine::EvalStore(NodeSet& Dst, Expr* Ex, NodeTy* Pred,
+void GRExprEngine::EvalStore(ExplodedNodeSet& Dst, Expr* Ex, ExplodedNode* Pred,
                              const GRState* state, SVal location, SVal Val,
                              const void *tag) {
   
@@ -1128,7 +1128,7 @@ void GRExprEngine::EvalStore(NodeSet& Dst, Expr* Ex, NodeTy* Pred,
   EvalBind(Dst, Ex, Pred, state, location, Val);
 }
 
-void GRExprEngine::EvalLoad(NodeSet& Dst, Expr* Ex, NodeTy* Pred,
+void GRExprEngine::EvalLoad(ExplodedNodeSet& Dst, Expr* Ex, ExplodedNode* Pred,
                             const GRState* state, SVal location,
                             const void *tag) {
 
@@ -1169,28 +1169,27 @@ void GRExprEngine::EvalLoad(NodeSet& Dst, Expr* Ex, NodeTy* Pred,
   }
 }
 
-void GRExprEngine::EvalStore(NodeSet& Dst, Expr* Ex, Expr* StoreE, NodeTy* Pred,
-                             const GRState* state, SVal location, SVal Val,
-                             const void *tag) {
+void GRExprEngine::EvalStore(ExplodedNodeSet& Dst, Expr* Ex, Expr* StoreE, 
+                             ExplodedNode* Pred, const GRState* state, 
+                             SVal location, SVal Val, const void *tag) {
  
-  NodeSet TmpDst;
+  ExplodedNodeSet TmpDst;
   EvalStore(TmpDst, StoreE, Pred, state, location, Val, tag);
 
-  for (NodeSet::iterator I=TmpDst.begin(), E=TmpDst.end(); I!=E; ++I)
+  for (ExplodedNodeSet::iterator I=TmpDst.begin(), E=TmpDst.end(); I!=E; ++I)
     MakeNode(Dst, Ex, *I, (*I)->getState(), ProgramPoint::PostStmtKind, tag);
 }
 
-GRExprEngine::NodeTy* GRExprEngine::EvalLocation(Stmt* Ex, NodeTy* Pred,
-                                                 const GRState* state,
-                                                 SVal location,
-                                                 const void *tag) {
+ExplodedNode* GRExprEngine::EvalLocation(Stmt* Ex, ExplodedNode* Pred,
+                                         const GRState* state, SVal location,
+                                         const void *tag) {
   
   SaveAndRestore<const void*> OldTag(Builder->Tag);
   Builder->Tag = tag;
   
   // Check for loads/stores from/to undefined values.  
   if (location.isUndef()) {
-    NodeTy* N =
+    ExplodedNode* N =
       Builder->generateNode(Ex, state, Pred,
                             ProgramPoint::PostUndefLocationCheckFailedKind);
     
@@ -1227,7 +1226,7 @@ GRExprEngine::NodeTy* GRExprEngine::EvalLocation(Stmt* Ex, NodeTy* Pred,
     
     // We don't use "MakeNode" here because the node will be a sink
     // and we have no intention of processing it later.
-    NodeTy* NullNode =
+    ExplodedNode* NullNode =
       Builder->generateNode(Ex, StNull, Pred, 
                             ProgramPoint::PostNullCheckFailedKind);
 
@@ -1261,7 +1260,7 @@ GRExprEngine::NodeTy* GRExprEngine::EvalLocation(Stmt* Ex, NodeTy* Pred,
 
       if (StOutBound) {
         // Report warning.  Make sink node manually.
-        NodeTy* OOBNode =
+        ExplodedNode* OOBNode =
           Builder->generateNode(Ex, StOutBound, Pred,
                                 ProgramPoint::PostOutOfBoundsCheckFailedKind);
 
@@ -1300,7 +1299,7 @@ GRExprEngine::NodeTy* GRExprEngine::EvalLocation(Stmt* Ex, NodeTy* Pred,
 //
 static bool EvalOSAtomicCompareAndSwap(ExplodedNodeSet& Dst,
                                        GRExprEngine& Engine,
-                                       GRStmtNodeBuilder<GRState>& Builder,
+                                       GRStmtNodeBuilder& Builder,
                                        CallExpr* CE, SVal L,                 
                                        ExplodedNode* Pred) {
 
@@ -1404,7 +1403,7 @@ static bool EvalOSAtomicCompareAndSwap(ExplodedNodeSet& Dst,
 
 static bool EvalOSAtomic(ExplodedNodeSet& Dst,
                          GRExprEngine& Engine,
-                         GRStmtNodeBuilder<GRState>& Builder,
+                         GRStmtNodeBuilder& Builder,
                          CallExpr* CE, SVal L,
                          ExplodedNode* Pred) {
   const FunctionDecl* FD = L.getAsFunctionDecl();
@@ -1426,7 +1425,8 @@ static bool EvalOSAtomic(ExplodedNodeSet& Dst,
 // Transfer function: Function calls.
 //===----------------------------------------------------------------------===//
 
-void GRExprEngine::EvalCall(NodeSet& Dst, CallExpr* CE, SVal L, NodeTy* Pred) {
+void GRExprEngine::EvalCall(ExplodedNodeSet& Dst, CallExpr* CE, SVal L, 
+                            ExplodedNode* Pred) {
   assert (Builder && "GRStmtNodeBuilder must be defined.");
   
   // FIXME: Allow us to chain together transfer functions.
@@ -1436,10 +1436,10 @@ void GRExprEngine::EvalCall(NodeSet& Dst, CallExpr* CE, SVal L, NodeTy* Pred) {
   getTF().EvalCall(Dst, *this, *Builder, CE, L, Pred);
 }
 
-void GRExprEngine::VisitCall(CallExpr* CE, NodeTy* Pred,
+void GRExprEngine::VisitCall(CallExpr* CE, ExplodedNode* Pred,
                              CallExpr::arg_iterator AI,
                              CallExpr::arg_iterator AE,
-                             NodeSet& Dst)
+                             ExplodedNodeSet& Dst)
 {
   // Determine the type of function we're calling (if available).
   const FunctionProtoType *Proto = NULL;
@@ -1450,10 +1450,11 @@ void GRExprEngine::VisitCall(CallExpr* CE, NodeTy* Pred,
   VisitCallRec(CE, Pred, AI, AE, Dst, Proto, /*ParamIdx=*/0);
 }
 
-void GRExprEngine::VisitCallRec(CallExpr* CE, NodeTy* Pred,
+void GRExprEngine::VisitCallRec(CallExpr* CE, ExplodedNode* Pred,
                                 CallExpr::arg_iterator AI,
                                 CallExpr::arg_iterator AE,
-                                NodeSet& Dst, const FunctionProtoType *Proto,
+                                ExplodedNodeSet& Dst, 
+                                const FunctionProtoType *Proto, 
                                 unsigned ParamIdx) {
   
   // Process the arguments.
@@ -1464,14 +1465,15 @@ void GRExprEngine::VisitCallRec(CallExpr* CE, NodeTy* Pred,
     if (Proto && ParamIdx < Proto->getNumArgs())
       VisitAsLvalue = Proto->getArgType(ParamIdx)->isReferenceType();
 
-    NodeSet DstTmp;  
+    ExplodedNodeSet DstTmp;  
     if (VisitAsLvalue)
       VisitLValue(*AI, Pred, DstTmp);    
     else
       Visit(*AI, Pred, DstTmp);    
     ++AI;
     
-    for (NodeSet::iterator DI=DstTmp.begin(), DE=DstTmp.end(); DI != DE; ++DI)
+    for (ExplodedNodeSet::iterator DI=DstTmp.begin(), DE=DstTmp.end(); DI != DE;
+         ++DI)
       VisitCallRec(CE, *DI, AI, AE, Dst, Proto, ParamIdx + 1);
     
     return;
@@ -1479,11 +1481,11 @@ void GRExprEngine::VisitCallRec(CallExpr* CE, NodeTy* Pred,
 
   // If we reach here we have processed all of the arguments.  Evaluate
   // the callee expression.
-  NodeSet DstTmp;
+  ExplodedNodeSet DstTmp;
   Expr* Callee = CE->getCallee()->IgnoreParens();
   
   { // Enter new scope to make the lifetime of 'DstTmp2' bounded.
-    NodeSet DstTmp2;
+    ExplodedNodeSet DstTmp2;
     Visit(Callee, Pred, DstTmp2);
     
     // Perform the previsit of the CallExpr, storing the results in DstTmp.
@@ -1491,7 +1493,7 @@ void GRExprEngine::VisitCallRec(CallExpr* CE, NodeTy* Pred,
   }
   
   // Finally, evaluate the function call.
-  for (NodeSet::iterator DI = DstTmp.begin(), DE = DstTmp.end(); DI!=DE; ++DI) {
+  for (ExplodedNodeSet::iterator DI = DstTmp.begin(), DE = DstTmp.end(); DI!=DE; ++DI) {
 
     const GRState* state = GetState(*DI);
     SVal L = state->getSVal(Callee);
@@ -1502,7 +1504,7 @@ void GRExprEngine::VisitCallRec(CallExpr* CE, NodeTy* Pred,
     // Check for undefined control-flow or calls to NULL.
     
     if (L.isUndef() || isa<loc::ConcreteInt>(L)) {      
-      NodeTy* N = Builder->generateNode(CE, state, *DI);
+      ExplodedNode* N = Builder->generateNode(CE, state, *DI);
       
       if (N) {
         N->markAsSink();
@@ -1640,7 +1642,7 @@ void GRExprEngine::VisitCallRec(CallExpr* CE, NodeTy* Pred,
          I != E; ++I) {
 
       if (GetState(*DI)->getSVal(*I).isUndef()) {        
-        NodeTy* N = Builder->generateNode(CE, GetState(*DI), *DI);
+        ExplodedNode* N = Builder->generateNode(CE, GetState(*DI), *DI);
       
         if (N) {
           N->markAsSink();
@@ -1677,9 +1679,9 @@ void GRExprEngine::VisitCallRec(CallExpr* CE, NodeTy* Pred,
 static std::pair<const void*,const void*> EagerlyAssumeTag
   = std::pair<const void*,const void*>(&EagerlyAssumeTag,0);
 
-void GRExprEngine::EvalEagerlyAssume(NodeSet &Dst, NodeSet &Src, Expr *Ex) {
-  for (NodeSet::iterator I=Src.begin(), E=Src.end(); I!=E; ++I) {
-    NodeTy *Pred = *I;
+void GRExprEngine::EvalEagerlyAssume(ExplodedNodeSet &Dst, ExplodedNodeSet &Src, Expr *Ex) {
+  for (ExplodedNodeSet::iterator I=Src.begin(), E=Src.end(); I!=E; ++I) {
+    ExplodedNode *Pred = *I;
     
     // Test if the previous node was as the same expression.  This can happen
     // when the expression fails to evaluate to anything meaningful and
@@ -1719,14 +1721,14 @@ void GRExprEngine::EvalEagerlyAssume(NodeSet &Dst, NodeSet &Src, Expr *Ex) {
 //===----------------------------------------------------------------------===//
 
 void GRExprEngine::VisitObjCIvarRefExpr(ObjCIvarRefExpr* Ex,
-                                            NodeTy* Pred, NodeSet& Dst,
+                                            ExplodedNode* Pred, ExplodedNodeSet& Dst,
                                             bool asLValue) {
   
   Expr* Base = cast<Expr>(Ex->getBase());
-  NodeSet Tmp;
+  ExplodedNodeSet Tmp;
   Visit(Base, Pred, Tmp);
   
-  for (NodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) {
+  for (ExplodedNodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) {
     const GRState* state = GetState(*I);
     SVal BaseVal = state->getSVal(Base);
     SVal location = state->getLValue(Ex->getDecl(), BaseVal);
@@ -1743,7 +1745,7 @@ void GRExprEngine::VisitObjCIvarRefExpr(ObjCIvarRefExpr* Ex,
 //===----------------------------------------------------------------------===//
 
 void GRExprEngine::VisitObjCForCollectionStmt(ObjCForCollectionStmt* S,
-                                              NodeTy* Pred, NodeSet& Dst) {
+                                              ExplodedNode* Pred, ExplodedNodeSet& Dst) {
     
   // ObjCForCollectionStmts are processed in two places.  This method
   // handles the case where an ObjCForCollectionStmt* occurs as one of the
@@ -1781,17 +1783,17 @@ void GRExprEngine::VisitObjCForCollectionStmt(ObjCForCollectionStmt* S,
     return;
   }
 
-  NodeSet Tmp;
+  ExplodedNodeSet Tmp;
   VisitLValue(cast<Expr>(elem), Pred, Tmp);
   
-  for (NodeSet::iterator I = Tmp.begin(), E = Tmp.end(); I!=E; ++I) {
+  for (ExplodedNodeSet::iterator I = Tmp.begin(), E = Tmp.end(); I!=E; ++I) {
     const GRState* state = GetState(*I);
     VisitObjCForCollectionStmtAux(S, *I, Dst, state->getSVal(elem));
   }
 }
 
 void GRExprEngine::VisitObjCForCollectionStmtAux(ObjCForCollectionStmt* S,
-                                                 NodeTy* Pred, NodeSet& Dst,
+                                                 ExplodedNode* Pred, ExplodedNodeSet& Dst,
                                                  SVal ElementV) {
     
 
@@ -1840,8 +1842,8 @@ void GRExprEngine::VisitObjCForCollectionStmtAux(ObjCForCollectionStmt* S,
 // Transfer function: Objective-C message expressions.
 //===----------------------------------------------------------------------===//
 
-void GRExprEngine::VisitObjCMessageExpr(ObjCMessageExpr* ME, NodeTy* Pred,
-                                        NodeSet& Dst){
+void GRExprEngine::VisitObjCMessageExpr(ObjCMessageExpr* ME, ExplodedNode* Pred,
+                                        ExplodedNodeSet& Dst){
   
   VisitObjCMessageExprArgHelper(ME, ME->arg_begin(), ME->arg_end(),
                                 Pred, Dst);
@@ -1850,16 +1852,16 @@ void GRExprEngine::VisitObjCMessageExpr(ObjCMessageExpr* ME, NodeTy* Pred,
 void GRExprEngine::VisitObjCMessageExprArgHelper(ObjCMessageExpr* ME,
                                               ObjCMessageExpr::arg_iterator AI,
                                               ObjCMessageExpr::arg_iterator AE,
-                                              NodeTy* Pred, NodeSet& Dst) {
+                                              ExplodedNode* Pred, ExplodedNodeSet& Dst) {
   if (AI == AE) {
     
     // Process the receiver.
     
     if (Expr* Receiver = ME->getReceiver()) {
-      NodeSet Tmp;
+      ExplodedNodeSet Tmp;
       Visit(Receiver, Pred, Tmp);
       
-      for (NodeSet::iterator NI = Tmp.begin(), NE = Tmp.end(); NI != NE; ++NI)
+      for (ExplodedNodeSet::iterator NI = Tmp.begin(), NE = Tmp.end(); NI != NE; ++NI)
         VisitObjCMessageExprDispatchHelper(ME, *NI, Dst);
       
       return;
@@ -1869,18 +1871,18 @@ void GRExprEngine::VisitObjCMessageExprArgHelper(ObjCMessageExpr* ME,
     return;
   }
   
-  NodeSet Tmp;
+  ExplodedNodeSet Tmp;
   Visit(*AI, Pred, Tmp);
   
   ++AI;
   
-  for (NodeSet::iterator NI = Tmp.begin(), NE = Tmp.end(); NI != NE; ++NI)
+  for (ExplodedNodeSet::iterator NI = Tmp.begin(), NE = Tmp.end(); NI != NE; ++NI)
     VisitObjCMessageExprArgHelper(ME, AI, AE, *NI, Dst);
 }
 
 void GRExprEngine::VisitObjCMessageExprDispatchHelper(ObjCMessageExpr* ME,
-                                                      NodeTy* Pred,
-                                                      NodeSet& Dst) {
+                                                      ExplodedNode* Pred,
+                                                      ExplodedNodeSet& Dst) {
   
   // FIXME: More logic for the processing the method call. 
   
@@ -1894,7 +1896,7 @@ void GRExprEngine::VisitObjCMessageExprDispatchHelper(ObjCMessageExpr* ME,
     
     // Check for undefined control-flow.    
     if (L.isUndef()) {
-      NodeTy* N = Builder->generateNode(ME, state, Pred);
+      ExplodedNode* N = Builder->generateNode(ME, state, Pred);
       
       if (N) {
         N->markAsSink();
@@ -1922,7 +1924,7 @@ void GRExprEngine::VisitObjCMessageExprDispatchHelper(ObjCMessageExpr* ME,
           // this point.
           // FIXME: We should bifurcate and fill the returned struct with
           //  garbage.                
-          if (NodeTy* N = Builder->generateNode(ME, StNull, Pred)) {
+          if (ExplodedNode* N = Builder->generateNode(ME, StNull, Pred)) {
             N->markAsSink();
             if (StNotNull)
               NilReceiverStructRetImplicit.insert(N);
@@ -1941,7 +1943,7 @@ void GRExprEngine::VisitObjCMessageExprDispatchHelper(ObjCMessageExpr* ME,
             const uint64_t returnTypeSize = Ctx.getTypeSize(ME->getType());
 
             if(voidPtrSize < returnTypeSize) {
-              if (NodeTy* N = Builder->generateNode(ME, StNull, Pred)) {
+              if (ExplodedNode* N = Builder->generateNode(ME, StNull, Pred)) {
                 N->markAsSink();
                 if(StNotNull)
                   NilReceiverLargerThanVoidPtrRetImplicit.insert(N);
@@ -2038,7 +2040,7 @@ void GRExprEngine::VisitObjCMessageExprDispatchHelper(ObjCMessageExpr* ME,
       
       // Generate an error node for passing an uninitialized/undefined value
       // as an argument to a message expression.  This node is a sink.
-      NodeTy* N = Builder->generateNode(ME, state, Pred);
+      ExplodedNode* N = Builder->generateNode(ME, state, Pred);
       
       if (N) {
         N->markAsSink();
@@ -2075,8 +2077,8 @@ void GRExprEngine::VisitObjCMessageExprDispatchHelper(ObjCMessageExpr* ME,
 // Transfer functions: Miscellaneous statements.
 //===----------------------------------------------------------------------===//
 
-void GRExprEngine::VisitCast(Expr* CastE, Expr* Ex, NodeTy* Pred, NodeSet& Dst){
-  NodeSet S1;
+void GRExprEngine::VisitCast(Expr* CastE, Expr* Ex, ExplodedNode* Pred, ExplodedNodeSet& Dst){
+  ExplodedNodeSet S1;
   QualType T = CastE->getType();
   QualType ExTy = Ex->getType();
 
@@ -2090,14 +2092,14 @@ void GRExprEngine::VisitCast(Expr* CastE, Expr* Ex, NodeTy* Pred, NodeSet& Dst){
   
   // Check for casting to "void".
   if (T->isVoidType()) {    
-    for (NodeSet::iterator I1 = S1.begin(), E1 = S1.end(); I1 != E1; ++I1)
+    for (ExplodedNodeSet::iterator I1 = S1.begin(), E1 = S1.end(); I1 != E1; ++I1)
       Dst.Add(*I1);
 
     return;
   }
 
-  for (NodeSet::iterator I1 = S1.begin(), E1 = S1.end(); I1 != E1; ++I1) {
-    NodeTy* N = *I1;
+  for (ExplodedNodeSet::iterator I1 = S1.begin(), E1 = S1.end(); I1 != E1; ++I1) {
+    ExplodedNode* N = *I1;
     const GRState* state = GetState(N);
     SVal V = state->getSVal(Ex);
     const SValuator::CastResult &Res = SVator.EvalCast(V, state, T, ExTy);
@@ -2107,13 +2109,13 @@ void GRExprEngine::VisitCast(Expr* CastE, Expr* Ex, NodeTy* Pred, NodeSet& Dst){
 }
 
 void GRExprEngine::VisitCompoundLiteralExpr(CompoundLiteralExpr* CL,
-                                            NodeTy* Pred, NodeSet& Dst, 
+                                            ExplodedNode* Pred, ExplodedNodeSet& Dst, 
                                             bool asLValue) {
   InitListExpr* ILE = cast<InitListExpr>(CL->getInitializer()->IgnoreParens());
-  NodeSet Tmp;
+  ExplodedNodeSet Tmp;
   Visit(ILE, Pred, Tmp);
   
-  for (NodeSet::iterator I = Tmp.begin(), EI = Tmp.end(); I!=EI; ++I) {
+  for (ExplodedNodeSet::iterator I = Tmp.begin(), EI = Tmp.end(); I!=EI; ++I) {
     const GRState* state = GetState(*I);
     SVal ILV = state->getSVal(ILE);
     state = state->bindCompoundLiteral(CL, ILV);
@@ -2125,7 +2127,7 @@ void GRExprEngine::VisitCompoundLiteralExpr(CompoundLiteralExpr* CL,
   }
 }
 
-void GRExprEngine::VisitDeclStmt(DeclStmt* DS, NodeTy* Pred, NodeSet& Dst) {  
+void GRExprEngine::VisitDeclStmt(DeclStmt* DS, ExplodedNode* Pred, ExplodedNodeSet& Dst) {  
 
   // The CFG has one DeclStmt per Decl.  
   Decl* D = *DS->decl_begin();
@@ -2138,14 +2140,14 @@ void GRExprEngine::VisitDeclStmt(DeclStmt* DS, NodeTy* Pred, NodeSet& Dst) {
 
   // FIXME: static variables may have an initializer, but the second
   //  time a function is called those values may not be current.
-  NodeSet Tmp;
+  ExplodedNodeSet Tmp;
 
   if (InitEx)
     Visit(InitEx, Pred, Tmp);
   else
     Tmp.Add(Pred);
   
-  for (NodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) {
+  for (ExplodedNodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) {
     const GRState* state = GetState(*I);
     unsigned Count = Builder->getCurrentBlockCount();
 
@@ -2158,7 +2160,7 @@ void GRExprEngine::VisitDeclStmt(DeclStmt* DS, NodeTy* Pred, NodeSet& Dst) {
       SVal Size = state->getSVal(SE);
       
       if (Size.isUndef()) {
-        if (NodeTy* N = Builder->generateNode(DS, state, Pred)) {
+        if (ExplodedNode* N = Builder->generateNode(DS, state, Pred)) {
           N->markAsSink();          
           ExplicitBadSizedVLA.insert(N);
         }
@@ -2169,7 +2171,7 @@ void GRExprEngine::VisitDeclStmt(DeclStmt* DS, NodeTy* Pred, NodeSet& Dst) {
       state = state->assume(Size, true);
       
       if (zeroState) {
-        if (NodeTy* N = Builder->generateNode(DS, zeroState, Pred)) {
+        if (ExplodedNode* N = Builder->generateNode(DS, zeroState, Pred)) {
           N->markAsSink();          
           if (state)
             ImplicitBadSizedVLA.insert(N);
@@ -2216,18 +2218,18 @@ namespace {
 class VISIBILITY_HIDDEN InitListWLItem {
 public:
   llvm::ImmutableList<SVal> Vals;
-  GRExprEngine::NodeTy* N;
+  ExplodedNode* N;
   InitListExpr::reverse_iterator Itr;
   
-  InitListWLItem(GRExprEngine::NodeTy* n, llvm::ImmutableList<SVal> vals,
-         InitListExpr::reverse_iterator itr)
+  InitListWLItem(ExplodedNode* n, llvm::ImmutableList<SVal> vals,
+                 InitListExpr::reverse_iterator itr)
   : Vals(vals), N(n), Itr(itr) {}
 };
 }
 
 
-void GRExprEngine::VisitInitListExpr(InitListExpr* E, NodeTy* Pred, 
-                                     NodeSet& Dst) {
+void GRExprEngine::VisitInitListExpr(InitListExpr* E, ExplodedNode* Pred, 
+                                     ExplodedNodeSet& Dst) {
 
   const GRState* state = GetState(Pred);
   QualType T = getContext().getCanonicalType(E->getType());
@@ -2257,12 +2259,12 @@ void GRExprEngine::VisitInitListExpr(InitListExpr* E, NodeTy* Pred,
       InitListWLItem X = WorkList.back();
       WorkList.pop_back();
       
-      NodeSet Tmp;
+      ExplodedNodeSet Tmp;
       Visit(*X.Itr, X.N, Tmp);
       
       InitListExpr::reverse_iterator NewItr = X.Itr + 1;
 
-      for (NodeSet::iterator NI=Tmp.begin(), NE=Tmp.end(); NI!=NE; ++NI) {
+      for (ExplodedNodeSet::iterator NI=Tmp.begin(), NE=Tmp.end(); NI!=NE; ++NI) {
         // Get the last initializer value.
         state = GetState(*NI);
         SVal InitV = state->getSVal(cast<Expr>(*X.Itr));
@@ -2291,10 +2293,10 @@ void GRExprEngine::VisitInitListExpr(InitListExpr* E, NodeTy* Pred,
 
   if (Loc::IsLocType(T) || T->isIntegerType()) {
     assert (E->getNumInits() == 1);
-    NodeSet Tmp;
+    ExplodedNodeSet Tmp;
     Expr* Init = E->getInit(0);
     Visit(Init, Pred, Tmp);
-    for (NodeSet::iterator I = Tmp.begin(), EI = Tmp.end(); I != EI; ++I) {
+    for (ExplodedNodeSet::iterator I = Tmp.begin(), EI = Tmp.end(); I != EI; ++I) {
       state = GetState(*I);
       MakeNode(Dst, E, *I, state->bindExpr(E, state->getSVal(Init)));
     }
@@ -2308,8 +2310,8 @@ void GRExprEngine::VisitInitListExpr(InitListExpr* E, NodeTy* Pred,
 
 /// VisitSizeOfAlignOfExpr - Transfer function for sizeof(type).
 void GRExprEngine::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr* Ex,
-                                          NodeTy* Pred,
-                                          NodeSet& Dst) {
+                                          ExplodedNode* Pred,
+                                          ExplodedNodeSet& Dst) {
   QualType T = Ex->getTypeOfArgument();
   uint64_t amt;  
   
@@ -2341,8 +2343,8 @@ void GRExprEngine::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr* Ex,
 }
 
 
-void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred,
-                                      NodeSet& Dst, bool asLValue) {
+void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, ExplodedNode* Pred,
+                                      ExplodedNodeSet& Dst, bool asLValue) {
 
   switch (U->getOpcode()) {
       
@@ -2352,10 +2354,10 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred,
     case UnaryOperator::Deref: {
       
       Expr* Ex = U->getSubExpr()->IgnoreParens();
-      NodeSet Tmp;
+      ExplodedNodeSet Tmp;
       Visit(Ex, Pred, Tmp);
       
-      for (NodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) {
+      for (ExplodedNodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) {
         
         const GRState* state = GetState(*I);
         SVal location = state->getSVal(Ex);
@@ -2373,10 +2375,10 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred,
     case UnaryOperator::Real: {
       
       Expr* Ex = U->getSubExpr()->IgnoreParens();
-      NodeSet Tmp;
+      ExplodedNodeSet Tmp;
       Visit(Ex, Pred, Tmp);
       
-      for (NodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) {
+      for (ExplodedNodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) {
         
         // FIXME: We don't have complex SValues yet.
         if (Ex->getType()->isAnyComplexType()) {
@@ -2397,10 +2399,10 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred,
     case UnaryOperator::Imag: {
       
       Expr* Ex = U->getSubExpr()->IgnoreParens();
-      NodeSet Tmp;
+      ExplodedNodeSet Tmp;
       Visit(Ex, Pred, Tmp);
       
-      for (NodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) {
+      for (ExplodedNodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) {
         // FIXME: We don't have complex SValues yet.
         if (Ex->getType()->isAnyComplexType()) {
           // Just report "Unknown."
@@ -2432,10 +2434,10 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred,
       // subexpression.
 
       Expr* Ex = U->getSubExpr()->IgnoreParens();
-      NodeSet Tmp;
+      ExplodedNodeSet Tmp;
       Visit(Ex, Pred, Tmp);
       
-      for (NodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) {        
+      for (ExplodedNodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) {        
         const GRState* state = GetState(*I);
         MakeNode(Dst, U, *I, state->bindExpr(U, state->getSVal(Ex)));
       }
@@ -2447,10 +2449,10 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred,
       
       assert(!asLValue);
       Expr* Ex = U->getSubExpr()->IgnoreParens();
-      NodeSet Tmp;
+      ExplodedNodeSet Tmp;
       VisitLValue(Ex, Pred, Tmp);
      
-      for (NodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) {        
+      for (ExplodedNodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) {        
         const GRState* state = GetState(*I);
         SVal V = state->getSVal(Ex);
         state = state->bindExpr(U, V);
@@ -2466,10 +2468,10 @