[analyzer] Previously, we were passing to CheckerContext enough info to construct ProgramPoint and it would pass it to NodeBuilder, which in turn would construct the ProgramPoint. Simplify it by just passing the ProgramPoint to CheckerContext. The ProgramPoint can only change if a checker tags it, in which case, we create a copy with the given tag.

(A step closer to making CheckerContext work with all node builders, not only StmtNodeBuilder.)

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

2 files changed, 40 insertions, 29 deletions

diff --git a/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h b/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h
index 03ab588a51..1f14787132 100644
--- a/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h
+++ b/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h
@@ -28,11 +28,9 @@ class CheckerContext {
   ExprEngine &Eng;
   ExplodedNode *Pred;
   SaveAndRestore<bool> OldSink;
-  const ProgramPointTag *checkerTag;
-  SaveAndRestore<ProgramPoint::Kind> OldPointKind;
   SaveOr OldHasGen;
+  const ProgramPoint Location;
   const ProgramState *ST;
-  const Stmt *statement;
   const unsigned size;
 public:
   bool *respondsToCallback;
@@ -41,21 +39,17 @@ public:
                  StmtNodeBuilder &builder,
                  ExprEngine &eng,
                  ExplodedNode *pred,
-                 const ProgramPointTag *tag,
-                 ProgramPoint::Kind K,
+                 const ProgramPoint &loc,
                  bool *respondsToCB = 0,
-                 const Stmt *stmt = 0,
                  const ProgramState *st = 0)
     : Dst(dst),
       B(builder),
       Eng(eng),
       Pred(pred),
       OldSink(B.BuildSinks),
-      checkerTag(tag),
-      OldPointKind(B.PointKind, K),
       OldHasGen(B.hasGeneratedNode),
+      Location(loc),
       ST(st),
-      statement(stmt),
       size(Dst.size()),
       respondsToCallback(respondsToCB) {}
 
