[analyzer][NFC] Refactor functions in PlistDiagnostics to take AnalyzerOptions as parameter

[Szelethus]

Summary

I intend to add a new flag macro-expnasions-as-events, and unfortunately I'll only be able to convert the macro piece into an event one once I'm about to emit it, due to the lack of an avaible Preprocessor object in the BugReporter.

[NoQ]

Fair enough!

lib/StaticAnalyzer/Core/PlistDiagnostics.cpp

306–307

Maybe just make this function non-static instead of passing members around manually?

315–316

And this.

[Szelethus]

lib/StaticAnalyzer/Core/PlistDiagnostics.cpp

306–307

That would probably be super-invasive for this file, from what I'm seeing. I might end up doing that, but this would mean pretty much a complete refactoring.

To be honest, almost all functions here should be a method, the output stream, FIDMap, Preprocessor, AnalyzerOptions could all be left out.

[Szelethus]

I'll probably do something with this parameter spaghetti, it bothers me too, but maybe in a separate patch :)

lib/StaticAnalyzer/Core/PlistDiagnostics.cpp

 using namespace clang;
 using namespace ento;
 using namespace markup;
 
 namespace {
   class PlistDiagnostics : public PathDiagnosticConsumer {
     const std::string OutputFile;
     const Preprocessor &PP;
+    AnalyzerOptions &AnOpts;
     const bool SupportsCrossFileDiagnostics;
-    const bool SerializeStatistics;
   public:
     PlistDiagnostics(AnalyzerOptions &AnalyzerOpts,
                      const std::string& prefix,
                      const Preprocessor &PP,
                      bool supportsMultipleFiles);
 
     ~PlistDiagnostics() override {}
 
public:
     }
   };
 } // end anonymous namespace
 
 PlistDiagnostics::PlistDiagnostics(AnalyzerOptions &AnalyzerOpts,
                                    const std::string& output,
                                    const Preprocessor &PP,
                                    bool supportsMultipleFiles)
-  : OutputFile(output), PP(PP),
-    SupportsCrossFileDiagnostics(supportsMultipleFiles),
-    SerializeStatistics(AnalyzerOpts.shouldSerializeStats()) {}
+  : OutputFile(output), PP(PP), AnOpts(AnalyzerOpts),
+    SupportsCrossFileDiagnostics(supportsMultipleFiles) {}
 
 void ento::createPlistDiagnosticConsumer(AnalyzerOptions &AnalyzerOpts,
                                          PathDiagnosticConsumers &C,
                                          const std::string& s,
                                          const Preprocessor &PP) {
-  C.push_back(new PlistDiagnostics(AnalyzerOpts, s, PP, false));
+  C.push_back(new PlistDiagnostics(AnalyzerOpts, s, PP,
+                                   /*supportsMultipleFiles*/ false));
 }
 
 void ento::createPlistMultiFileDiagnosticConsumer(AnalyzerOptions &AnalyzerOpts,
                                                   PathDiagnosticConsumers &C,
                                                   const std::string &s,
                                                   const Preprocessor &PP) {
-  C.push_back(new PlistDiagnostics(AnalyzerOpts, s, PP, true));
+  C.push_back(new PlistDiagnostics(AnalyzerOpts, s, PP,
+                                   /*supportsMultipleFiles*/ true));
 }
 
 static void EmitRanges(raw_ostream &o,
                        const ArrayRef<SourceRange> Ranges,
                        const FIDMap& FM,
                        const Preprocessor &PP,
                        unsigned indent) {
 
if (!s.empty()) {
     Indent(o, indent) << "<key>alternate</key>";
     EmitString(o, s) << '\n';
   }
 
   --indent;
   Indent(o, indent) << "</dict>\n";
 }
 
