[analyzer][AST] print() JSONify: Stmt implementation

[Charusso]

Summary

This patch also adds a function called JsonFormat() which:

• Flattens the string so removes the new-lines.
• Escapes double quotes.

[NoQ]

I'd prefer to keep it in the Analyzer entirely (Decls as well), as it's a fairly esoteric use case.

[NoQ]

clang/include/clang/Basic/JsonSupport.h

26 ↗

(On Diff #201576)

inline is soo not worth typing these days.

[Charusso]

I have not found any better place and Decl-printing has more and more esoteric version with crazy boolean flags. Where would you move that?

[NoQ]

Ok, how about the following:

Out << escapeOutputForJson([](raw_ostream &OS) { S->printPretty(OS, Helper, PP, /*AddQuotes=*/true); });

Where escapeOutputForJson() is defined in JsonSupport.h as something like:

std::string escapeOutputForJson(std::function<void(raw_ostream &)> Func) {
  std::string Buf;
  llvm::raw_string_ostream TempOut(Buf);
  Func(TempOut);
  Out << JsonFormat(TempOut.str(), AddQuotes);
}

[NoQ]

I guess it's not that important though, i'm fine with committing it :)

[Charusso]

• Just rebase.

[Charusso]

In D62494#1519981, @NoQ wrote:

Ok, how about the following:

Out << escapeOutputForJson([](raw_ostream &OS) { S->printPretty(OS, Helper, PP, /*AddQuotes=*/true); });

When you wrote your idea that was my first idea as well as it is very common in the Static Analyzer, but our job is to make the life more simple.

[Charusso]

clang/include/clang/Basic/JsonSupport.h

26 ↗

