[AST] Ensure that an empty json file is generated if compile errors

[njames93]

Are there any tests that ensure something is always outputted?

[steveire]

In D98827#2635303, @njames93 wrote:

Are there any tests that ensure something is always outputted?

The test verifies that the generated c++ either gives no introspection data or introspection data which the test expects.

Thats the best we can do currently because there are lots of cases where we don't know whether dummy data of valid data will be generated.

clang/lib/Tooling/DumpTool/ASTSrcLocProcessor.h

 class ASTSrcLocProcessor : public ast_matchers::MatchFinder::MatchCallback {
 public:
   explicit ASTSrcLocProcessor(StringRef JsonPath);
 
   std::unique_ptr<ASTConsumer> createASTConsumer(CompilerInstance &Compiler,
                                                  StringRef File);
 
   void generate();
+  void generateEmpty();
 
 private:
   void run(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
   llvm::StringMap<StringRef> ClassInheritance;
   llvm::StringMap<std::vector<StringRef>> ClassesInClade;
   llvm::StringMap<ClassData> ClassEntries;
 
   std::string JsonPath;
   std::unique_ptr<clang::ast_matchers::MatchFinder> Finder;
 };
 
 } // namespace tooling
 } // namespace clang
 
 #endif

clang/lib/Tooling/DumpTool/ASTSrcLocProcessor.cpp

llvm::json::Object toJSON(llvm::StringMap<ClassData> const &Obj) {
   llvm::json::Object JsonObj;
   for (const auto &Item : Obj) {
     if (!Item.second.isEmpty())
       JsonObj[Item.first()] = ::toJSON(Item.second);
   }
   return JsonObj;
 }
 
-void WriteJSON(std::string JsonPath,
-               llvm::StringMap<StringRef> const &ClassInheritance,
-               llvm::StringMap<std::vector<StringRef>> const &ClassesInClade,
-               llvm::StringMap<ClassData> const &ClassEntries) {
+void WriteJSON(std::string JsonPath, llvm::json::Object &&ClassInheritance,
+               llvm::json::Object &&ClassesInClade,
+               llvm::json::Object &&ClassEntries) {
   llvm::json::Object JsonObj;
 
   using llvm::json::toJSON;
 
-  JsonObj["classInheritance"] = ::toJSON(ClassInheritance);
-  JsonObj["classesInClade"] = ::toJSON(ClassesInClade);
-  JsonObj["classEntries"] = ::toJSON(ClassEntries);
+  JsonObj["classInheritance"] = std::move(ClassInheritance);
+  JsonObj["classesInClade"] = std::move(ClassesInClade);
+  JsonObj["classEntries"] = std::move(ClassEntries);
 
   std::error_code EC;
   llvm::raw_fd_ostream JsonOut(JsonPath, EC, llvm::sys::fs::F_Text);
   if (EC)
     return;
 
   llvm::json::Value JsonVal(std::move(JsonObj));
   JsonOut << formatv("{0:2}", JsonVal);
 }
 
 void ASTSrcLocProcessor::generate() {
-  WriteJSON(JsonPath, ClassInheritance, ClassesInClade, ClassEntries);
+  WriteJSON(JsonPath, ::toJSON(ClassInheritance), ::toJSON(ClassesInClade),
+            ::toJSON(ClassEntries));
 }
 
+void ASTSrcLocProcessor::generateEmpty() { WriteJSON(JsonPath, {}, {}, {}); }
+
 std::vector<std::string>
 CaptureMethods(std::string TypeString, const clang::CXXRecordDecl *ASTClass,
                const MatchFinder::MatchResult &Result) {
 
   auto publicAccessor = [](auto... InnerMatcher) {
     return cxxMethodDecl(isPublic(), parameterCountIs(0), isConst(),
                          InnerMatcher...);
   };

clang/lib/Tooling/DumpTool/ClangSrcLocDump.cpp

static cl::opt<std::string> JsonOutputPath("json-output-path",
                                            cl::desc("json output path"),
                                            cl::Required,
                                            cl::value_desc("path"));
 
 class ASTSrcLocGenerationAction : public clang::ASTFrontendAction {
 public:
   ASTSrcLocGenerationAction() : Processor(JsonOutputPath) {}
 
-  ~ASTSrcLocGenerationAction() { Processor.generate(); }
+  void ExecuteAction() override {
+    clang::ASTFrontendAction::ExecuteAction();
+    if (getCompilerInstance().getDiagnostics().getNumErrors() > 0)
+      Processor.generateEmpty();
+    else
+      Processor.generate();
+  }
 
   std::unique_ptr<clang::ASTConsumer>
   CreateASTConsumer(clang::CompilerInstance &Compiler,
                     llvm::StringRef File) override {
     return Processor.createASTConsumer(Compiler, File);
   }
 
 private: