[analyzer] print() JSONify: Environment implementation

[Charusso]

Summary

-

[Charusso]

• Improved the JSON format.

[NoQ]

Looks great!

[Charusso]

• 100% pure JSON.

clang/include/clang/Analysis/AnalysisDeclContext.h

public:
   const StackFrameContext *getStackFrame() const;
 
   /// Return true if the current LocationContext has no caller context.
   virtual bool inTopFrame() const;
 
   virtual void Profile(llvm::FoldingSetNodeID &ID) = 0;
 
   void dumpStack(
-      raw_ostream &OS, StringRef Indent = {}, const char *NL = "\n",
-      const char *Sep = "",
+      raw_ostream &Out, const char *NL = "\n", const char *Sep = "",
       std::function<void(const LocationContext *)> printMoreInfoPerContext =
           [](const LocationContext *) {}) const;
-  void dumpStack() const;
+
+  void print(
+      raw_ostream &Out, const char *NL = "\n", const char *Sep = "",
+      unsigned int Space = 0,
+      std::function<void(const LocationContext *)> printMoreInfoPerContext =
+          [](const LocationContext *) {}) const;
+
+  void dump() const;
 
 public:
   static void ProfileCommon(llvm::FoldingSetNodeID &ID,
                             ContextKind ck,
                             AnalysisDeclContext *ctx,
                             const LocationContext *parent,
                             const void *data);
 };

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

public:
   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;
+  void print(raw_ostream &Out, const ASTContext &Ctx,
+             const LocationContext *LCtx = nullptr, const char *NL = "\n",
+             const char *Sep = "", unsigned int Space = 0) const;
 };
 
 class EnvironmentManager {
 private:
   using FactoryTy = Environment::BindingsTy::Factory;
 
   FactoryTy F;
 

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

public:
   processRegionChanges(ProgramStateRef state,
                        const InvalidatedSymbols *invalidated,
                        ArrayRef<const MemRegion *> ExplicitRegions,
                        ArrayRef<const MemRegion *> Regions,
                        const LocationContext *LCtx,
                        const CallEvent *Call) override;
 
   /// printState - Called by ProgramStateManager to print checker-specific data.
-  void printState(raw_ostream &Out, ProgramStateRef State, const char *NL,
-                  const char *Sep,
-                  const LocationContext *LCtx = nullptr) override;
+  void printState(raw_ostream &Out, ProgramStateRef State,
+                  const LocationContext *LCtx, const char *NL, const char *Sep,
+                  unsigned int Space) const override;
 
   ProgramStateManager &getStateManager() override { return StateMgr; }
 
   StoreManager &getStoreManager() { return StateMgr.getStoreManager(); }
 
   ConstraintManager &getConstraintManager() {
     return StateMgr.getConstraintManager();
   }

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

public:
   notifyCheckersOfPointerEscape(ProgramStateRef State,
                            const InvalidatedSymbols *Invalidated,
                            ArrayRef<const MemRegion *> ExplicitRegions,
                            const CallEvent *Call,
                            RegionAndSymbolInvalidationTraits &HTraits) = 0;
 
   /// printState - Called by ProgramStateManager to print checker-specific data.
   virtual void printState(raw_ostream &Out, ProgramStateRef State,
-                          const char *NL, const char *Sep,
-                          const LocationContext *LCtx = nullptr) = 0;
+                          const LocationContext *LCtx, const char *NL,
+                          const char *Sep, unsigned int Space) const = 0;
 
   /// Called by CoreEngine when the analysis worklist is either empty or the
   //  maximum number of analysis steps have been reached.
   virtual void processEndWorklist() = 0;
 };
 
 } // end GR namespace
 
 } // end clang namespace
 
 #endif

clang/lib/Analysis/AnalysisDeclContext.cpp

 #include "clang/AST/Stmt.h"
 #include "clang/AST/StmtCXX.h"
 #include "clang/AST/StmtVisitor.h"
 #include "clang/Analysis/Analyses/CFGReachabilityAnalysis.h"
 #include "clang/Analysis/BodyFarm.h"
 #include "clang/Analysis/CFG.h"
 #include "clang/Analysis/CFGStmtMap.h"
 #include "clang/Analysis/Support/BumpVector.h"
+#include "clang/Basic/JsonSupport.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/iterator_range.h"
if (Parent == this)
       return true;
     else
       LC = Parent;
   } while (LC);
 
   return false;
 }
 