(On Diff #201576)

Without that you cannot build Clang, so I will leave that.

[NoQ]

clang/include/clang/Basic/JsonSupport.h

26 ↗

(On Diff #201576)

Mm ok nvm then >.<

[NoQ]

In D62494#1521079, @Charusso wrote:

When you wrote your idea that was my first idea as well as it is very common in the Static Analyzer, but our job is to make the life more simple.

Ok!

include/clang/AST/Stmt.h

public:
   /// dumpPretty/printPretty - These two methods do a "pretty print" of the AST
   /// back to its original source language syntax.
   void dumpPretty(const ASTContext &Context) const;
   void printPretty(raw_ostream &OS, PrinterHelper *Helper,
                    const PrintingPolicy &Policy, unsigned Indentation = 0,
                    StringRef NewlineSymbol = "\n",
                    const ASTContext *Context = nullptr) const;
 
+  /// Pretty-prints in JSON format.
+  void printJson(raw_ostream &Out, PrinterHelper *Helper,
+                 const PrintingPolicy &Policy, bool AddQuotes) const;
+
   /// viewAST - Visualize an AST rooted at this Stmt* using GraphViz.  Only
   ///   works on systems with GraphViz (Mac OS X) or dot+gv installed.
   void viewAST() const;
 
   /// Skip no-op (attributed, compound) container stmts and skip captured
   /// stmt at the top, if \a IgnoreCaptured is true.
   Stmt *IgnoreContainers(bool IgnoreCaptured = false);
   const Stmt *IgnoreContainers(bool IgnoreCaptured = false) const {

include/clang/Basic/JsonSupport.h

 //===- JsonSupport.h - JSON Output Utilities --------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_BASIC_JSONSUPPORT_H
 #define LLVM_CLANG_BASIC_JSONSUPPORT_H
 
 #include "clang/Basic/LLVM.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/raw_ostream.h"
 
 
 namespace clang {
 
 inline raw_ostream &Indent(raw_ostream &Out, const unsigned int Space,
                            bool IsDot) {
   for (unsigned int I = 0; I < Space * 2; ++I)
     Out << (IsDot ? "&nbsp;" : " ");
   return Out;
 }
 
+inline std::string JsonFormat(StringRef RawSR, bool AddQuotes) {
+  if (RawSR.empty())
+    return "null";
+
+  // Trim special characters.
+  std::string Str = RawSR.trim().str();
+  size_t Pos = 0;
+
+  // Escape double quotes.
+  while (true) {
+    Pos = Str.find('\"', Pos);
+    if (Pos == std::string::npos)
+      break;
+
+    // Prevent bad conversions.
+    size_t TempPos = (Pos != 0) ? Pos - 1 : 0;
+
+    // See whether the current double quote is escaped.
+    if (TempPos != Str.find("\\\"", TempPos)) {
+      Str.insert(Pos, "\\");
+      ++Pos; // As we insert the escape-character move plus one.
+    }
+
+    ++Pos;
+  }
+
+  // Remove new-lines.
+  Str.erase(std::remove(Str.begin(), Str.end(), '\n'), Str.end());
+
+  if (!AddQuotes)
+    return Str;
+
+  return '\"' + Str + '\"';
+}
+
 } // namespace clang
 
 #endif // LLVM_CLANG_BASIC_JSONSUPPORT_H

lib/AST/StmtPrinter.cpp

 #include "clang/AST/StmtObjC.h"
 #include "clang/AST/StmtOpenMP.h"
 #include "clang/AST/StmtVisitor.h"
 #include "clang/AST/TemplateBase.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/ExpressionTraits.h"
 #include "clang/Basic/IdentifierTable.h"
+#include "clang/Basic/JsonSupport.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/Lambda.h"
 #include "clang/Basic/OpenMPKinds.h"
 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/TypeTraits.h"
 #include "clang/Lex/Lexer.h"
 #include "llvm/ADT/ArrayRef.h"

 //===----------------------------------------------------------------------===//
 // Stmt method implementations
 //===----------------------------------------------------------------------===//
 
 void Stmt::dumpPretty(const ASTContext &Context) const {
   printPretty(llvm::errs(), nullptr, PrintingPolicy(Context.getLangOpts()));
 }
 
-void Stmt::printPretty(raw_ostream &OS, PrinterHelper *Helper,
+void Stmt::printPretty(raw_ostream &Out, PrinterHelper *Helper,
                        const PrintingPolicy &Policy, unsigned Indentation,
-                       StringRef NL,
-                       const ASTContext *Context) const {
-  StmtPrinter P(OS, Helper, Policy, Indentation, NL, Context);
-  P.Visit(const_cast<Stmt*>(this));
+                       StringRef NL, const ASTContext *Context) const {
+  StmtPrinter P(Out, Helper, Policy, Indentation, NL, Context);
+  P.Visit(const_cast<Stmt *>(this));
 }
 
+void Stmt::printJson(raw_ostream &Out, PrinterHelper *Helper,
+                     const PrintingPolicy &Policy, bool AddQuotes) const {
+  std::string Buf;
+  llvm::raw_string_ostream TempOut(Buf);
+
+  printPretty(TempOut, Helper, Policy);
+
+  Out << JsonFormat(TempOut.str(), AddQuotes);
+}
+
 //===----------------------------------------------------------------------===//
 // PrinterHelper
 //===----------------------------------------------------------------------===//
 
 // Implement virtual destructor.
 PrinterHelper::~PrinterHelper() = default;

lib/Analysis/ProgramPoint.cpp

case ProgramPoint::PreStmtPurgeDeadSymbolsKind:
       return PreStmtPurgeDeadSymbols(S, LC, tag);
   }
 }
 
 LLVM_DUMP_METHOD void ProgramPoint::dump() const {
   return printJson(llvm::errs());
 }
 
-static void printLocation(raw_ostream &Out, SourceLocation Loc,
-                          const SourceManager &SM) {
+static void printLocJson(raw_ostream &Out, SourceLocation Loc,
   Out << "\"location\": ";
   if (!Loc.isFileID()) {
     Out << "null";
     return;
   }
 
   Out << "{ \"line\": " << SM.getExpansionLineNumber(Loc)
       << ", \"column\": " << SM.getExpansionColumnNumber(Loc) << " }";
 }
 
 void ProgramPoint::printJson(llvm::raw_ostream &Out, const char *NL) const {
   const ASTContext &Context =
       getLocationContext()->getAnalysisDeclContext()->getASTContext();
   const SourceManager &SM = Context.getSourceManager();
+  const PrintingPolicy &PP = Context.getPrintingPolicy();
+  const bool AddQuotes = true;
 
   Out << "\"kind\": \"";
   switch (getKind()) {
   case ProgramPoint::BlockEntranceKind:
     Out << "BlockEntrance\""
         << ", \"block_id\": "
         << castAs<BlockEntrance>().getBlock()->getBlockID();
     break;
 
   case ProgramPoint::FunctionExitKind: {
     auto FEP = getAs<FunctionExitPoint>();
     Out << "FunctionExit\""
         << ", \"block_id\": " << FEP->getBlock()->getBlockID()
         << ", \"stmt_id\": ";
 
     if (const ReturnStmt *RS = FEP->getStmt()) {
-      Out << RS->getID(Context) << ", \"stmt\": \"";
-      RS->printPretty(Out, /*Helper=*/nullptr, Context.getPrintingPolicy());
-      Out << '\"';
+      Out << RS->getID(Context) << ", \"stmt\": ";
+      RS->printJson(Out, nullptr, PP, AddQuotes);
     } else {
       Out << "null, \"stmt\": null";
     }
     break;
   }
   case ProgramPoint::BlockExitKind:
     llvm_unreachable("BlockExitKind");
     break;
Out << "LoopExit\", \"stmt\": \""
         << castAs<LoopExit>().getLoopStmt()->getStmtClassName() << '\"';
     break;
 
   case ProgramPoint::PreImplicitCallKind: {
     ImplicitCallPoint PC = castAs<ImplicitCallPoint>();
     Out << "PreCall\", \"stmt\": \"";
     PC.getDecl()->print(Out, Context.getLangOpts());
     Out << "\", ";
-    printLocation(Out, PC.getLocation(), SM);
+    printLocJson(Out, PC.getLocation(), SM);
     break;
   }
 
   case ProgramPoint::PostImplicitCallKind: {
     ImplicitCallPoint PC = castAs<ImplicitCallPoint>();
     Out << "PostCall\", \"stmt\": \"";
     PC.getDecl()->print(Out, Context.getLangOpts());
     Out << "\", ";
-    printLocation(Out, PC.getLocation(), SM);
+    printLocJson(Out, PC.getLocation(), SM);
     break;
   }
 
   case ProgramPoint::PostInitializerKind: {
     Out << "PostInitializer\", ";
     const CXXCtorInitializer *Init = castAs<PostInitializer>().getInitializer();
     if (const FieldDecl *FD = Init->getAnyMember()) {
       Out << "\"field_decl\": \"" << *FD << '\"';
case ProgramPoint::BlockEdgeKind: {
     Out << "Edge\", \"src_id\": " << E.getSrc()->getBlockID()
         << ", \"dst_id\": " << E.getDst()->getBlockID()
         << ", \"terminator\": " << (!T ? "null, \"term_kind\": null" : "\"");
     if (!T)
       break;
 
     E.getSrc()->printTerminator(Out, Context.getLangOpts());
     Out << "\", ";
-    printLocation(Out, T->getBeginLoc(), SM);
-    Out << ", \"term_kind\": \"";
+    printLocJson(Out, T->getBeginLoc(), SM);
 
+    Out << ", \"term_kind\": \"";
     if (isa<SwitchStmt>(T)) {
       Out << "SwitchStmt\", \"case\": ";
       if (const Stmt *Label = E.getDst()->getLabel()) {
         if (const auto *C = dyn_cast<CaseStmt>(Label)) {
           Out << "{ \"lhs\": ";
-          if (const Stmt *LHS = C->getLHS())
-            LHS->printPretty(Out, nullptr, Context.getPrintingPolicy());
-          else
+          if (const Stmt *LHS = C->getLHS()) {
+            LHS->printJson(Out, nullptr, PP, AddQuotes);
+          } else {
             Out << "null";
+    }
+
           Out << ", \"rhs\": ";
-          if (const Stmt *RHS = C->getRHS())
-            RHS->printPretty(Out, nullptr, Context.getPrintingPolicy());
-          else
+          if (const Stmt *RHS = C->getRHS()) {
+            RHS->printJson(Out, nullptr, PP, AddQuotes);
+          } else {
             Out << "null";
+          }
           Out << " }";
         } else {
           assert(isa<DefaultStmt>(Label));
           Out << "\"default\"";
         }
       } else {
         Out << "\"implicit default\"";
       }
     } else if (isa<IndirectGotoStmt>(T)) {
       // FIXME: More info.
       Out << "IndirectGotoStmt\"";
     } else {
       Out << "Condition\", \"value\": "
           << (*E.getSrc()->succ_begin() == E.getDst() ? "true" : "false");
     }
     break;
   }
 
   default: {
     const Stmt *S = castAs<StmtPoint>().getStmt();
     assert(S != nullptr && "Expecting non-null Stmt");
 
-    llvm::SmallString<256> TempBuf;
-    llvm::raw_svector_ostream TempOut(TempBuf);
-
     Out << "Statement\", \"stmt_kind\": \"" << S->getStmtClassName()
         << "\", \"stmt_id\": " << S->getID(Context)
         << ", \"pointer\": \"" << (const void *)S << "\", \"pretty\": ";
 
-    // See whether the current statement is pretty-printable.
-    S->printPretty(TempOut, /*Helper=*/nullptr, Context.getPrintingPolicy());
-    if (!TempBuf.empty()) {
-      Out << '\"' << TempBuf.str().trim() << "\", ";
-      TempBuf.clear();
-    } else {
-      Out << "null, ";
-    }
+    S->printJson(Out, nullptr, PP, AddQuotes);
 
-    printLocation(Out, S->getBeginLoc(), SM);
+    Out << ", ";
+    printLocJson(Out, S->getBeginLoc(), SM);
 
     Out << ", \"stmt_point_kind\": ";
     if (getAs<PreStmt>())
       Out << "\"PreStmt\"";
     else if (getAs<PostLoad>())
       Out << "\"PostLoad\"";
     else if (getAs<PostStore>())
       Out << "\"PostStore\"";

lib/StaticAnalyzer/Core/Environment.cpp

void Environment::printJson(raw_ostream &Out, const ASTContext &Ctx,
   Out << '[' << NL; // Start of Environment.
   PrintingPolicy PP = Ctx.getPrintingPolicy();
 
   LCtx->printJson(Out, NL, Space, IsDot, [&](const LocationContext *LC) {
     // LCtx items begin
     bool HasItem = false;
     unsigned int InnerSpace = Space + 1;
 
-    llvm::SmallString<256> TempBuf;
-    llvm::raw_svector_ostream TempOut(TempBuf);
-
     // Store the last ExprBinding which we will print.
     BindingsTy::iterator LastI = ExprBindings.end();
     for (BindingsTy::iterator I = ExprBindings.begin(); I != ExprBindings.end();
          ++I) {
       if (I->first.getLocationContext() != LC)
         continue;
 
       if (!HasItem) {
for (BindingsTy::iterator I = ExprBindings.begin(); I != ExprBindings.end();
       if (I->first.getLocationContext() != LC)
         continue;
 
       const Stmt *S = I->first.getStmt();
       Indent(Out, InnerSpace, IsDot)
           << "{ \"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 (!TempBuf.empty()) {
-        Out << '\"' << TempBuf.str().trim() << '\"';
-        TempBuf.clear();
-      } else {
-        Out << "null";
-      }
+      S->printJson(Out, nullptr, PP, /*AddQuotes=*/true);
 
       Out << ", \"value\": \"" << I->second << "\" }";
 
       if (I != LastI)
         Out << ',';
       Out << NL;
     }
 
     if (HasItem)
       Indent(Out, --InnerSpace, IsDot) << ']';
     else
       Out << "null ";
   });
 
   Indent(Out, --Space, IsDot) << "]," << NL; // End of Environment.
 }

lib/StaticAnalyzer/Core/ExprEngine.cpp

if (getItem().getKind() == ConstructionContextItem::ArgumentKind)
       Out << getItem().getIndex();
     else
       Out << "null";
 
     // Pretty-print
     Out << ", \"pretty\": ";
 
     if (S) {
-      llvm::SmallString<256> TempBuf;
-      llvm::raw_svector_ostream TempOut(TempBuf);
-
-      // See whether the current statement is pretty-printable.
-      S->printPretty(TempOut, Helper, PP);
-      if (!TempBuf.empty()) {
-        Out << '\"' << TempBuf.str().trim() << '\"';
-        TempBuf.clear();
-      } else {
-        Out << "null";
-      }
+      S->printJson(Out, Helper, PP, /*AddQuotes=*/true);
     } else {
       Out << '\"' << I->getAnyMember()->getNameAsString() << '\"';
     }
   }
 
   void Profile(llvm::FoldingSetNodeID &ID) const {
     ID.Add(Impl.first);
     ID.AddPointer(Impl.second);