[analyzer] Dump reproducible identifiers for statements in exploded graph in store

[NoQ]

This would have helped me immensely with debugging temporary materialization support. Assuming that we dump these identifiers in symbols/regions as well.

[NoQ]

clang/lib/StaticAnalyzer/Core/ProgramState.cpp

460

You can obtain Context from getStateManager() here as well.

clang/include/clang/StaticAnalyzer/Core/PathSensitive/Environment.h

void Profile(llvm::FoldingSetNodeID& ID) const {
     Profile(ID, this);
   }
 
   bool operator==(const Environment& RHS) const {
     return ExprBindings == RHS.ExprBindings;
   }
 
   void print(raw_ostream &Out, const char *NL, const char *Sep,
+             const ASTContext &Context,
              const LocationContext *WithLC = nullptr) const;
 };
 
 class EnvironmentManager {
 private:
   using FactoryTy = Environment::BindingsTy::Factory;
 
   FactoryTy F;

clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h

public:
 
   template<typename T>
   bool contains(typename ProgramStateTrait<T>::key_type key) const {
     void *const* d = FindGDM(ProgramStateTrait<T>::GDMIndex());
     return ProgramStateTrait<T>::Contains(ProgramStateTrait<T>::MakeData(d), key);
   }
 
   // Pretty-printing.
-  void print(raw_ostream &Out, const char *nl = "\n", const char *sep = "",
+  void print(raw_ostream &Out,
+             const ASTContext &Context,
+             const char *nl = "\n", const char *sep = "",
              const LocationContext *CurrentLC = nullptr) const;
   void printDOT(raw_ostream &Out,
+                const ASTContext &Context,
                 const LocationContext *CurrentLC = nullptr) const;
   void printTaint(raw_ostream &Out, const char *nl = "\n",
                   const char *sep = "") const;
 
   void dump() const;
   void dumpTaint() const;
 
 private:

clang/lib/StaticAnalyzer/Core/Environment.cpp

for (Environment::iterator I = Env.begin(), E = Env.end();
     }
   }
 
   NewEnv.ExprBindings = EBMapRef.asImmutableMap();
   return NewEnv;
 }
 
 void Environment::print(raw_ostream &Out, const char *NL,
-                        const char *Sep, const LocationContext *WithLC) const {
+                        const char *Sep,
+                        const ASTContext &Context,
+                        const LocationContext *WithLC) const {
   if (ExprBindings.isEmpty())
     return;
 
   if (!WithLC) {
     // Find the freshest location context.
     llvm::SmallPtrSet<const LocationContext *, 16> FoundContexts;
     for (auto I : *this) {
       const LocationContext *LC = I.first.getLocationContext();
       if (FoundContexts.count(LC) == 0) {
         // This context is fresher than all other contexts so far.
         WithLC = LC;
         for (const LocationContext *LCI = LC; LCI; LCI = LCI->getParent())
           FoundContexts.insert(LCI);
       }
     }
   }
 
   assert(WithLC);
 
-  LangOptions LO; // FIXME.
-  PrintingPolicy PP(LO);
+  PrintingPolicy PP = Context.getPrintingPolicy();
 
   Out << NL << NL << "Expressions by stack frame:" << NL;
   WithLC->dumpStack(Out, "", NL, Sep, [&](const LocationContext *LC) {
     for (auto I : ExprBindings) {
       if (I.first.getLocationContext() != LC)
         continue;
 
       const Stmt *S = I.first.getStmt();
       assert(S != nullptr && "Expected non-null Stmt");
 
-      Out << "(" << (const void *)LC << ',' << (const void *)S << ") ";
-      S->printPretty(Out, nullptr, PP);
+      Out << "(LC" << (const void *)LC << ", S" << S->getID(Context) << " <"
+          << (const void *)S << "> ) ";
+      S->printPretty(Out, /*Helper=*/nullptr, PP);
       Out << " : " << I.second << NL;
     }
   });
 }