@@ -172,10 +166,10 @@ private:
                                  bool markAsSink,
                                  ExplodedNode *pred = 0,
                                  const ProgramPointTag *tag = 0) {
-    assert(statement && "Only transitions with statements currently supported");
-    ExplodedNode *node = B.generateNode(statement, state,
-                                        pred ? pred : Pred,
-                                        tag  ? tag  : checkerTag);
+
+    ExplodedNode *node = B.generateNode(tag ? Location.withTag(tag) : Location,
+                                        state,
+                                        pred ? pred : Pred);
     if (markAsSink && node)
       node->markAsSink();
     return node;
diff --git a/lib/StaticAnalyzer/Core/CheckerManager.cpp b/lib/StaticAnalyzer/Core/CheckerManager.cpp
index ac4358d6fe..948ac1729c 100644
--- a/lib/StaticAnalyzer/Core/CheckerManager.cpp
+++ b/lib/StaticAnalyzer/Core/CheckerManager.cpp
@@ -140,9 +140,12 @@ namespace {
     void runChecker(CheckerManager::CheckStmtFunc checkFn,
                     ExplodedNodeSet &Dst, ExplodedNode *Pred) {
       // FIXME: Remove respondsToCallback from CheckerContext;
-      CheckerContext C(Dst, Eng.getBuilder(), Eng, Pred, checkFn.Checker,
-                       IsPreVisit ? ProgramPoint::PreStmtKind :
-                                    ProgramPoint::PostStmtKind, 0, S);
+      ProgramPoint::Kind K =  IsPreVisit ? ProgramPoint::PreStmtKind :
+                                           ProgramPoint::PostStmtKind;
+      const ProgramPoint &L = ProgramPoint::getProgramPoint(S, K,
+                                Pred->getLocationContext(), checkFn.Checker);
+      CheckerContext C(Dst, Eng.getBuilder(), Eng, Pred, L, 0);
+
       checkFn(S, C);
     }
   };
@@ -176,10 +179,12 @@ namespace {
 
     void runChecker(CheckerManager::CheckObjCMessageFunc checkFn,
                     ExplodedNodeSet &Dst, ExplodedNode *Pred) {
-      CheckerContext C(Dst, Eng.getBuilder(), Eng, Pred, checkFn.Checker,
-                       IsPreVisit ? ProgramPoint::PreStmtKind :
-                                    ProgramPoint::PostStmtKind, 0,
-                       Msg.getOriginExpr());
+      ProgramPoint::Kind K =  IsPreVisit ? ProgramPoint::PreStmtKind :
+                                           ProgramPoint::PostStmtKind;
+      const ProgramPoint &L = ProgramPoint::getProgramPoint(Msg.getOriginExpr(),
+                                K, Pred->getLocationContext(), checkFn.Checker);
+      CheckerContext C(Dst, Eng.getBuilder(), Eng, Pred, L, 0);
+
       checkFn(Msg, C);
     }
   };
@@ -216,9 +221,12 @@ namespace {
 
     void runChecker(CheckerManager::CheckLocationFunc checkFn,
                     ExplodedNodeSet &Dst, ExplodedNode *Pred) {
-      CheckerContext C(Dst, Eng.getBuilder(), Eng, Pred, checkFn.Checker,
-                       IsLoad ? ProgramPoint::PreLoadKind :
-                       ProgramPoint::PreStoreKind, 0, S);
+      ProgramPoint::Kind K =  IsLoad ? ProgramPoint::PreLoadKind :
+                                       ProgramPoint::PreStoreKind;
+      const ProgramPoint &L = ProgramPoint::getProgramPoint(S, K,
+                                Pred->getLocationContext(), checkFn.Checker);
+      CheckerContext C(Dst, Eng.getBuilder(), Eng, Pred, L, 0);
+
       checkFn(Loc, IsLoad, S, C);
     }
   };
@@ -251,8 +259,11 @@ namespace {
 
     void runChecker(CheckerManager::CheckBindFunc checkFn,
                     ExplodedNodeSet &Dst, ExplodedNode *Pred) {
-      CheckerContext C(Dst, Eng.getBuilder(), Eng, Pred, checkFn.Checker,
-                       ProgramPoint::PreStmtKind, 0, S);
+      ProgramPoint::Kind K =  ProgramPoint::PreStmtKind;
+      const ProgramPoint &L = ProgramPoint::getProgramPoint(S, K,
+                                Pred->getLocationContext(), checkFn.Checker);
+      CheckerContext C(Dst, Eng.getBuilder(), Eng, Pred, L, 0);
+
       checkFn(Loc, Val, S, C);
     }
   };
@@ -318,8 +329,11 @@ namespace {
 
     void runChecker(CheckerManager::CheckDeadSymbolsFunc checkFn,
                     ExplodedNodeSet &Dst, ExplodedNode *Pred) {
-      CheckerContext C(Dst, Eng.getBuilder(), Eng, Pred, checkFn.Checker,
-                       ProgramPoint::PostPurgeDeadSymbolsKind, 0, S);
+      ProgramPoint::Kind K = ProgramPoint::PostPurgeDeadSymbolsKind;
+      const ProgramPoint &L = ProgramPoint::getProgramPoint(S, K,
+                                Pred->getLocationContext(), checkFn.Checker);
+      CheckerContext C(Dst, Eng.getBuilder(), Eng, Pred, L, 0);
+
       checkFn(SR, C);
     }
   };
@@ -428,8 +442,11 @@ void CheckerManager::runCheckersForEvalCall(ExplodedNodeSet &Dst,
            EI = EvalCallCheckers.begin(), EE = EvalCallCheckers.end();
          EI != EE; ++EI) {
       ExplodedNodeSet checkDst;
-      CheckerContext C(checkDst, Eng.getBuilder(), Eng, Pred, EI->Checker,
-                       ProgramPoint::PostStmtKind, 0, CE);
+      ProgramPoint::Kind K = ProgramPoint::PostStmtKind;
+      const ProgramPoint &L = ProgramPoint::getProgramPoint(CE, K,
+                                Pred->getLocationContext(), EI->Checker);
+
+      CheckerContext C(checkDst, Eng.getBuilder(), Eng, Pred, L, 0);
       bool evaluated = (*EI)(CE, C);
       assert(!(evaluated && anyEvaluated)
              && "There are more than one checkers evaluating the call");