[analyzer] print() JSONify: Type information implementation

[Charusso]

Summary

-

[Charusso]

• Improved the JSON format.

[NoQ]

I wish for more tests, but hopefully we'll get them eventually.

[Charusso]

• 100% pure JSON.

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

 namespace ento {
 
 class MemRegion;
 
 /// The GDM component containing the dynamic type info. This is a map from a
 /// symbol to its most likely type.
 struct DynamicTypeMap {};
 
-using DynamicTypeMapImpl =
-    llvm::ImmutableMap<const MemRegion *, DynamicTypeInfo>;
+using DynamicTypeMapTy = llvm::ImmutableMap<const MemRegion *, DynamicTypeInfo>;
 
 template <>
 struct ProgramStateTrait<DynamicTypeMap>
-    : public ProgramStatePartialTrait<DynamicTypeMapImpl> {
+    : public ProgramStatePartialTrait<DynamicTypeMapTy> {
   static void *GDMIndex();
 };
 
 /// Get dynamic type information for a region.
 DynamicTypeInfo getDynamicTypeInfo(ProgramStateRef State,
                                    const MemRegion *Reg);
 
 /// Set dynamic type information of the region; return the new state.
 ProgramStateRef setDynamicTypeInfo(ProgramStateRef State, const MemRegion *Reg,
                                    DynamicTypeInfo NewTy);
 
 /// Set dynamic type information of the region; return the new state.
 inline ProgramStateRef setDynamicTypeInfo(ProgramStateRef State,
                                           const MemRegion *Reg, QualType NewTy,
                                           bool CanBeSubClassed = true) {
   return setDynamicTypeInfo(State, Reg,
                             DynamicTypeInfo(NewTy, CanBeSubClassed));
 }
 
-void printDynamicTypeInfo(ProgramStateRef State, raw_ostream &Out,
-                          const char *NL, const char *Sep);
+void printDynamicTypeInfo(raw_ostream &Out, ProgramStateRef State,
+                          const char *NL = "\n", const char *Sep = "",
+                          unsigned int Space = 0);
 
 } // namespace ento
 } // namespace clang
 
 #endif // LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_DYNAMICTYPEMAP_H

clang/lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp

public:
   /// This value is set to true, when the Generics checker is turned on.
   DefaultBool CheckGenerics;
 };
 } // end anonymous namespace
 
 void DynamicTypePropagation::checkDeadSymbols(SymbolReaper &SR,
                                               CheckerContext &C) const {
   ProgramStateRef State = C.getState();
-  DynamicTypeMapImpl TypeMap = State->get<DynamicTypeMap>();
-  for (DynamicTypeMapImpl::iterator I = TypeMap.begin(), E = TypeMap.end();
+  DynamicTypeMapTy TypeMap = State->get<DynamicTypeMap>();
+  for (DynamicTypeMapTy::iterator I = TypeMap.begin(), E = TypeMap.end();
        I != E; ++I) {
     if (!SR.isLiveRegion(I->first)) {
       State = State->remove<DynamicTypeMap>(I->first);
     }
   }
 
   MostSpecializedTypeArgsMapTy TyArgMap =
       State->get<MostSpecializedTypeArgsMap>();

clang/lib/StaticAnalyzer/Core/DynamicTypeMap.cpp

 //===- DynamicTypeMap.cpp - Dynamic Type Info related APIs ----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines APIs that track and query dynamic type information. This
 //  information can be used to devirtualize calls during the symbolic execution
 //  or do type checking.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/StaticAnalyzer/Core/PathSensitive/DynamicTypeMap.h"
+#include "clang/Basic/JsonSupport.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SymExpr.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 

 ProgramStateRef setDynamicTypeInfo(ProgramStateRef State, const MemRegion *Reg,
                                    DynamicTypeInfo NewTy) {
   Reg = Reg->StripCasts();
   ProgramStateRef NewState = State->set<DynamicTypeMap>(Reg, NewTy);
   assert(NewState);
   return NewState;
 }
 
-void printDynamicTypeInfo(ProgramStateRef State, raw_ostream &Out,
-                          const char *NL, const char *Sep) {
-  bool First = true;
-  for (const auto &I : State->get<DynamicTypeMap>()) {
-    if (First) {
-      Out << NL << "Dynamic types of regions:" << NL;
-      First = false;
-    }
+void printDynamicTypeInfo(raw_ostream &Out, ProgramStateRef State,
+                          const char *NL, const char *Sep, unsigned int Space) {
+  Indent(Out, Space)
+      << "\"dynamic_types\": { \"title\": \"Dynamic types\", \"items\": ";
+
+  const DynamicTypeMapTy &DTM = State->get<DynamicTypeMap>();
+  if (DTM.isEmpty()) {
+    Out << "null }," << NL;
+    return;
+
+  ++Space;
+  Out << '[' << NL;
+  for (const auto &I : DTM) {
     const MemRegion *MR = I.first;
     const DynamicTypeInfo &DTI = I.second;
-    Out << MR << " : ";
+    Out << "{ \"region\": \"" << MR << "\", \"dyn_type\": \"";
     if (DTI.isValid()) {
-      Out << DTI.getType()->getPointeeType().getAsString();
-      if (DTI.canBeASubClass()) {
-        Out << " (or its subclass)";
-      }
+      Out << DTI.getType()->getPointeeType().getAsString()
+          << "\" \"sub_classable\": "
+          << (DTI.canBeASubClass() ? "true" : "false");
     } else {
-      Out << "Invalid type info";
+      Out << "null"; // Invalid type info
     }
-    Out << NL;
+    Out << "\" }," << NL;
   }
+  --Space;
+  Indent(Out, Space) << "]}," << NL;
 }
 
 void *ProgramStateTrait<DynamicTypeMap>::GDMIndex() {
   static int index = 0;
   return &index;
 }
 
 } // namespace ento
 } // namespace clang

clang/lib/StaticAnalyzer/Core/ProgramState.cpp

void ProgramState::print(raw_ostream &Out, const LocationContext *LCtx,
 
   // Print out the environment.
   Env.print(Out, Context, LCtx, NL, Sep, Space);
 
   // Print out the constraints.
   Mgr.getConstraintManager().print(Out, this, NL, Sep, Space);
 
   // Print out the tracked dynamic types.
-  printDynamicTypeInfo(this, Out, NL, Sep);
+  printDynamicTypeInfo(Out, this, NL, Sep, Space);
 
   // Print checker-specific data.
   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);

clang/test/Analysis/expr-inspection.c

 // CHECK-NEXT: ]},
 // 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-NEXT: "constraints": { "title": "Constraints", "items": [
 // CHECK-NEXT:   { "name": "reg_$0<int x>", "value": "{ [-2147483648, 13] }" },
-// CHECK-NEXT: ]}
-
+// CHECK-NEXT: ]},
+// CHECK-NEXT: "dynamic_types": { "title": "Dynamic types", "items": null },