[analyzer] Modularize builder use in processBranch.

Take advantage of the new builders for branch processing. As part of this change pass generic NodeBuilder (instead of BranchNodeBuilder) to the BranchCondition callback and remove the unused methods form BranchBuilder.

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

4 files changed, 26 insertions, 19 deletions

diff --git a/include/clang/StaticAnalyzer/Core/Checker.h b/include/clang/StaticAnalyzer/Core/Checker.h
index 1e4edeb0c7..51533489e5 100644
--- a/include/clang/StaticAnalyzer/Core/Checker.h
+++ b/include/clang/StaticAnalyzer/Core/Checker.h
@@ -215,7 +215,7 @@ public:
 class BranchCondition {
   template <typename CHECKER>
   static void _checkBranchCondition(void *checker, const Stmt *condition,
-                                    BranchNodeBuilder &B, ExprEngine &Eng) {
+                                    NodeBuilder &B, ExprEngine &Eng) {
     ((const CHECKER *)checker)->checkBranchCondition(condition, B, Eng);
   }
 
diff --git a/include/clang/StaticAnalyzer/Core/CheckerManager.h b/include/clang/StaticAnalyzer/Core/CheckerManager.h
index e3e4c49f71..6026aec643 100644
--- a/include/clang/StaticAnalyzer/Core/CheckerManager.h
+++ b/include/clang/StaticAnalyzer/Core/CheckerManager.h
@@ -39,7 +39,7 @@ namespace ento {
   class ExplodedGraph;
   class ProgramState;
   class EndOfFunctionNodeBuilder;
-  class BranchNodeBuilder;
+  class NodeBuilder;
   class MemRegion;
   class SymbolReaper;
 
@@ -232,7 +232,7 @@ public:
 
   /// \brief Run checkers for branch condition.
   void runCheckersForBranchCondition(const Stmt *condition,
-                                     BranchNodeBuilder &B, ExprEngine &Eng);
+                                     NodeBuilder &B, ExprEngine &Eng);
 
   /// \brief Run checkers for live symbols.
   ///
@@ -334,7 +334,7 @@ public:
   typedef CheckerFn<void (EndOfFunctionNodeBuilder &, ExprEngine &)>
       CheckEndPathFunc;
   
-  typedef CheckerFn<void (const Stmt *, BranchNodeBuilder &, ExprEngine &)>
+  typedef CheckerFn<void (const Stmt *, NodeBuilder &, ExprEngine &)>
       CheckBranchConditionFunc;
   
   typedef CheckerFn<void (SymbolReaper &, CheckerContext &)>
diff --git a/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h b/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h
index e366b065c0..1bbc66ced7 100644
--- a/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h
+++ b/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h
@@ -51,7 +51,7 @@ public:
       ST(st),
       size(Dst.size()),
       Ctx(builder.Eng, builder.getBlock()),
-      NB(Ctx, pred),
+      NB(pred, Ctx),
       respondsToCallback(respondsToCB) {
     assert(!(ST && ST != Pred->getState()));
   }
diff --git a/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h b/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h
index 7629ac4a67..ac174c4b39 100644
--- a/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h
+++ b/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h
@@ -181,7 +181,7 @@ protected:
   friend class StmtNodeBuilder;
 
   ExplodedNode *BuilderPred;
-  NodeBuilderContext &C;
+  const NodeBuilderContext &C;
   bool Finalized;
 
   /// \brief The frontier set - a set of nodes which need to be propagated after
@@ -212,12 +212,19 @@ protected:
                                  bool MarkAsSink = false);
 
 public:
-  NodeBuilder(NodeBuilderContext &Ctx, ExplodedNode *N)
+  NodeBuilder(ExplodedNode *N, NodeBuilderContext &Ctx)
     : BuilderPred(N), C(Ctx), Finalized(false) {
     assert(!N->isSink());
     Deferred.insert(N);
   }
 
+  /// Create a new builder using the parent builder's context.
+  NodeBuilder(ExplodedNode *N, const NodeBuilder &ParentBldr)
+    : BuilderPred(N), C(ParentBldr.C), Finalized(false) {
+    assert(!N->isSink());
+    Deferred.insert(N);
+  }
+
   virtual ~NodeBuilder() {}
 
   /// \brief Generates a node in the ExplodedGraph.
@@ -258,7 +265,11 @@ public:
                          C.Block->getBlockID());
   }
 
+  // \brief Get the builder's predecessor - the parent to all the other nodes.
   ExplodedNode *getPredecessor() const { return BuilderPred; }
+
+  // \brief Returns state of the predecessor.
+  const ProgramState *getState() const { return BuilderPred->getState(); }
 };
 
 class CommonNodeBuilder {
@@ -409,19 +420,19 @@ class BranchNodeBuilder: public NodeBuilder {
   }
 
 public:
-  BranchNodeBuilder(NodeBuilderContext &C, ExplodedNode *Pred,
+  BranchNodeBuilder(ExplodedNode *Pred, NodeBuilderContext &C,
                     const CFGBlock *dstT, const CFGBlock *dstF)
-  : NodeBuilder(C, Pred), DstT(dstT), DstF(dstF),
+  : NodeBuilder(Pred, C), DstT(dstT), DstF(dstF),
     GeneratedTrue(false), GeneratedFalse(false),
     InFeasibleTrue(!DstT), InFeasibleFalse(!DstF) {
   }
 
-  /// This function generate a new ExplodedNode but not a new
-  /// branch(block edge). Creates a transition from the Builder's top
-  /// predecessor.
-  ExplodedNode *generateNode(const Stmt *Condition, const ProgramState *State,
-                             const ProgramPointTag *Tag = 0,
-                             bool MarkAsSink = false);
+  /// Create a new builder using the parent builder's context.
+  BranchNodeBuilder(ExplodedNode *Pred, BranchNodeBuilder &ParentBldr)
+  : NodeBuilder(Pred, ParentBldr), DstT(ParentBldr.DstT), DstF(ParentBldr.DstF),
+    GeneratedTrue(false), GeneratedFalse(false),
+    InFeasibleTrue(!DstT), InFeasibleFalse(!DstF) {
+  }
 
   ExplodedNode *generateNode(const ProgramState *State, bool branch,
                              ExplodedNode *Pred = 0);
@@ -440,10 +451,6 @@ public:
   bool isFeasible(bool branch) {
     return branch ? !InFeasibleTrue : !InFeasibleFalse;
   }
-
-  const ProgramState *getState() const {
-    return getPredecessor()->getState();
-  }
 };
 
 class IndirectGotoNodeBuilder {