-static void printLocation(raw_ostream &OS, const SourceManager &SM,
-                          SourceLocation SLoc) {
-  if (SLoc.isFileID() && SM.isInMainFile(SLoc))
-    OS << "line " << SM.getExpansionLineNumber(SLoc);
+static void printLocation(raw_ostream &Out, const SourceManager &SM,
+                          SourceLocation Loc) {
+  if (Loc.isFileID() && SM.isInMainFile(Loc))
+    Out << SM.getExpansionLineNumber(Loc);
   else
-    SLoc.print(OS, SM);
+    Loc.print(Out, SM);
 }
 
-void LocationContext::dumpStack(
-    raw_ostream &OS, StringRef Indent, const char *NL, const char *Sep,
-    std::function<void(const LocationContext *)> printMoreInfoPerContext) const {
+void LocationContext::dumpStack(raw_ostream &Out, const char *NL,
+                                const char *Sep,
+                                std::function<void(const LocationContext *)>
+                                    printMoreInfoPerContext) const {
   ASTContext &Ctx = getAnalysisDeclContext()->getASTContext();
   PrintingPolicy PP(Ctx.getLangOpts());
   PP.TerseOutput = 1;
 
   const SourceManager &SM =
       getAnalysisDeclContext()->getASTContext().getSourceManager();
 
   unsigned Frame = 0;
   for (const LocationContext *LCtx = this; LCtx; LCtx = LCtx->getParent()) {
     switch (LCtx->getKind()) {
     case StackFrame:
-      OS << Indent << '#' << Frame << ' ';
+      Out << "\t#" << Frame << ' ';
       ++Frame;
       if (const auto *D = dyn_cast<NamedDecl>(LCtx->getDecl()))
-        OS << "Calling " << D->getQualifiedNameAsString();
+        Out << "Calling " << D->getQualifiedNameAsString();
       else
-        OS << "Calling anonymous code";
+        Out << "Calling anonymous code";
       if (const Stmt *S = cast<StackFrameContext>(LCtx)->getCallSite()) {
-        OS << " at ";
-        printLocation(OS, SM, S->getBeginLoc());
+        Out << " at line ";
+        printLocation(Out, SM, S->getBeginLoc());
       }
       break;
     case Scope:
-      OS << "Entering scope";
+      Out << "Entering scope";
       break;
     case Block:
-      OS << "Invoking block";
+      Out << "Invoking block";
       if (const Decl *D = cast<BlockInvocationContext>(LCtx)->getDecl()) {
-        OS << " defined at ";
-        printLocation(OS, SM, D->getBeginLoc());
+        Out << " defined at line ";
+        printLocation(Out, SM, D->getBeginLoc());
       }
       break;
     }
-    OS << NL;
+    Out << NL;
 
     printMoreInfoPerContext(LCtx);
   }
 }
 
-LLVM_DUMP_METHOD void LocationContext::dumpStack() const {
-  dumpStack(llvm::errs());
+void LocationContext::print(raw_ostream &Out, const char *NL, const char *Sep,
+                            unsigned int Space,
+                            std::function<void(const LocationContext *)>
+                                printMoreInfoPerContext) const {
+  ASTContext &Ctx = getAnalysisDeclContext()->getASTContext();
+  PrintingPolicy PP(Ctx.getLangOpts());
+  PP.TerseOutput = 1;
+
+  const SourceManager &SM =
+      getAnalysisDeclContext()->getASTContext().getSourceManager();
+
+  unsigned Frame = 0;
+  for (const LocationContext *LCtx = this; LCtx; LCtx = LCtx->getParent()) {
+    Indent(Out, Space) << "{ \"location_context\": \"";
+    switch (LCtx->getKind()) {
+    case StackFrame:
+      Out << '#' << Frame << " Call\", \"calling\": \"";
+      ++Frame;
+      if (const auto *D = dyn_cast<NamedDecl>(LCtx->getDecl()))
+        Out << D->getQualifiedNameAsString();
+      else
+        Out << "anonymous code";
+
+      Out << "\", \"call_line\": ";
+      if (const Stmt *S = cast<StackFrameContext>(LCtx)->getCallSite()) {
+        Out << '\"';
+        printLocation(Out, SM, S->getBeginLoc());
+  Out << '\"';
+      } else {
+        Out << "null";
       }
 
+      Out << ", \"items\": ";
+      break;
+    case Scope:
+      Out << "Entering scope\"";
+      break;
+    case Block:
+      Out << "Invoking block\"";
+      if (const Decl *D = cast<BlockInvocationContext>(LCtx)->getDecl()) {
+        Out << ", \"decl_line\": ";
+        printLocation(Out, SM, D->getBeginLoc());
+        Out << ' ';
+      }
+      break;
+    }
+
+    printMoreInfoPerContext(LCtx);
+
+    Out << "}," << NL;
+  }
+}
+
+LLVM_DUMP_METHOD void LocationContext::dump() const { print(llvm::errs()); }
+
 //===----------------------------------------------------------------------===//
 // Lazily generated map to query the external variables referenced by a Block.
 //===----------------------------------------------------------------------===//
 
 namespace {
 
 class FindBlockDeclRefExprsVals : public StmtVisitor<FindBlockDeclRefExprsVals>{
   BumpVector<const VarDecl *> &BEVals;

clang/lib/StaticAnalyzer/Core/Environment.cpp

 #include "clang/StaticAnalyzer/Core/PathSensitive/Environment.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/PrettyPrinter.h"
 #include "clang/AST/Stmt.h"
 #include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/LangOptions.h"
+#include "clang/Basic/JsonSupport.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SymExpr.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h"
 #include "llvm/ADT/ImmutableMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/Casting.h"
if (SymReaper.isLive(BlkExpr.getStmt(), BlkExpr.getLocationContext())) {
       RSScaner.scan(X);
     }
   }
 
   NewEnv.ExprBindings = EBMapRef.asImmutableMap();
   return NewEnv;
 }
 
-void Environment::print(raw_ostream &Out, const char *NL,
-                        const char *Sep,
-                        const ASTContext &Context,
-                        const LocationContext *WithLC) const {
-  if (ExprBindings.isEmpty())
+void Environment::print(raw_ostream &Out, const ASTContext &Ctx,
+                        const LocationContext *LCtx, const char *NL,
+                        const char *Sep, unsigned int Space) const {
+  Indent(Out, Space)
+      << "\"environment\": { \"title\": \"Environment\", \"items\": ";
+  ++Space;
+
+  if (ExprBindings.isEmpty()) {
+    Out << "\"null\" }," << NL;
     return;
+  }
 
-  if (!WithLC) {
+  if (!LCtx) {
     // 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;
+        LCtx = LC;
         for (const LocationContext *LCI = LC; LCI; LCI = LCI->getParent())
           FoundContexts.insert(LCI);
       }
     }
   }
 
-  assert(WithLC);
+  assert(LCtx);
+
+  // Environment items begin
+  Out << '[' << NL;
+
+  PrintingPolicy PP = Ctx.getPrintingPolicy();
 
-  PrintingPolicy PP = Context.getPrintingPolicy();
+  LCtx->print(Out, NL, Sep, Space, [&](const LocationContext *LC) {
+    // LCtx items begin
+    bool HasItem = false;
+    unsigned int InnerSpace = Space + 1;
 
-  Out << NL << "Expressions by stack frame:" << NL;
-  WithLC->dumpStack(Out, "", NL, Sep, [&](const LocationContext *LC) {
-    for (auto I : ExprBindings) {
+    llvm::SmallString<256> Buf;
+    llvm::raw_svector_ostream TempOut(Buf);
+
+    for (const auto &I : ExprBindings) {
       if (I.first.getLocationContext() != LC)
         continue;
 
+      if (!HasItem) {
+        HasItem = true;
+        Out << '[' << NL;
+      }
+
       const Stmt *S = I.first.getStmt();
       assert(S != nullptr && "Expected non-null Stmt");
 
-      Out << "(LC" << LC->getID() << ", S" << S->getID(Context) << ") ";
-      S->printPretty(Out, /*Helper=*/nullptr, PP);
-      Out << " : " << I.second << NL;
+      Indent(Out, InnerSpace)
+          << "{ \"lctx_id\": " << LC->getID()
+          << ", \"stmt_id\": " << S->getID(Ctx) << ", \"pretty\": ";
+
+      // See whether the current statement is pretty-printable.
+      S->printPretty(TempOut, /*Helper=*/nullptr, PP);
+      if (!Buf.empty()) {
+        Out << '\"' << Buf << '\"';
+        Buf.clear();
+      } else {
+        Out << "null";
+      }
+
+      Out << ", \"value\": \"" << I.second << "\" }," << NL;
     }
+
+    if (HasItem)
+      Indent(Out, --InnerSpace) << ']';
+    else
+      Out << "null ";
   });
+
+  Indent(Out, --Space) << "]}," << NL;
 }

clang/lib/StaticAnalyzer/Core/ExprEngine.cpp

for (auto I : State->get<ObjectsUnderConstruction>()) {
     if (Key.getLocationContext() != LC)
       continue;
     Key.print(Out, nullptr, PP);
     Out << " : " << Value << NL;
   }
 }
 
 void ExprEngine::printState(raw_ostream &Out, ProgramStateRef State,
-                            const char *NL, const char *Sep,
-                            const LocationContext *LCtx) {
+                            const LocationContext *LCtx, const char *NL,
+                            const char *Sep, unsigned int Space) const {
   if (LCtx) {
     if (!State->get<ObjectsUnderConstruction>().isEmpty()) {
-      Out << Sep << "Objects under construction:" << NL;
+      Out << "Objects under construction:" << NL;
 
-      LCtx->dumpStack(Out, "", NL, Sep, [&](const LocationContext *LC) {
+      LCtx->print(Out, NL, Sep, Space, [&](const LocationContext *LC) {
         printObjectsUnderConstructionForContext(Out, State, NL, LC);
       });
     }
   }
 
   getCheckerManager().runCheckersForPrintState(Out, State, NL, Sep);
 }
 

clang/lib/StaticAnalyzer/Core/PrettyStackTraceLocationContext.h

 /// \endcode
 class PrettyStackTraceLocationContext : public llvm::PrettyStackTraceEntry {
   const LocationContext *LCtx;
 public:
   PrettyStackTraceLocationContext(const LocationContext *LC) : LCtx(LC) {
     assert(LCtx);
   }
 
-  void print(raw_ostream &OS) const override {
-    OS << "While analyzing stack: \n";
-    LCtx->dumpStack(OS, "\t");
+  void print(raw_ostream &Out) const override {
+    Out << "While analyzing stack: \n";
+    LCtx->dumpStack(Out);
   }
 };
 
 } // end ento namespace
 } // end clang namespace
 
 #endif

clang/lib/StaticAnalyzer/Core/ProgramState.cpp

void ProgramState::print(raw_ostream &Out, const LocationContext *LCtx,
                          const char *NL, const char *Sep,
                          unsigned int Space) const {
   // Print the store.
   ProgramStateManager &Mgr = getStateManager();
   const ASTContext &Context = getStateManager().getContext();
   Mgr.getStoreManager().print(Out, getStore(), NL, Sep, Space);
 
   // Print out the environment.
-  Env.print(Out, NL, Sep, Context, LCtx);
+  Env.print(Out, Context, LCtx, NL, Sep, Space);
 
   // Print out the constraints.
   Mgr.getConstraintManager().print(this, Out, NL, Sep);
 
   // Print out the tracked dynamic types.
   printDynamicTypeInfo(this, Out, NL, Sep);
 
   // Print checker-specific data.
-  Mgr.getOwningEngine().printState(Out, this, NL, Sep, LCtx);
+  Mgr.getOwningEngine().printState(Out, this, LCtx, NL, Sep, Space);
 }
 
 void ProgramState::printDOT(raw_ostream &Out, const LocationContext *LCtx,
                             unsigned int Space) const {
   print(Out, LCtx, "\\l", "\\|", Space);
 }
 
 LLVM_DUMP_METHOD void ProgramState::dump() const {

clang/test/Analysis/expr-inspection.c

void foo(int x) {
   }
 }
 
 // CHECK:      "store": { "title": "Store", "items": [
 // CHECK-NEXT:   { "cluster": "y", "items": [
 // CHECK-NEXT:     { "kind": "Direct", "offset": 0, "value": "2 S32b" },
 // CHECK-NEXT:   ]},
 // CHECK-NEXT: ]},
-
-// CHECK:      Expressions by stack frame:
-// CHECK-NEXT: #0 Calling foo
-// CHECK-NEXT: (LC1, S847) clang_analyzer_printState : &code{clang_analyzer_printState}
+// CHECK-NEXT: "environment": { "title": "Environment", "items": [
+// CHECK-NEXT:   { "location_context": "#0 Call", "calling": "foo", "call_line": null, "items": [
+// CHECK-NEXT:     { "lctx_id": 1, "stmt_id": 847, "pretty": "clang_analyzer_printState", "value": "&code{clang_analyzer_printState}" },
+// CHECK-NEXT:   ]},
+// CHECK-NEXT: ]},
 
 // CHECK:      Ranges of symbol values:
 // CHECK-NEXT:  reg_$0<int x> : { [-2147483648, 13] }