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

6 files changed, 260 insertions, 267 deletions

diff --git a/lib/Analysis/BasicObjCFoundationChecks.cpp b/lib/Analysis/BasicObjCFoundationChecks.cpp
index d7631bc2c2..6e9dd909fc 100644
--- a/lib/Analysis/BasicObjCFoundationChecks.cpp
+++ b/lib/Analysis/BasicObjCFoundationChecks.cpp
@@ -63,12 +63,12 @@ class VISIBILITY_HIDDEN BasicObjCFoundationChecks : public GRSimpleAPICheck {
   ASTContext &Ctx;
       
   bool isNSString(const ObjCInterfaceType *T, const char* suffix);
-  bool AuditNSString(NodeTy* N, const ObjCMessageExpr* ME);
+  bool AuditNSString(ExplodedNode* N, const ObjCMessageExpr* ME);
       
-  void Warn(NodeTy* N, const Expr* E, const std::string& s);  
-  void WarnNilArg(NodeTy* N, const Expr* E);
+  void Warn(ExplodedNode* N, const Expr* E, const std::string& s);  
+  void WarnNilArg(ExplodedNode* N, const Expr* E);
   
-  bool CheckNilArg(NodeTy* N, unsigned Arg);
+  bool CheckNilArg(ExplodedNode* N, unsigned Arg);
 
 public:
   BasicObjCFoundationChecks(ASTContext& ctx, BugReporter& br) 
@@ -77,7 +77,7 @@ public:
   bool Audit(ExplodedNode* N, GRStateManager&);
   
 private:  
-  void WarnNilArg(NodeTy* N, const ObjCMessageExpr* ME, unsigned Arg) {    
+  void WarnNilArg(ExplodedNode* N, const ObjCMessageExpr* ME, unsigned Arg) {    
     std::string sbuf;
     llvm::raw_string_ostream os(sbuf);
     os << "Argument to '" << GetReceiverNameType(ME) << "' method '"
@@ -139,7 +139,7 @@ static inline bool isNil(SVal X) {
 // Error reporting.
 //===----------------------------------------------------------------------===//
 
-bool BasicObjCFoundationChecks::CheckNilArg(NodeTy* N, unsigned Arg) {
+bool BasicObjCFoundationChecks::CheckNilArg(ExplodedNode* N, unsigned Arg) {
   const ObjCMessageExpr* ME =
     cast<ObjCMessageExpr>(cast<PostStmt>(N->getLocation()).getStmt());
   
@@ -162,7 +162,7 @@ bool BasicObjCFoundationChecks::isNSString(const ObjCInterfaceType *T,
   return !strcmp("String", suffix) || !strcmp("MutableString", suffix);
 }
 
-bool BasicObjCFoundationChecks::AuditNSString(NodeTy* N, 
+bool BasicObjCFoundationChecks::AuditNSString(ExplodedNode* N, 
                                               const ObjCMessageExpr* ME) {
   
   Selector S = ME->getSelector();
diff --git a/lib/Analysis/CFRefCount.cpp b/lib/Analysis/CFRefCount.cpp
index 0b8b488bf0..02f427a91e 100644
--- a/lib/Analysis/CFRefCount.cpp
+++ b/lib/Analysis/CFRefCount.cpp
@@ -167,19 +167,19 @@ ResolveToInterfaceMethodDecl(const ObjCMethodDecl *MD) {
 
 namespace {
 class VISIBILITY_HIDDEN GenericNodeBuilder {
-  GRStmtNodeBuilder<GRState> *SNB;
+  GRStmtNodeBuilder *SNB;
   Stmt *S;
   const void *tag;
-  GREndPathNodeBuilder<GRState> *ENB;
+  GREndPathNodeBuilder *ENB;
 public:
-  GenericNodeBuilder(GRStmtNodeBuilder<GRState> &snb, Stmt *s,
+  GenericNodeBuilder(GRStmtNodeBuilder &snb, Stmt *s,
                      const void *t)
   : SNB(&snb), S(s), tag(t), ENB(0) {}
-  GenericNodeBuilder(GREndPathNodeBuilder<GRState> &enb)
+
+  GenericNodeBuilder(GREndPathNodeBuilder &enb)
   : SNB(0), S(0), tag(0), ENB(&enb) {}
   
-  ExplodedNode *MakeNode(const GRState *state,
-                                  ExplodedNode *Pred) {
+  ExplodedNode *MakeNode(const GRState *state, ExplodedNode *Pred) {
     if (SNB)
       return SNB->generateNode(PostStmt(S, tag), state, Pred);
     
@@ -1835,8 +1835,8 @@ public:
   };
 
 private:
-  typedef llvm::DenseMap<const GRExprEngine::NodeTy*, const RetainSummary*>
-          SummaryLogTy;  
+  typedef llvm::DenseMap<const ExplodedNode*, const RetainSummary*>
+    SummaryLogTy;  
 
   RetainSummaryManager Summaries;  
   SummaryLogTy SummaryLog;
@@ -1854,7 +1854,7 @@ private:
                     RefVal::Kind& hasErr);
 
   void ProcessNonLeakError(ExplodedNodeSet& Dst,
-                           GRStmtNodeBuilder<GRState>& Builder,
+                           GRStmtNodeBuilder& Builder,
                            Expr* NodeExpr, Expr* ErrorExpr,
                            ExplodedNode* Pred,
                            const GRState* St,
@@ -1897,7 +1897,7 @@ public:
 
   void EvalSummary(ExplodedNodeSet& Dst,
                    GRExprEngine& Eng,
-                   GRStmtNodeBuilder<GRState>& Builder,
+                   GRStmtNodeBuilder& Builder,
                    Expr* Ex,
                    Expr* Receiver,
                    const RetainSummary& Summ,
@@ -1906,20 +1906,20 @@ public:
     
   virtual void EvalCall(ExplodedNodeSet& Dst,
                         GRExprEngine& Eng,
-                        GRStmtNodeBuilder<GRState>& Builder,
+                        GRStmtNodeBuilder& Builder,
                         CallExpr* CE, SVal L,
                         ExplodedNode* Pred);  
   
   
   virtual void EvalObjCMessageExpr(ExplodedNodeSet& Dst,
                                    GRExprEngine& Engine,
-                                   GRStmtNodeBuilder<GRState>& Builder,
+                                   GRStmtNodeBuilder& Builder,
                                    ObjCMessageExpr* ME,
                                    ExplodedNode* Pred);
   
   bool EvalObjCMessageExprAux(ExplodedNodeSet& Dst,
                               GRExprEngine& Engine,
-                              GRStmtNodeBuilder<GRState>& Builder,
+                              GRStmtNodeBuilder& Builder,
                               ObjCMessageExpr* ME,
                               ExplodedNode* Pred);
 
@@ -1929,11 +1929,11 @@ public:
   // End-of-path.
   
   virtual void EvalEndPath(GRExprEngine& Engine,
-                           GREndPathNodeBuilder<GRState>& Builder);
+                           GREndPathNodeBuilder& Builder);
   
   virtual void EvalDeadSymbols(ExplodedNodeSet& Dst,
                                GRExprEngine& Engine,
-                               GRStmtNodeBuilder<GRState>& Builder,
+                               GRStmtNodeBuilder& Builder,
                                ExplodedNode* Pred,
                                Stmt* S, const GRState* state,
                                SymbolReaper& SymReaper);
@@ -1946,7 +1946,7 @@ public:
   
   virtual void EvalReturn(ExplodedNodeSet& Dst,
                           GRExprEngine& Engine,
-                          GRStmtNodeBuilder<GRState>& Builder,
+                          GRStmtNodeBuilder& Builder,
                           ReturnStmt* S,
                           ExplodedNode* Pred);
 
@@ -2743,7 +2743,7 @@ static QualType GetReturnType(const Expr* RetE, ASTContext& Ctx) {
 
 void CFRefCount::EvalSummary(ExplodedNodeSet& Dst,
                              GRExprEngine& Eng,
-                             GRStmtNodeBuilder<GRState>& Builder,
+                             GRStmtNodeBuilder& Builder,
                              Expr* Ex,
                              Expr* Receiver,
                              const RetainSummary& Summ,
@@ -2953,7 +2953,7 @@ void CFRefCount::EvalSummary(ExplodedNodeSet& Dst,
   }
   
   // Generate a sink node if we are at the end of a path.
-  GRExprEngine::NodeTy *NewNode =
+  ExplodedNode *NewNode =
     Summ.isEndPath() ? Builder.MakeSinkNode(Dst, Ex, Pred, state)
                      : Builder.MakeNode(Dst, Ex, Pred, state);
   
@@ -2964,7 +2964,7 @@ void CFRefCount::EvalSummary(ExplodedNodeSet& Dst,
 
 void CFRefCount::EvalCall(ExplodedNodeSet& Dst,
                           GRExprEngine& Eng,
-                          GRStmtNodeBuilder<GRState>& Builder,
+                          GRStmtNodeBuilder& Builder,
                           CallExpr* CE, SVal L,
                           ExplodedNode* Pred) {
   const FunctionDecl* FD = L.getAsFunctionDecl();
@@ -2978,7 +2978,7 @@ void CFRefCount::EvalCall(ExplodedNodeSet& Dst,
 
 void CFRefCount::EvalObjCMessageExpr(ExplodedNodeSet& Dst,
                                      GRExprEngine& Eng,
-                                     GRStmtNodeBuilder<GRState>& Builder,
+                                     GRStmtNodeBuilder& Builder,
                                      ObjCMessageExpr* ME,
                                      ExplodedNode* Pred) {  
   RetainSummary* Summ = 0;
@@ -3098,7 +3098,7 @@ void CFRefCount::EvalBind(GRStmtNodeBuilderRef& B, SVal location, SVal val) {
 
 void CFRefCount::EvalReturn(ExplodedNodeSet& Dst,
                             GRExprEngine& Eng,
-                            GRStmtNodeBuilder<GRState>& Builder,
+                            GRStmtNodeBuilder& Builder,
                             ReturnStmt* S,
                             ExplodedNode* Pred) {
   
@@ -3515,7 +3515,7 @@ CFRefCount::ProcessLeaks(const GRState * state,
 }
 
 void CFRefCount::EvalEndPath(GRExprEngine& Eng,
-                             GREndPathNodeBuilder<GRState>& Builder) {
+                             GREndPathNodeBuilder& Builder) {
   
   const GRState *state = Builder.getState();
   GenericNodeBuilder Bd(Builder);
@@ -3543,7 +3543,7 @@ void CFRefCount::EvalEndPath(GRExprEngine& Eng,
 
 void CFRefCount::EvalDeadSymbols(ExplodedNodeSet& Dst,
                                  GRExprEngine& Eng,
-                                 GRStmtNodeBuilder<GRState>& Builder,
+                                 GRStmtNodeBuilder& Builder,
                                  ExplodedNode* Pred,
                                  Stmt* S,
                                  const GRState* state,
@@ -3597,13 +3597,13 @@ void CFRefCount::EvalDeadSymbols(ExplodedNodeSet& Dst,
 }
 
 void CFRefCount::ProcessNonLeakError(ExplodedNodeSet& Dst,
-                                     GRStmtNodeBuilder<GRState>& Builder,
+                                     GRStmtNodeBuilder& Builder,
                                      Expr* NodeExpr, Expr* ErrorExpr,
                                      ExplodedNode* Pred,
                                      const GRState* St,
                                      RefVal::Kind hasErr, SymbolRef Sym) {
   Builder.BuildSinks = true;
-  GRExprEngine::NodeTy* N  = Builder.MakeNode(Dst, NodeExpr, Pred, St);
+  ExplodedNode *N  = Builder.MakeNode(Dst, NodeExpr, Pred, St);
   
   if (!N)
     return;
diff --git a/lib/Analysis/CheckNSError.cpp b/lib/Analysis/CheckNSError.cpp
index 0d67e01609..b9599ceb6a 100644
--- a/lib/Analysis/CheckNSError.cpp
+++ b/lib/Analysis/CheckNSError.cpp
@@ -66,7 +66,7 @@ void clang::RegisterNSErrorChecks(BugReporter& BR, GRExprEngine &Eng) {
 
 void NSErrorCheck::FlushReports(BugReporter& BR) {
   // Get the analysis engine and the exploded analysis graph.
-  GRExprEngine::GraphTy& G = Eng.getGraph();
+  ExplodedGraph& G = Eng.getGraph();
   
   // Get the declaration of the method/function that was analyzed.
   Decl& CodeDecl = G.getCodeDecl();
@@ -89,8 +89,8 @@ void NSErrorCheck::FlushReports(BugReporter& BR) {
   
   if (ResultTy == Ctx.VoidTy) EmitRetTyWarning(BR, CodeDecl);
   
-  for (GRExprEngine::GraphTy::roots_iterator RI=G.roots_begin(),
-       RE=G.roots_end(); RI!=RE; ++RI) {
+  for (ExplodedGraph::roots_iterator RI=G.roots_begin(), RE=G.roots_end(); 
+       RI!=RE; ++RI) {
     // Scan the parameters for an implicit null dereference.
     for (llvm::SmallVectorImpl<VarDecl*>::iterator I=ErrorParams.begin(),
           E=ErrorParams.end(); I!=E; ++I)    
diff --git a/lib/Analysis/GRCoreEngine.cpp b/lib/Analysis/GRCoreEngine.cpp
index 4f0179ab59..66c12fd00f 100644
--- a/lib/Analysis/GRCoreEngine.cpp
+++ b/lib/Analysis/GRCoreEngine.cpp
@@ -119,13 +119,11 @@ GRWorkList* GRWorkList::MakeBFSBlockDFSContents() {
 //===----------------------------------------------------------------------===//
 // Core analysis engine.
 //===----------------------------------------------------------------------===//
-void GRCoreEngine::ProcessEndPath(GREndPathNodeBuilderImpl& BuilderImpl) {
-  GREndPathNodeBuilder<StateTy> Builder(BuilderImpl);
+void GRCoreEngine::ProcessEndPath(GREndPathNodeBuilder& Builder) {
   SubEngine.ProcessEndPath(Builder);
 }
 
-void GRCoreEngine::ProcessStmt(Stmt* S, GRStmtNodeBuilderImpl& BuilderImpl) {
-  GRStmtNodeBuilder<StateTy> Builder(BuilderImpl,SubEngine.getStateManager());
+void GRCoreEngine::ProcessStmt(Stmt* S, GRStmtNodeBuilder& Builder) {
   SubEngine.ProcessStmt(S, Builder);
 }
 
@@ -135,20 +133,18 @@ bool GRCoreEngine::ProcessBlockEntrance(CFGBlock* Blk, const GRState* State,
 }
 
 void GRCoreEngine::ProcessBranch(Stmt* Condition, Stmt* Terminator,
-                   GRBranchNodeBuilderImpl& BuilderImpl) {
-  GRBranchNodeBuilder<StateTy> Builder(BuilderImpl);
+                   GRBranchNodeBuilder& Builder) {
   SubEngine.ProcessBranch(Condition, Terminator, Builder);    
 }
 
-void GRCoreEngine::ProcessIndirectGoto(GRIndirectGotoNodeBuilderImpl& BuilderImpl) {
-  GRIndirectGotoNodeBuilder<GRState> Builder(BuilderImpl);
+void GRCoreEngine::ProcessIndirectGoto(GRIndirectGotoNodeBuilder& Builder) {
   SubEngine.ProcessIndirectGoto(Builder);
 }
 
-void GRCoreEngine::ProcessSwitch(GRSwitchNodeBuilderImpl& BuilderImpl) {
-  GRSwitchNodeBuilder<GRState> Builder(BuilderImpl);
+void GRCoreEngine::ProcessSwitch(GRSwitchNodeBuilder& Builder) {
   SubEngine.ProcessSwitch(Builder);
 }
+
 /// ExecuteWorkList - Run the worklist algorithm for a maximum number of steps.
 bool GRCoreEngine::ExecuteWorkList(unsigned Steps) {
   
@@ -224,7 +220,7 @@ void GRCoreEngine::HandleBlockEdge(const BlockEdge& L, ExplodedNode* Pred) {
             && "EXIT block cannot contain Stmts.");
 
     // Process the final state transition.
-    GREndPathNodeBuilderImpl Builder(Blk, Pred, this);
+    GREndPathNodeBuilder Builder(Blk, Pred, this);
     ProcessEndPath(Builder);
 
     // This path is done. Don't enqueue any more nodes.
@@ -238,7 +234,7 @@ void GRCoreEngine::HandleBlockEdge(const BlockEdge& L, ExplodedNode* Pred) {
 }
 
 void GRCoreEngine::HandleBlockEntrance(const BlockEntrance& L,
-                                           ExplodedNode* Pred) {
+                                       ExplodedNode* Pred) {
   
   // Increment the block counter.
   GRBlockCounter Counter = WList->getBlockCounter();
@@ -247,7 +243,8 @@ void GRCoreEngine::HandleBlockEntrance(const BlockEntrance& L,
   
   // Process the entrance of the block.  
   if (Stmt* S = L.getFirstStmt()) {
-    GRStmtNodeBuilderImpl Builder(L.getBlock(), 0, Pred, this);
+    GRStmtNodeBuilder Builder(L.getBlock(), 0, Pred, this, 
+                              SubEngine.getStateManager());
     ProcessStmt(S, Builder);
   }
   else 
@@ -298,7 +295,7 @@ void GRCoreEngine::HandleBlockExit(CFGBlock * B, ExplodedNode* Pred) {
         // Only 1 successor: the indirect goto dispatch block.
         assert (B->succ_size() == 1);
         
-        GRIndirectGotoNodeBuilderImpl
+        GRIndirectGotoNodeBuilder
            builder(Pred, B, cast<IndirectGotoStmt>(Term)->getTarget(),
                    *(B->succ_begin()), this);
         
@@ -322,9 +319,8 @@ void GRCoreEngine::HandleBlockExit(CFGBlock * B, ExplodedNode* Pred) {
       }
         
       case Stmt::SwitchStmtClass: {
-        GRSwitchNodeBuilderImpl builder(Pred, B,
-                                        cast<SwitchStmt>(Term)->getCond(),
-                                        this);
+        GRSwitchNodeBuilder builder(Pred, B, cast<SwitchStmt>(Term)->getCond(),
+                                    this);
         
         ProcessSwitch(builder);
         return;
@@ -346,8 +342,8 @@ void GRCoreEngine::HandleBranch(Stmt* Cond, Stmt* Term, CFGBlock * B,
                                 ExplodedNode* Pred) {
   assert (B->succ_size() == 2);
 
-  GRBranchNodeBuilderImpl Builder(B, *(B->succ_begin()), *(B->succ_begin()+1),
-                                  Pred, this);
+  GRBranchNodeBuilder Builder(B, *(B->succ_begin()), *(B->succ_begin()+1),
+                              Pred, this);
   
   ProcessBranch(Cond, Term, Builder);
 }
@@ -360,7 +356,8 @@ void GRCoreEngine::HandlePostStmt(const PostStmt& L, CFGBlock* B,
   if (StmtIdx == B->size())
     HandleBlockExit(B, Pred);
   else {
-    GRStmtNodeBuilderImpl Builder(B, StmtIdx, Pred, this);
+    GRStmtNodeBuilder Builder(B, StmtIdx, Pred, this, 
+                              SubEngine.getStateManager());
     ProcessStmt((*B)[StmtIdx], Builder);
   }
 }
@@ -384,19 +381,23 @@ void GRCoreEngine::GenerateNode(const ProgramPoint& Loc,
   if (IsNew) WList->Enqueue(Node);
 }
 
-GRStmtNodeBuilderImpl::GRStmtNodeBuilderImpl(CFGBlock* b, unsigned idx,
-                                             ExplodedNode* N, GRCoreEngine* e)
-  : Eng(*e), B(*b), Idx(idx), Pred(N), LastNode(N) {
+GRStmtNodeBuilder::GRStmtNodeBuilder(CFGBlock* b, unsigned idx,
+                                     ExplodedNode* N, GRCoreEngine* e,
+                                     GRStateManager &mgr)
+  : Eng(*e), B(*b), Idx(idx), Pred(N), LastNode(N), Mgr(mgr), Auditor(0), 
+    PurgingDeadSymbols(false), BuildSinks(false), HasGeneratedNode(false),
+    PointKind(ProgramPoint::PostStmtKind), Tag(0) {
   Deferred.insert(N);
+  CleanedState = getLastNode()->getState();
 }
 
-GRStmtNodeBuilderImpl::~GRStmtNodeBuilderImpl() {
+GRStmtNodeBuilder::~GRStmtNodeBuilder() {
   for (DeferredTy::iterator I=Deferred.begin(), E=Deferred.end(); I!=E; ++I)
     if (!(*I)->isSink())
       GenerateAutoTransition(*I);
 }
 
-void GRStmtNodeBuilderImpl::GenerateAutoTransition(ExplodedNode* N) {
+void GRStmtNodeBuilder::GenerateAutoTransition(ExplodedNode* N) {
   assert (!N->isSink());
   
   PostStmt Loc(getStmt());
@@ -452,17 +453,17 @@ static inline PostStmt GetPostLoc(const Stmt* S, ProgramPoint::Kind K,
 }
 
 ExplodedNode*
-GRStmtNodeBuilderImpl::generateNodeImpl(const Stmt* S, const GRState* State,
+GRStmtNodeBuilder::generateNodeInternal(const Stmt* S, const GRState* State,
                                         ExplodedNode* Pred,
                                         ProgramPoint::Kind K,
                                         const void *tag) {
   return K == ProgramPoint::PreStmtKind
-         ? generateNodeImpl(PreStmt(S, tag), State, Pred)
-         : generateNodeImpl(GetPostLoc(S, K, tag), State, Pred); 
+         ? generateNodeInternal(PreStmt(S, tag), State, Pred)
+         : generateNodeInternal(GetPostLoc(S, K, tag), State, Pred); 
 }
 
 ExplodedNode*
-GRStmtNodeBuilderImpl::generateNodeImpl(const ProgramPoint &Loc,
+GRStmtNodeBuilder::generateNodeInternal(const ProgramPoint &Loc,
                                         const GRState* State,
                                         ExplodedNode* Pred) {
   bool IsNew;
@@ -480,8 +481,8 @@ GRStmtNodeBuilderImpl::generateNodeImpl(const ProgramPoint &Loc,
   return NULL;  
 }
 
-ExplodedNode* GRBranchNodeBuilderImpl::generateNodeImpl(const GRState* State,
-                                                        bool branch) {
+ExplodedNode* GRBranchNodeBuilder::generateNode(const GRState* State,
+                                                bool branch) {
   
   // If the branch has been marked infeasible we should not generate a node.
   if (!isFeasible(branch))
@@ -507,9 +508,9 @@ ExplodedNode* GRBranchNodeBuilderImpl::generateNodeImpl(const GRState* State,
   return NULL;
 }
 
-GRBranchNodeBuilderImpl::~GRBranchNodeBuilderImpl() {
-  if (!GeneratedTrue) generateNodeImpl(Pred->State, true);
-  if (!GeneratedFalse) generateNodeImpl(Pred->State, false);
+GRBranchNodeBuilder::~GRBranchNodeBuilder() {
+  if (!GeneratedTrue) generateNode(Pred->State, true);
+  if (!GeneratedFalse) generateNode(Pred->State, false);
   
   for (DeferredTy::iterator I=Deferred.begin(), E=Deferred.end(); I!=E; ++I)
     if (!(*I)->isSink()) Eng.WList->Enqueue(*I);
@@ -517,13 +518,11 @@ GRBranchNodeBuilderImpl::~GRBranchNodeBuilderImpl() {
 
 
 ExplodedNode*
-GRIndirectGotoNodeBuilderImpl::generateNodeImpl(const Iterator& I,
-                                                const GRState* St,
-                                                bool isSink) {
+GRIndirectGotoNodeBuilder::generateNode(const iterator& I, const GRState* St,
+                                        bool isSink) {
   bool IsNew;
   
-  ExplodedNode* Succ =
-    Eng.G->getNode(BlockEdge(Src, I.getBlock()), St, &IsNew);
+  ExplodedNode* Succ = Eng.G->getNode(BlockEdge(Src, I.getBlock()), St, &IsNew);
               
   Succ->addPredecessor(Pred);
   
@@ -542,13 +541,11 @@ GRIndirectGotoNodeBuilderImpl::generateNodeImpl(const Iterator& I,
 
 
 ExplodedNode*
-GRSwitchNodeBuilderImpl::generateCaseStmtNodeImpl(const Iterator& I,
-                                                  const GRState* St) {
+GRSwitchNodeBuilder::generateCaseStmtNode(const iterator& I, const GRState* St){
 
   bool IsNew;
   
-  ExplodedNode* Succ = Eng.G->getNode(BlockEdge(Src, I.getBlock()),
-                                                St, &IsNew);  
+  ExplodedNode* Succ = Eng.G->getNode(BlockEdge(Src, I.getBlock()), St, &IsNew);
   Succ->addPredecessor(Pred);
   
   if (IsNew) {
@@ -561,8 +558,7 @@ GRSwitchNodeBuilderImpl::generateCaseStmtNodeImpl(const Iterator& I,
 
 
 ExplodedNode*
-GRSwitchNodeBuilderImpl::generateDefaultCaseNodeImpl(const GRState* St,
-                                                     bool isSink) {
+GRSwitchNodeBuilder::generateDefaultCaseNode(const GRState* St, bool isSink) {
   
   // Get the block for the default case.
   assert (Src->succ_rbegin() != Src->succ_rend());
@@ -570,8 +566,7 @@ GRSwitchNodeBuilderImpl::generateDefaultCaseNodeImpl(const GRState* St,
   
   bool IsNew;
   
-  ExplodedNode* Succ = Eng.G->getNode(BlockEdge(Src, DefaultBlock),
-                                                St, &IsNew);  
+  ExplodedNode* Succ = Eng.G->getNode(BlockEdge(Src, DefaultBlock), St, &IsNew);
   Succ->addPredecessor(Pred);
   
   if (IsNew) {
@@ -586,20 +581,18 @@ GRSwitchNodeBuilderImpl::generateDefaultCaseNodeImpl(const GRState* St,
   return NULL;
 }
 
-GREndPathNodeBuilderImpl::~GREndPathNodeBuilderImpl() {
+GREndPathNodeBuilder::~GREndPathNodeBuilder() {
   // Auto-generate an EOP node if one has not been generated.
-  if (!HasGeneratedNode) generateNodeImpl(Pred->State);
+  if (!HasGeneratedNode) generateNode(Pred->State);
 }
 
 ExplodedNode*
-GREndPathNodeBuilderImpl::generateNodeImpl(const GRState* State,
-                                           const void *tag,
-                                           ExplodedNode* P) {
+GREndPathNodeBuilder::generateNode(const GRState* State, const void *tag,
+                                   ExplodedNode* P) {
   HasGeneratedNode = true;    
   bool IsNew;
   
-  ExplodedNode* Node =
-    Eng.G->getNode(BlockEntrance(&B, tag), State, &IsNew);
+  ExplodedNode* Node = Eng.G->getNode(BlockEntrance(&B, tag), State, &IsNew);
   
   Node->addPredecessor(P ? P : Pred);
   
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, loc