clang/lib/StaticAnalyzer/Core/ExprEngine.cpp

       break;
     }
 
     default: {
       const Stmt *S = Loc.castAs<StmtPoint>().getStmt();
       assert(S != nullptr && "Expecting non-null Stmt");
 
       Out << S->getStmtClassName() << ' '
-          << S->getID(Context) << " (" << (const void *)S << ") ";
+          << S->getID(Context) << " <" << (const void *)S << "> ";
       S->printPretty(Out, /*helper=*/nullptr, Context.getPrintingPolicy(),
                      /*Indentation=*/2, /*NewlineSymbol=*/"\\l");
       printLocation(Out, S->getBeginLoc());
 
       if (Loc.getAs<PreStmt>())
         Out << "\\lPreStmt\\l;";
       else if (Loc.getAs<PostLoad>())
         Out << "\\lPostLoad\\l;";

     }
 
     Out << "\\l\\|";
 
     ExplodedGraph &Graph =
         static_cast<ExprEngine *>(State->getStateManager().getOwningEngine())
             ->getGraph();
 
-    Out << "StateID: " << State->getID() << " (" << (const void *)State.get()
-        << ")"
-        << " NodeID: " << N->getID(&Graph) << " (" << (const void *)N << ")\\|";
+    Out << "StateID: " << State->getID() << " <" << (const void *)State.get()
+        << ">"
+        << " NodeID: " << N->getID(&Graph) << " <" << (const void *)N << ">\\|";
 
     bool SameAsAllPredecessors =
         std::all_of(N->pred_begin(), N->pred_end(), [&](const ExplodedNode *P) {
           return P->getState()->getID() == State->getID();
         });
     if (!SameAsAllPredecessors)
-      State->printDOT(Out, N->getLocationContext());
+      State->printDOT(Out, Context, N->getLocationContext());
     return Out.str();
   }
 };
 
 } // namespace llvm
 #endif
 
 void ExprEngine::ViewGraph(bool trim) {

clang/lib/StaticAnalyzer/Core/ProgramState.cpp

if (store)
     stateMgr->getStoreManager().decrementReferenceCount(store);
   store = newStoreStore;
 }
 
 //===----------------------------------------------------------------------===//
 //  State pretty-printing.
 //===----------------------------------------------------------------------===//
 
-void ProgramState::print(raw_ostream &Out, const char *NL, const char *Sep,
+void ProgramState::print(raw_ostream &Out,
+                         const ASTContext &Context,
+                         const char *NL, const char *Sep,
                          const LocationContext *LC) const {
   // Print the store.
   ProgramStateManager &Mgr = getStateManager();
   Mgr.getStoreManager().print(getStore(), Out, NL, Sep);
 
   // Print out the environment.
-  Env.print(Out, NL, Sep, LC);
+  Env.print(Out, NL, Sep, Context, LC);
 
   // Print out the constraints.
   Mgr.getConstraintManager().print(this, Out, NL, Sep);
 
   // Print out the tracked dynamic types.
   printDynamicTypeInfo(this, Out, NL, Sep);
 
   // Print out tainted symbols.
   printTaint(Out, NL, Sep);
 
   // Print checker-specific data.
   Mgr.getOwningEngine()->printState(Out, this, NL, Sep, LC);
 }
 
-void ProgramState::printDOT(raw_ostream &Out, const LocationContext *LC) const {
-  print(Out, "\\l", "\\|", LC);
+void ProgramState::printDOT(raw_ostream &Out,
+                            const ASTContext &Context,
+                            const LocationContext *LC) const {
+  print(Out, Context, "\\l", "\\|", LC);
 }
 
 LLVM_DUMP_METHOD void ProgramState::dump() const {
-  print(llvm::errs());
+  print(llvm::errs(), getStateManager().getContext());
 }
 
 void ProgramState::printTaint(raw_ostream &Out,
                               const char *NL, const char *Sep) const {
   TaintMapImpl TM = get<TaintMap>();
 
   if (!TM.isEmpty())
     Out <<"Tainted symbols:" << NL;