-static void ReportEvent(raw_ostream &o, const PathDiagnosticEventPiece& P,
+static void ReportEvent(raw_ostream &o,
+                        const PathDiagnosticEventPiece& P,
                         const FIDMap& FM,
                         const Preprocessor &PP,
                         unsigned indent,
                         unsigned depth,
                         bool isKeyEvent = false) {
 
   const SourceManager &SM = PP.getSourceManager();
 
static void ReportEvent(raw_ostream &o,
   --indent;
   Indent(o, indent); o << "</dict>\n";
 }
 
 static void ReportPiece(raw_ostream &o,
                         const PathDiagnosticPiece &P,
                         const FIDMap& FM, 
                         const Preprocessor &PP,
+                        AnalyzerOptions &AnOpts,
                         unsigned indent,
                         unsigned depth,
                         bool includeControlFlow,
                         bool isKeyEvent = false);
 
 static void ReportCall(raw_ostream &o,
                        const PathDiagnosticCallPiece &P,
                        const FIDMap& FM,
                        const Preprocessor &PP,
+                       AnalyzerOptions &AnOpts,
                        unsigned indent,
                        unsigned depth) {
 
   if (auto callEnter = P.getCallEnterEvent())
-    ReportPiece(o, *callEnter, FM, PP, indent, depth,
+    ReportPiece(o, *callEnter, FM, PP, AnOpts, indent, depth,
                 /*includeControlFlow*/ true, P.isLastInMainSourceFile());
 
 
   ++depth;
 
   if (auto callEnterWithinCaller = P.getCallEnterWithinCallerEvent())
-    ReportPiece(o, *callEnterWithinCaller, FM, PP, indent, depth,
+    ReportPiece(o, *callEnterWithinCaller, FM, PP, AnOpts, indent, depth,
                 /*includeControlFlow*/ true);
 
   for (PathPieces::const_iterator I = P.path.begin(), E = P.path.end();I!=E;++I)
-    ReportPiece(o, **I, FM, PP, indent, depth,
+    ReportPiece(o, **I, FM, PP, AnOpts, indent, depth,
                 /*includeControlFlow*/ true);
 
   --depth;
 
   if (auto callExit = P.getCallExitEvent())
-    ReportPiece(o, *callExit, FM, PP, indent, depth,
+    ReportPiece(o, *callExit, FM, PP, AnOpts, indent, depth,
                 /*includeControlFlow*/ true);
 }
 
 static void ReportMacro(raw_ostream &o,
                         const PathDiagnosticMacroPiece& P,
                         const FIDMap& FM,
                         const Preprocessor &PP,
+                        AnalyzerOptions &AnOpts,
                         unsigned indent,
                         unsigned depth) {
 
   for (PathPieces::const_iterator I = P.subPieces.begin(), E=P.subPieces.end();
        I!=E; ++I) {
-    ReportPiece(o, **I, FM, PP, indent, depth, /*includeControlFlow*/ false);
+    ReportPiece(o, **I, FM, PP, AnOpts, indent, depth,
+                /*includeControlFlow*/ false);
   }
 }
 
 static void ReportNote(raw_ostream &o, const PathDiagnosticNotePiece& P,
                         const FIDMap& FM,
                         const Preprocessor &PP,
-                        unsigned indent,
-                        unsigned depth) {
+                        unsigned indent) {
 
   const SourceManager &SM = PP.getSourceManager();
 
   Indent(o, indent) << "<dict>\n";
   ++indent;
 
   // Output the location.
   FullSourceLoc L = P.getLocation().asLocation();
 
   Indent(o, indent) << "<key>location</key>\n";
   EmitLocation(o, SM, L, FM, indent);
 
   // Output the ranges (if any).
   ArrayRef<SourceRange> Ranges = P.getRanges();
   EmitRanges(o, Ranges, FM, PP, indent);
 
   // Output the text.
   EmitMessage(o, P.getString(), indent);
 
   // Finish up.
   --indent;
   Indent(o, indent); o << "</dict>\n";
 }
 
-static void ReportDiag(raw_ostream &o, const PathDiagnosticPiece& P,
-                       const FIDMap& FM, const Preprocessor &PP) {
-  ReportPiece(o, P, FM, PP, /*indent*/ 4, /*depth*/ 0,
+static void ReportDiag(raw_ostream &o,
+                       const PathDiagnosticPiece& P,
+                       const FIDMap& FM,
+                       const Preprocessor &PP,
+                       AnalyzerOptions &AnOpts) {
+  ReportPiece(o, P, FM, PP, AnOpts, /*indent*/ 4, /*depth*/ 0,
               /*includeControlFlow*/ true);
 }
 
 static void ReportPiece(raw_ostream &o,
                         const PathDiagnosticPiece &P,
                         const FIDMap& FM,
                         const Preprocessor &PP,
+                        AnalyzerOptions &AnOpts,
                         unsigned indent,
                         unsigned depth,
                         bool includeControlFlow,
                         bool isKeyEvent) {
   switch (P.getKind()) {
     case PathDiagnosticPiece::ControlFlow:
       if (includeControlFlow)
         ReportControlFlow(o, cast<PathDiagnosticControlFlowPiece>(P), FM, PP,
                           indent);
       break;
     case PathDiagnosticPiece::Call:
-      ReportCall(o, cast<PathDiagnosticCallPiece>(P), FM, PP, indent, depth);
+      ReportCall(o, cast<PathDiagnosticCallPiece>(P), FM, PP, AnOpts, indent,
+                 depth);
       break;
     case PathDiagnosticPiece::Event:
       ReportEvent(o, cast<PathDiagnosticEventPiece>(P), FM, PP, indent, depth,
                   isKeyEvent);
       break;
     case PathDiagnosticPiece::Macro:
-      ReportMacro(o, cast<PathDiagnosticMacroPiece>(P), FM, PP, indent, depth);
+      ReportMacro(o, cast<PathDiagnosticMacroPiece>(P), FM, PP, AnOpts, indent,
+                  depth);
       break;
     case PathDiagnosticPiece::Note:
-      ReportNote(o, cast<PathDiagnosticNotePiece>(P), FM, PP, indent, depth);
+      ReportNote(o, cast<PathDiagnosticNotePiece>(P), FM, PP, indent);
       break;
   }
 }
 
 /// Print coverage information to output stream {@code o}.
 /// May modify the used list of files {@code Fids} by inserting new ones.
 static void printCoverage(const PathDiagnostic *D,
                           unsigned InputIndentLevel,
for (std::vector<const PathDiagnostic*>::iterator DI=Diags.begin(),
 
     PathPieces::const_iterator I = Path.begin();
 
     if (FirstNonNote != Path.begin()) {
       o << "   <key>notes</key>\n"
            "   <array>\n";
 
       for (; I != FirstNonNote; ++I)
-        ReportDiag(o, **I, FM, PP);
+        ReportDiag(o, **I, FM, PP, AnOpts);
 
       o << "   </array>\n";
     }
 
     o << "   <key>path</key>\n";
 
     o << "   <array>\n";
 
     for (PathPieces::const_iterator E = Path.end(); I != E; ++I)
-      ReportDiag(o, **I, FM, PP);
+      ReportDiag(o, **I, FM, PP, AnOpts);
 
     o << "   </array>\n";
 
     // Output the bug type and bug category.
     o << "   <key>description</key>";
     EmitString(o, D->getShortDescription()) << '\n';
     o << "   <key>category</key>";
     EmitString(o, D->getCategory()) << '\n';
void PlistDiagnostics::FlushDiagnosticsImpl(
   o << " </array>\n";
 
   o << " <key>files</key>\n"
        " <array>\n";
   for (FileID FID : Fids)
     EmitString(o << "  ", SM.getFileEntryForID(FID)->getName()) << '\n';
   o << " </array>\n";
 
-  if (llvm::AreStatisticsEnabled() && SerializeStatistics) {
+  if (llvm::AreStatisticsEnabled() && AnOpts.shouldSerializeStats()) {
     o << " <key>statistics</key>\n";
     std::string stats;
     llvm::raw_string_ostream os(stats);
     llvm::PrintStatisticsJSON(os);
     os.flush();
     EmitString(o, html::EscapeText(stats)) << '\n';
   }
 
   // Finish.
   o << "</dict>\n</plist>";
 }