[analyzer] NFC: Move path diagnostic consumer implementations to libAnalysis.

[NoQ]

Summary

We're finally more or less ready to allow users outside of the Static Analyzer to take advantage of path diagnostic consumers for emitting their warnings in different formats. I didn't really try to do that in practice, but most of the necessary APIs should be at least available now.

I'm not planning to convert Clang-Tidy to use these APIs directly because i understand that they're more complicated than Clang-Tidy really needs them to be. I'll either simplify these APIs (if they indeed can be simplified) or (more likely) introduce a convenient wrapper for easily building path diagnostics.

I'm not sure about renaming these classes to get rid of the "Path" prefix. These diagnostics aren't necessarily displaying the path (and they never did), but they're flexible enough for displaying paths and that's still the primary difference between our path diagnostics and ordinary diagnostics. Also if we just call them "Diagnostics" it'll be too generic and hard to distinguish from the Clang diagnostic engine. Suggestions are welcome :)

[gribozavr]

clang/include/clang/Analysis/PathDiagnosticConsumers.h

39

Does this code declare e.g., createPlistDiagnosticConsumer? That function is defined in libStaticAnalyzer. Declaring it libAnalysis is not appropriate, and effectively introduces a layering violation. Users who link against libAnalysis will get link errors if they don't link against libStaticAnalyzer.

[NoQ]

clang/include/clang/Analysis/PathDiagnosticConsumers.h

39

Oh crap, i forgot to move them.

[NoQ]

Hmm, does anybody want me to write an example tool that emits path diagnostics but doesn't link to libStaticAnalyzer*?

[NoQ]

Unforget to actually move the consumer implementations to libAnalysis, not just their headers.

Casually rename ClangDiagPathDiagConsumer to TextDiagnostics according to the local naming tradition.

[gribozavr]

clang/include/clang/Analysis/PathDiagnosticConsumers.def

23

80 columns?

clang/include/clang/Analysis/PathDiagnosticConsumers.h

38

Maybe not quite an appropriate comment for this patch, but I just realized that this factory function returns void, which confused me -- where does the new consumer go? Only after reading an implementation of one of these functions I understood that they add the new consumer to C, which is a vector (whose type is conveniently hidden by a typedef -- why?)

I'd suggest to make these factories more like factories, and make them return a unique_ptr that the caller can put wherever they need. Of course, in a separate patch.

I'd also suggest to remove the PathDiagnosticConsumers typedef altogether. It is used just a couple of times in the code, and obfuscates code more than it helps.

clang/lib/Analysis/PlistHTMLDiagnostics.cpp

27 ↗

(On Diff #219829)

Passing it by value would have made it less subtle, and probably as efficient.

clang/lib/Analysis/TextDiagnostics.cpp

23 ↗

(On Diff #219829)

"TextDiagnosticsConsumer"

Or even better, "TextPathDiagnosticsConsumer".

Same for the file name. Same for other files that define diagnostics consumers.

Clarity is really important here. Very few places in the code will mention this type by name, however, it is really important to distinguish this diagnostics infrastructure from the rest of Clang's diagnostics.

I'm also starting to wonder whether this diagnostics infrastructure should be in its own library, not in libAnalysis -- what do you think?

[Szelethus]

In D67422#1667079, @NoQ wrote:

Casually rename ClangDiagPathDiagConsumer to TextDiagnostics according to the local naming tradition.

Yoink. You could be facing a rebasing nightmare here :)

[NoQ]

Aaaaand rebase. Addressed comments. With @Szelethus's refactoring work the patch actually looks much cleaner than it used to. One bit that's not directly related but i decided to keep it from the original patch was moving the plist-html diagnostic builder function into its own file.

[NoQ]

clang/include/clang/Analysis/PathDiagnosticConsumers.h

38

Will do!

clang/lib/Analysis/TextDiagnostics.cpp

23 ↗

(On Diff #219829)

Renamed all the stuff.

I'm also starting to wonder whether this diagnostics infrastructure should be in its own library, not in libAnalysis -- what do you think?

Maybe! libAnalysis is currently a mess; it's basically a collection of all static-analyzer-ish things that are also used outside of the static analyzer. That's indeed not a good definition for a library. It incorporates a number of completely unrelated things.

[Szelethus]

In D67422#2192407, @NoQ wrote:

One bit that's not directly related but i decided to keep it from the original patch was moving the plist-html diagnostic builder function into its own file.

That is a great call indeed.

I'm also starting to wonder whether this diagnostics infrastructure should be in its own library, not in libAnalysis -- what do you think?

Maybe! libAnalysis is currently a mess; it's basically a collection of all static-analyzer-ish things that are also used outside of the static analyzer. That's indeed not a good definition for a library. It incorporates a number of completely unrelated things.

Not to mention my new plugins were knocked around all over the place, and eventually they also landed in it. I think libAnalysis is indeed well overdue for a revision, maybe sooner rather then later. There aren't too many other changes in this patch, maybe its worth doing this right away? I don't insist.

[vsavchenko]

Other than parameter names, it looks totally reasonable to me.

clang/lib/Analysis/HTMLPathDiagnosticConsumer.cpp

69

Maybe while we are here, we can change the names to match the code style (aka capitalize)?
It seems like all other functions have similar problems. It's no biggie, but still...

NOTE: I really wanted to try this new feature of Phabricator 😊

clang/lib/Analysis/PlistHTMLPathDiagnosticConsumer.cpp

26

As long as it is a new function, I guess we should definitely keep names according to the Coding Standards

[NoQ]

Fxd.

clang/lib/Analysis/PlistHTMLPathDiagnosticConsumer.cpp

26

It's not new but sure!

[vsavchenko]

clang/lib/Analysis/TextPathDiagnosticConsumer.cpp

1

TextPathDiagnosticConsumer.cpp?

35

TextPathDiagnosticConsumer?

[NoQ]

Whoops fxd!

[NoQ]

clang/lib/Analysis/PlistHTMLPathDiagnosticConsumer.cpp

28–32

I just realized that this code creates 5 consumers: 1 html consumer, 1 plist consumer, 3 text consumers. This isn't a regression due to this patch... but damn!

[Szelethus]

The patch looks great. I guess the only remaining discussion remains as to whether this should be in libAnalysis, or somewhere else. Here is my take: Since clang-tidy, CSA, and some other parts of the compiler (like uninitialized variable warnings) are static analyzers within the same infrastructure, it makes sense for them to have a common library. I see that diagnostics aren't really analyses. libFrontend or libDriver, which, as I understand it contains most the diagnostics machinery for clang aren't viable alternatives because of the library dependencies. So, I think if libAnalysis was called libStaticAnalysisCommon, we would be golden, but that would screw over downstream developers for negligible gain. While I'm not terribly experiences in library layout design, for the time being, the move to libAnalysis seems appropriate.

I see that we're still heavily tied to StaticAnalyzer headers. Doesn't that violate the module system, as libAnalysis is a dependency of libStaticAnalyzerCore? AnalyzerOptions and AnalysisConsumer (that last one in particular) seem deeply integrated into these consumers.

clang/lib/Analysis/PlistHTMLPathDiagnosticConsumer.cpp

28–32

Oh wow. That is definitely my mistake. The issue is that detailed diagnostics (-analyzer-output=text) and the minimal one (analyzer-output=text-minimal) should be mutually exclusive. I'll try to think about a solution. Maybe some Profile thing might work.

[vsavchenko]

Awesome, looks great!

[NoQ]

In D67422#2215371, @Szelethus wrote:

The patch looks great. I guess the only remaining discussion remains as to whether this should be in libAnalysis, or somewhere else. Here is my take: Since clang-tidy, CSA, and some other parts of the compiler (like uninitialized variable warnings) are static analyzers within the same infrastructure, it makes sense for them to have a common library. I see that diagnostics aren't really analyses. libFrontend or libDriver, which, as I understand it contains most the diagnostics machinery for clang aren't viable alternatives because of the library dependencies. So, I think if libAnalysis was called libStaticAnalysisCommon, we would be golden, but that would screw over downstream developers for negligible gain. While I'm not terribly experiences in library layout design, for the time being, the move to libAnalysis seems appropriate.

I agree that there's something here and also that it's not that urgent/critical to rename things at this point. It's not that people suffer horribly from having to link to only some of these things.

I see that we're still heavily tied to StaticAnalyzer headers. Doesn't that violate the module system, as libAnalysis is a dependency of libStaticAnalyzerCore? AnalyzerOptions and AnalysisConsumer (that last one in particular) seem deeply integrated into these consumers.

Mmm, these are dead includes now. Reliance on AnalyzerOptions was supposed to be eliminated since D67420 and these are in fact rebase conflicts. Fxd.

[NoQ]

clang/lib/Analysis/SarifPathDiagnosticConsumer.cpp

310

This thing still worries me but this definitely isn't a link-time dependency.

[Szelethus]

clang/lib/Analysis/SarifPathDiagnosticConsumer.cpp

310

D53277#1285757, rGb8cfcc71469d40a98f4cc79fcdc46cd67bea45f7

[Szelethus]

Unless anyone else objects, I'm happy to see this landed! Nice work! ^-^

[Szelethus]

In D67422#2216137, @NoQ wrote:

I agree that there's something here and also that it's not that urgent/critical to rename things at this point. It's not that people suffer horribly from having to link to only some of these things.

In the long run, if we end up piling more of the common stuff in libAnalysis, it might be worth to create a new library.

[NoQ]

clang/lib/Analysis/SarifPathDiagnosticConsumer.cpp

310

Ok, what's the proper solution here? This is clearly a layering violation now; this generic diagnostic consumer shouldn't know anything about the Static Analyzer specifically. I guess we could separate it into an independent polymorphic object ("DescriptionGetter" or something like that) that the Static Analyzer would instantiate manually. Or ideally we could ship this information with the bug report itself.

I'll add a FIXME and try to reproduce potential modules problems locally.

[Szelethus]

clang/lib/Analysis/SarifPathDiagnosticConsumer.cpp

310

I am puzzled myself :/ Maybe we could ask @aaron.ballman, since he landed most of these changes back in the day?

[NoQ]

clang/lib/Analysis/SarifPathDiagnosticConsumer.cpp

310

I fixed a couple other bugs that caused modules build to fail before pushing but this one wasn't a problem.

[aaron.ballman]

clang/lib/Analysis/SarifPathDiagnosticConsumer.cpp

310

The original code was added because it's needed for the required SARIF output. At the time, it didn't seem like it was a layering violation because the SARIF output was limited to just the clang static analyzer diagnostics -- however, I agree that work needs to be done here now. For instance, one of the issues with the SARIF output is that it only captures output from the static analyzer and doesn't report diagnostics from Clang itself, IIRC. We'll need to solve this for clang-tidy diagnostics as well.

[NoQ]

This patch hasn't landed yet (reverted every time due to circular dependencies(?)). I plan to split it up into smaller patches as I rebase because rebase is already very painful.

[NoQ]

Abandon in favor of splitting up.

clang/include/clang/Analysis/PathDiagnosticConsumers.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHDIAGNOSTICCONSUMERS_H
 #define LLVM_CLANG_STATICANALYZER_CORE_PATHDIAGNOSTICCONSUMERS_H
 
 #include <string>
 #include <vector>
 
+#include "clang/Analysis/PathDiagnostic.h"
+
 namespace clang {
 
 class AnalyzerOptions;
 class Preprocessor;
 namespace cross_tu {
 class CrossTranslationUnitContext;
 }
 
 namespace ento {
 
 class PathDiagnosticConsumer;
-typedef std::vector<PathDiagnosticConsumer*> PathDiagnosticConsumers;
+typedef std::vector<PathDiagnosticConsumer *> PathDiagnosticConsumers;
 
 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATEFN)                    \
   void CREATEFN(PathDiagnosticConsumerOptions Diagopts,                        \
                 PathDiagnosticConsumers &C, const std::string &Prefix,         \
                 const Preprocessor &PP,                                        \
                 const cross_tu::CrossTranslationUnitContext &CTU);
-#include "clang/StaticAnalyzer/Core/Analyses.def"
+#include "clang/Analysis/PathDiagnosticConsumers.def"
 
 } // end 'ento' namespace
 } // end 'clang' namespace
 
 #endif

clang/include/clang/Analysis/PathDiagnosticConsumers.def

-//===-- Analyses.def - Metadata about Static Analyses -----------*- C++ -*-===//
+//===-- PathDiagnosticConsumers.def - Visualizing warnings ------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
-//  This file defines the set of static analyses used by AnalysisConsumer.
+// This file defines the set of path diagnostic consumers - objects that
+// implement different representations of static analysis results.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef ANALYSIS_STORE
-#define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN)
-#endif
-
-ANALYSIS_STORE(RegionStore, "region", "Use region-based analyzer store",
-               CreateRegionStoreManager)
-
-#ifndef ANALYSIS_CONSTRAINTS
-#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN)
-#endif
-
-ANALYSIS_CONSTRAINTS(RangeConstraints, "range",
-                     "Use constraint tracking of concrete value ranges",
-                     CreateRangeConstraintManager)
-
-ANALYSIS_CONSTRAINTS(Z3Constraints, "z3", "Use Z3 contraint solver",
-                     CreateZ3ConstraintManager)
-
 #ifndef ANALYSIS_DIAGNOSTICS
 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATEFN)
 #endif
 
 ANALYSIS_DIAGNOSTICS(HTML, "html", "Output analysis results using HTML",
                      createHTMLDiagnosticConsumer)
 
 ANALYSIS_DIAGNOSTICS(
     HTML_SINGLE_FILE, "html-single-file",
     "Output analysis results using HTML (not allowing for multi-file bugs)",
     createHTMLSingleFileDiagnosticConsumer)
 
 ANALYSIS_DIAGNOSTICS(PLIST, "plist", "Output analysis results using Plists",
                      createPlistDiagnosticConsumer)
 
 ANALYSIS_DIAGNOSTICS(
     PLIST_MULTI_FILE, "plist-multi-file",
     "Output analysis results using Plists (allowing for multi-file bugs)",
ANALYSIS_DIAGNOSTICS(TEXT, "text", "Text output of analysis results to stderr",
                      createTextPathDiagnosticConsumer)
 
 ANALYSIS_DIAGNOSTICS(TEXT_MINIMAL, "text-minimal",
                      "Emits minimal diagnostics to stderr, stating only the "
                      "warning message and the associated notes. Usually "
                      "used in addition to other analysis types",
                      createTextMinimalPathDiagnosticConsumer)
 
-#ifndef ANALYSIS_PURGE
-#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC)
-#endif
-
-ANALYSIS_PURGE(
-    PurgeStmt, "statement",
-    "Purge symbols, bindings, and constraints before every statement")
-
-ANALYSIS_PURGE(
-    PurgeBlock, "block",
-    "Purge symbols, bindings, and constraints before every basic block")
-
-ANALYSIS_PURGE(PurgeNone, "none",
-               "Do not purge symbols, bindings, or constraints")
-
-#ifndef ANALYSIS_INLINING_MODE
-#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC)
-#endif
-
-ANALYSIS_INLINING_MODE(All, "all", "Analyze all functions as top level")
-
-ANALYSIS_INLINING_MODE(
-    NoRedundancy, "noredundancy",
-    "Do not analyze a function which has been previously inlined")
-
-#undef ANALYSIS_STORE
-#undef ANALYSIS_CONSTRAINTS
 #undef ANALYSIS_DIAGNOSTICS
-#undef ANALYSIS_PURGE
-#undef ANALYSIS_INLINING_MODE
-#undef ANALYSIS_IPA

clang/include/clang/StaticAnalyzer/Core/Analyses.def

 
 ANALYSIS_CONSTRAINTS(RangeConstraints, "range",
                      "Use constraint tracking of concrete value ranges",
                      CreateRangeConstraintManager)
 
 ANALYSIS_CONSTRAINTS(Z3Constraints, "z3", "Use Z3 contraint solver",
                      CreateZ3ConstraintManager)
 
-#ifndef ANALYSIS_DIAGNOSTICS
-#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATEFN)
-#endif
-
-ANALYSIS_DIAGNOSTICS(HTML, "html", "Output analysis results using HTML",
-                     createHTMLDiagnosticConsumer)
-
-ANALYSIS_DIAGNOSTICS(
-    HTML_SINGLE_FILE, "html-single-file",
-    "Output analysis results using HTML (not allowing for multi-file bugs)",
-    createHTMLSingleFileDiagnosticConsumer)
-
-ANALYSIS_DIAGNOSTICS(PLIST, "plist", "Output analysis results using Plists",
-                     createPlistDiagnosticConsumer)
-
-ANALYSIS_DIAGNOSTICS(
-    PLIST_MULTI_FILE, "plist-multi-file",
-    "Output analysis results using Plists (allowing for multi-file bugs)",
-    createPlistMultiFileDiagnosticConsumer)
-
-ANALYSIS_DIAGNOSTICS(PLIST_HTML, "plist-html",
-                     "Output analysis results using HTML wrapped with Plists",
-                     createPlistHTMLDiagnosticConsumer)
-
-ANALYSIS_DIAGNOSTICS(SARIF, "sarif", "Output analysis results in a SARIF file",
-                     createSarifDiagnosticConsumer)
-
-ANALYSIS_DIAGNOSTICS(TEXT, "text", "Text output of analysis results to stderr",
-                     createTextPathDiagnosticConsumer)
-
-ANALYSIS_DIAGNOSTICS(TEXT_MINIMAL, "text-minimal",
-                     "Emits minimal diagnostics to stderr, stating only the "
-                     "warning message and the associated notes. Usually "
-                     "used in addition to other analysis types",
-                     createTextMinimalPathDiagnosticConsumer)
-
 #ifndef ANALYSIS_PURGE
 #define ANALYSIS_PURGE(NAME, CMDFLAG, DESC)
 #endif
 
 ANALYSIS_PURGE(
     PurgeStmt, "statement",
     "Purge symbols, bindings, and constraints before every statement")
 

 ANALYSIS_INLINING_MODE(All, "all", "Analyze all functions as top level")
 
 ANALYSIS_INLINING_MODE(
     NoRedundancy, "noredundancy",
     "Do not analyze a function which has been previously inlined")
 
 #undef ANALYSIS_STORE
 #undef ANALYSIS_CONSTRAINTS
-#undef ANALYSIS_DIAGNOSTICS
 #undef ANALYSIS_PURGE
 #undef ANALYSIS_INLINING_MODE
 #undef ANALYSIS_IPA

clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h

 #include "clang/StaticAnalyzer/Core/Analyses.def"
 NumConstraints
 };
 
 /// AnalysisDiagClients - Set of available diagnostic clients for rendering
 ///  analysis results.
 enum AnalysisDiagClients {
 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) PD_##NAME,
-#include "clang/StaticAnalyzer/Core/Analyses.def"
+#include "clang/Analysis/PathDiagnosticConsumers.def"
 PD_NONE,
 NUM_ANALYSIS_DIAG_CLIENTS
 };
 
 /// AnalysisPurgeModes - Set of available strategies for dead symbol removal.
 enum AnalysisPurgeMode {
 #define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) NAME,
 #include "clang/StaticAnalyzer/Core/Analyses.def"

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

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_ANALYSISMANAGER_H
 #define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_ANALYSISMANAGER_H
 
 #include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Analysis/PathDiagnostic.h"
+#include "clang/Analysis/PathDiagnosticConsumers.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
-#include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
 
 namespace clang {
 
 class CodeInjector;
 
 namespace ento {
   class CheckerManager;
 

clang/include/clang/module.modulemap

 module Clang_Analysis {
   requires cplusplus
   umbrella "Analysis"
 
   textual header "Analysis/Analyses/ThreadSafetyOps.def"
+  textual header "Analysis/PathDiagnosticConsumers.def"
 
   module * { export * }
 
   // FIXME: Exclude these headers to avoid pulling all of the AST matchers
   // library into clang. Due to inline key functions in the headers,
   // importing the AST matchers library gives a link dependency on the AST
   // matchers (and thus the AST), which clang-format should not have.
   exclude header "Analysis/Analyses/ExprMutationAnalyzer.h"

clang/lib/Analysis/CMakeLists.txt

add_clang_library(clangAnalysis
   CallGraph.cpp
   CloneDetection.cpp
   CocoaConventions.cpp
   ConstructionContext.cpp
   Consumed.cpp
   CodeInjector.cpp
   Dominators.cpp
   ExprMutationAnalyzer.cpp
+  HTMLPathDiagnosticConsumer.cpp
   IssueHash.cpp
   LiveVariables.cpp
   ObjCNoReturn.cpp
   PathDiagnostic.cpp
+  PlistPathDiagnosticConsumer.cpp
+  PlistHTMLPathDiagnosticConsumer.cpp
   PostOrderCFGView.cpp
   ProgramPoint.cpp
   ReachableCode.cpp
   RetainSummaryManager.cpp
+  SarifPathDiagnosticConsumer.cpp
+  TextPathDiagnosticConsumer.cpp
   ThreadSafety.cpp
   ThreadSafetyCommon.cpp
   ThreadSafetyLogical.cpp
   ThreadSafetyTIL.cpp
   UninitializedValues.cpp
 
   LINK_LIBS
   clangAST

clang/lib/Analysis/HTMLPathDiagnosticConsumer.cpp

-//===- HTMLDiagnostics.cpp - HTML Diagnostics for Paths -------------------===//
+//===- HTMLPathDiagnosticConsumer.cpp - HTML Diagnostics for Paths --------===//
 //
 // 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 the HTMLDiagnostics object.
+//  This file defines the HTMLPathDiagnosticConsumer object.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Analysis/IssueHash.h"
 #include "clang/Analysis/PathDiagnostic.h"
+#include "clang/Analysis/PathDiagnosticConsumers.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/AST/Stmt.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/Token.h"
 #include "clang/Rewrite/Core/HTMLRewrite.h"
 #include "clang/Rewrite/Core/Rewriter.h"
-#include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"

 using namespace ento;
 
 //===----------------------------------------------------------------------===//
 // Boilerplate.
 //===----------------------------------------------------------------------===//
 
 namespace {
 
-class HTMLDiagnostics : public PathDiagnosticConsumer {
+class HTMLPathDiagnosticConsumer : public PathDiagnosticConsumer {
   PathDiagnosticConsumerOptions DiagOpts;
   std::string Directory;
   bool createdDir = false;
   bool noDir = false;
   const Preprocessor &PP;
   const bool SupportsCrossFileDiagnostics;
 
 public:
-  HTMLDiagnostics(PathDiagnosticConsumerOptions DiagOpts,
-                  const std::string &OutputDir, const Preprocessor &pp,
-                  bool supportsMultipleFiles)
-      : DiagOpts(std::move(DiagOpts)), Directory(OutputDir), PP(pp),
-        SupportsCrossFileDiagnostics(supportsMultipleFiles) {}
+  HTMLPathDiagnosticConsumer(PathDiagnosticConsumerOptions DiagOpts,
+                             const std::string &OutputDir,
+                             const Preprocessor &PP, bool SupportsMultipleFiles)
+      : DiagOpts(std::move(DiagOpts)), Directory(OutputDir), PP(PP),
+        SupportsCrossFileDiagnostics(SupportsMultipleFiles) {}
 
-  ~HTMLDiagnostics() override { FlushDiagnostics(nullptr); }
+  ~HTMLPathDiagnosticConsumer() override { FlushDiagnostics(nullptr); }
 
   void FlushDiagnosticsImpl(std::vector<const PathDiagnostic *> &Diags,
                             FilesMade *filesMade) override;
 
-  StringRef getName() const override {
-    return "HTMLDiagnostics";
-  }
+  StringRef getName() const override { return "HTMLPathDiagnosticConsumer"; }
 
   bool supportsCrossFileDiagnostics() const override {
     return SupportsCrossFileDiagnostics;
   }
 
   unsigned ProcessMacroPiece(raw_ostream &os,
                              const PathDiagnosticMacroPiece& P,
                              unsigned num);
void ento::createHTMLDiagnosticConsumer(
   // as our default. In the case of backward compatibility concerns, this could
   // be preserved with -analyzer-config-compatibility-mode=true.
   createTextMinimalPathDiagnosticConsumer(DiagOpts, C, OutputDir, PP, CTU);
 
   // TODO: Emit an error here.
   if (OutputDir.empty())
     return;
 
-  C.push_back(new HTMLDiagnostics(std::move(DiagOpts), OutputDir, PP, true));
+  C.push_back(
+      new HTMLPathDiagnosticConsumer(std::move(DiagOpts), OutputDir, PP, true));
 }
 
 void ento::createHTMLSingleFileDiagnosticConsumer(
     PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,
     const std::string &OutputDir, const Preprocessor &PP,
     const cross_tu::CrossTranslationUnitContext &CTU) {
   createTextMinimalPathDiagnosticConsumer(DiagOpts, C, OutputDir, PP, CTU);
 
   // TODO: Emit an error here.
   if (OutputDir.empty())
     return;
 
-  C.push_back(new HTMLDiagnostics(std::move(DiagOpts), OutputDir, PP, false));
-}
-
-void ento::createPlistHTMLDiagnosticConsumer(
-    PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,
-    const std::string &prefix, const Preprocessor &PP,
-    const cross_tu::CrossTranslationUnitContext &CTU) {
-  createHTMLDiagnosticConsumer(
-      DiagOpts, C, std::string(llvm::sys::path::parent_path(prefix)), PP,
-      CTU);
-  createPlistMultiFileDiagnosticConsumer(DiagOpts, C, prefix, PP, CTU);
-  createTextMinimalPathDiagnosticConsumer(std::move(DiagOpts), C, prefix, PP,
-                                          CTU);
+  C.push_back(new HTMLPathDiagnosticConsumer(std::move(DiagOpts), OutputDir, PP,
+                                             false));
 }
 
 //===----------------------------------------------------------------------===//
 // Report processing.
 //===----------------------------------------------------------------------===//
 
-void HTMLDiagnostics::FlushDiagnosticsImpl(
-  std::vector<const PathDiagnostic *> &Diags,
-  FilesMade *filesMade) {
+void HTMLPathDiagnosticConsumer::FlushDiagnosticsImpl(
+    std::vector<const PathDiagnostic *> &Diags, FilesMade *filesMade) {
   for (const auto Diag : Diags)
     ReportDiag(*Diag, filesMade);
 }
 
-void HTMLDiagnostics::ReportDiag(const PathDiagnostic& D,
+void HTMLPathDiagnosticConsumer::ReportDiag(const PathDiagnostic &D,
                                             FilesMade *filesMade) {
   // Create the HTML directory if it is missing.
   if (!createdDir) {
     createdDir = true;
     if (std::error_code ec = llvm::sys::fs::create_directories(Directory)) {
       llvm::errs() << "warning: could not create directory '"
                    << Directory << "': " << ec.message() << '\n';
       noDir = true;
       return;
void HTMLPathDiagnosticConsumer::ReportDiag(const PathDiagnostic &D,
   if (filesMade)
     filesMade->addDiagnostic(D, getName(),
                              llvm::sys::path::filename(ResultPath));
 
   // Emit the HTML to disk.
   os << report;
 }
 
-std::string HTMLDiagnostics::GenerateHTML(const PathDiagnostic& D, Rewriter &R,
-    const SourceManager& SMgr, const PathPieces& path, const char *declName) {
+std::string HTMLPathDiagnosticConsumer::GenerateHTML(const PathDiagnostic &D,
+                                                     Rewriter &R,
+                                                     const SourceManager &SMgr,
+                                                     const PathPieces &path,
+                                                     const char *declName) {
   // Rewrite source files as HTML for every new file the path crosses
   std::vector<FileID> FileIDs;
   for (auto I : path) {
     FileID FID = I->getLocation().asLocation().getExpansionLoc().getFileID();
     if (llvm::is_contained(FileIDs, FID))
       continue;
 
     FileIDs.push_back(FID);
std::string HTMLPathDiagnosticConsumer::GenerateHTML(const PathDiagnostic &D,
   std::string file;
   llvm::raw_string_ostream os(file);
   for (auto BI : *Buf)
     os << BI;
 
   return os.str();
 }
 
-void HTMLDiagnostics::dumpCoverageData(
-    const PathDiagnostic &D,
-    const PathPieces &path,
+void HTMLPathDiagnosticConsumer::dumpCoverageData(
+    const PathDiagnostic &D, const PathPieces &path,
     llvm::raw_string_ostream &os) {
 
   const FilesToLineNumsMap &ExecutedLines = D.getExecutedLines();
 
   os << "var relevant_lines = {";
   for (auto I = ExecutedLines.begin(),
             E = ExecutedLines.end(); I != E; ++I) {
     if (I != ExecutedLines.begin())
       os << ", ";
 
     os << "\"" << I->first.getHashValue() << "\": {";
     for (unsigned LineNo : I->second) {
       if (LineNo != *(I->second.begin()))
         os << ", ";
 
       os << "\"" << LineNo << "\": 1";
     }
     os << "}";
   }
 
   os << "};";
 }
 
-std::string HTMLDiagnostics::showRelevantLinesJavascript(
-      const PathDiagnostic &D, const PathPieces &path) {
+std::string HTMLPathDiagnosticConsumer::showRelevantLinesJavascript(
   std::string s;
   llvm::raw_string_ostream os(s);
   os << "<script type='text/javascript'>\n";
   dumpCoverageData(D, path, os);
   os << R"<<<(
 
 var filterCounterexample = function (hide) {
   var tables = document.getElementsByClassName("code");
<label for="showCounterexample">
        Show only relevant lines
     </label>
 </form>
 )<<<";
 
   return os.str();
 }
 
-void HTMLDiagnostics::FinalizeHTML(const PathDiagnostic& D, Rewriter &R,
-    const SourceManager& SMgr, const PathPieces& path, FileID FID,
-    const FileEntry *Entry, const char *declName) {
+void HTMLPathDiagnosticConsumer::FinalizeHTML(
+    const PathDiagnostic &D, Rewriter &R, const SourceManager &SMgr,
+    const PathPieces &path, FileID FID, const FileEntry *Entry,
+    const char *declName) {
   // This is a cludge; basically we want to append either the full
   // working directory if we have no directory information.  This is
   // a work in progress.
 
   llvm::SmallString<0> DirName;
 
   if (llvm::sys::path::is_relative(Entry->getName())) {
     llvm::sys::fs::current_path(DirName);
// Embed meta-data tags.
 
     // Insert the text.
     R.InsertTextBefore(SMgr.getLocForStartOfFile(FID), os.str());
   }
 
   html::AddHeaderFooterInternalBuiltinCSS(R, FID, Entry->getName());
 }
 
-StringRef HTMLDiagnostics::showHelpJavascript() {
+StringRef HTMLPathDiagnosticConsumer::showHelpJavascript() {
   return R"<<<(
 <script type='text/javascript'>
 
 var toggleHelp = function() {
     var hint = document.querySelector("#tooltiphint");
     var attributeName = "hidden";
     if (hint.hasAttribute(attributeName)) {
       hint.removeAttribute(attributeName);
html::HighlightRange(R, Range.getBegin(), Range.getEnd(),
                          /*IsTokenRange=*/true);
   } else {
     // Otherwise inject just the new row at the end of the range.
     html::HighlightRange(R, Range.getBegin(), Range.getEnd(), "", Buf.c_str(),
                          /*IsTokenRange=*/true);
   }
 }
 
-void HTMLDiagnostics::RewriteFile(Rewriter &R,
-                                  const PathPieces& path, FileID FID) {
+void HTMLPathDiagnosticConsumer::RewriteFile(Rewriter &R,
+                                             const PathPieces &path,
+                                             FileID FID) {
   // Process the path.
   // Maintain the counts of extra note pieces separately.
   unsigned TotalPieces = path.size();
   unsigned TotalNotePieces = std::count_if(
       path.begin(), path.end(), [](const PathDiagnosticPieceRef &p) {
         return isa<PathDiagnosticNotePiece>(*p);
       });
   unsigned PopUpPieceCount = std::count_if(
void HTMLPathDiagnosticConsumer::RewriteFile(Rewriter &R,
 
   // If we have a preprocessor, relex the file and syntax highlight.
   // We might not have a preprocessor if we come from a deserialized AST file,
   // for example.
   html::SyntaxHighlight(R, FID, PP);
   html::HighlightMacros(R, FID, PP);
 }
 
-void HTMLDiagnostics::HandlePiece(Rewriter &R, FileID BugFileID,
-                                  const PathDiagnosticPiece &P,
-                                  const std::vector<SourceRange> &PopUpRanges,
-                                  unsigned num, unsigned max) {
+void HTMLPathDiagnosticConsumer::HandlePiece(
+    Rewriter &R, FileID BugFileID, const PathDiagnosticPiece &P,
+    const std::vector<SourceRange> &PopUpRanges, unsigned num, unsigned max) {
   // For now, just draw a box above the line in question, and emit the
   // warning.
   FullSourceLoc Pos = P.getLocation().asLocation();
 
   if (!Pos.isValid())
     return;
 
   SourceManager &SM = R.getSourceMgr();
static void EmitAlphaCounter(raw_ostream &os, unsigned n) {
   n /= 'z' - 'a';
 
   if (n > 0)
     EmitAlphaCounter(os, n);
 
   os << char('a' + x);
 }
 
-unsigned HTMLDiagnostics::ProcessMacroPiece(raw_ostream &os,
-                                            const PathDiagnosticMacroPiece& P,
-                                            unsigned num) {
+unsigned HTMLPathDiagnosticConsumer::ProcessMacroPiece(
+    raw_ostream &os, const PathDiagnosticMacroPiece &P, unsigned num) {
   for (const auto &subPiece : P.subPieces) {
     if (const auto *MP = dyn_cast<PathDiagnosticMacroPiece>(subPiece.get())) {
       num = ProcessMacroPiece(os, *MP, num);
       continue;
     }
 
     if (const auto *EP = dyn_cast<PathDiagnosticEventPiece>(subPiece.get())) {
       os << "<div class=\"msg msgEvent\" style=\"width:94%; "
             "margin-left:5px\">"
             "<table class=\"msgT\"><tr>"
             "<td valign=\"top\"><div class=\"PathIndex PathIndexEvent\">";
       EmitAlphaCounter(os, num++);
       os << "</div></td><td valign=\"top\">"
          << html::EscapeText(EP->getString())
          << "</td></tr></table></div>\n";
     }
   }
 
   return num;
 }
 
-void HTMLDiagnostics::HighlightRange(Rewriter& R, FileID BugFileID,
+void HTMLPathDiagnosticConsumer::HighlightRange(Rewriter &R, FileID BugFileID,
                                                 SourceRange Range,
                                                 const char *HighlightStart,
                                                 const char *HighlightEnd) {
   SourceManager &SM = R.getSourceMgr();
   const LangOptions &LangOpts = R.getLangOpts();
 
   SourceLocation InstantiationStart = SM.getExpansionLoc(Range.getBegin());
   unsigned StartLineNo = SM.getExpansionLineNumber(InstantiationStart);
 
   SourceLocation InstantiationEnd = SM.getExpansionLoc(Range.getEnd());
   unsigned EndLineNo = SM.getExpansionLineNumber(InstantiationEnd);
void HTMLPathDiagnosticConsumer::HighlightRange(Rewriter &R, FileID BugFileID,
   // selected range.
 
   SourceLocation E =
     InstantiationEnd.getLocWithOffset(EndColNo - OldEndColNo);
 
   html::HighlightRange(R, InstantiationStart, E, HighlightStart, HighlightEnd);
 }
 
-StringRef HTMLDiagnostics::generateKeyboardNavigationJavascript() {
+StringRef HTMLPathDiagnosticConsumer::generateKeyboardNavigationJavascript() {
   return R"<<<(
 <script type='text/javascript'>
 var digitMatcher = new RegExp("[0-9]+");
 
 var querySelectorAllArray = function(selector) {
   return Array.prototype.slice.call(
     document.querySelectorAll(selector));
 }

clang/lib/Analysis/PlistHTMLPathDiagnosticConsumer.cpp

+//===--- PlistHTMLDiagnostics.cpp - The Plist-HTML Diagnostic Consumer. ---===//
+//
+// 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 diagnostic consumer produces both the HTML output and the Plist output.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Analysis/PathDiagnostic.h"
+#include "clang/Analysis/PathDiagnosticConsumers.h"
+#include "clang/Basic/SourceManager.h"
+#include "clang/CrossTU/CrossTranslationUnit.h"
+#include "clang/Lex/Preprocessor.h"
+
+using namespace clang;
+using namespace ento;
+
+void ento::createPlistHTMLDiagnosticConsumer(
+    PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,
+    const std::string &Prefix, const Preprocessor &PP,
+    const cross_tu::CrossTranslationUnitContext &CTU) {
+  createHTMLDiagnosticConsumer(
+      DiagOpts, C, std::string(llvm::sys::path::parent_path(Prefix)), PP, CTU);
+  createPlistMultiFileDiagnosticConsumer(DiagOpts, C, Prefix, PP, CTU);
+  createTextMinimalPathDiagnosticConsumer(std::move(DiagOpts), C, Prefix, PP,
+                                          CTU);
+}

clang/lib/Analysis/PlistPathDiagnosticConsumer.cpp

-//===--- PlistDiagnostics.cpp - Plist Diagnostics for Paths -----*- C++ -*-===//
+//===--- PlistPathDiagnosticConsumer.cpp - Plist Diagnostics ----*- 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
 //
 //===----------------------------------------------------------------------===//
 //
-//  This file defines the PlistDiagnostics object.
+//  This file defines the PlistPathDiagnosticConsumer object.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Analysis/IssueHash.h"
 #include "clang/Analysis/PathDiagnostic.h"
+#include "clang/Analysis/PathDiagnosticConsumers.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/PlistSupport.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/Version.h"
 #include "clang/CrossTU/CrossTranslationUnit.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/TokenConcatenation.h"
 #include "clang/Rewrite/Core/HTMLRewrite.h"
-#include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Support/Casting.h"
 #include <memory>
 
 using namespace clang;
 using namespace ento;
 using namespace markup;
 
 //===----------------------------------------------------------------------===//
 // Declarations of helper classes and functions for emitting bug reports in
 // plist format.
 //===----------------------------------------------------------------------===//
 
 namespace {
-  class PlistDiagnostics : public PathDiagnosticConsumer {
+  class PlistPathDiagnosticConsumer : public PathDiagnosticConsumer {
     PathDiagnosticConsumerOptions DiagOpts;
     const std::string OutputFile;
     const Preprocessor &PP;
     const cross_tu::CrossTranslationUnitContext &CTU;
     const bool SupportsCrossFileDiagnostics;
 
     void printBugPath(llvm::raw_ostream &o, const FIDMap &FM,
                       const PathPieces &Path);
 
   public:
-    PlistDiagnostics(PathDiagnosticConsumerOptions DiagOpts,
+    PlistPathDiagnosticConsumer(PathDiagnosticConsumerOptions DiagOpts,
                      const std::string &OutputFile, const Preprocessor &PP,
                      const cross_tu::CrossTranslationUnitContext &CTU,
                      bool supportsMultipleFiles);
 
-    ~PlistDiagnostics() override {}
+    ~PlistPathDiagnosticConsumer() override {}
 
     void FlushDiagnosticsImpl(std::vector<const PathDiagnostic *> &Diags,
                               FilesMade *filesMade) override;
 
     StringRef getName() const override {
-      return "PlistDiagnostics";
+      return "PlistPathDiagnosticConsumer";
     }
 
     PathGenerationScheme getGenerationScheme() const override {
       return Extensive;
     }
     bool supportsLogicalOpControlFlow() const override { return true; }
     bool supportsCrossFileDiagnostics() const override {
       return SupportsCrossFileDiagnostics;
static void printCoverage(const PathDiagnostic *D,
   }
   IndentLevel--;
   Indent(o, IndentLevel) << "</dict>\n";
 
   assert(IndentLevel == InputIndentLevel);
 }
 
 //===----------------------------------------------------------------------===//
-// Methods of PlistDiagnostics.
+// Methods of PlistPathDiagnosticConsumer.
 //===----------------------------------------------------------------------===//
 
-PlistDiagnostics::PlistDiagnostics(
+PlistPathDiagnosticConsumer::PlistPathDiagnosticConsumer(
     PathDiagnosticConsumerOptions DiagOpts, const std::string &output,
     const Preprocessor &PP, const cross_tu::CrossTranslationUnitContext &CTU,
     bool supportsMultipleFiles)
     : DiagOpts(std::move(DiagOpts)), OutputFile(output), PP(PP), CTU(CTU),
       SupportsCrossFileDiagnostics(supportsMultipleFiles) {
   // FIXME: Will be used by a later planned change.
   (void)this->CTU;
 }
 
 void ento::createPlistDiagnosticConsumer(
     PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,
     const std::string &OutputFile, const Preprocessor &PP,
     const cross_tu::CrossTranslationUnitContext &CTU) {
 
   // TODO: Emit an error here.
   if (OutputFile.empty())
     return;
 
-  C.push_back(new PlistDiagnostics(DiagOpts, OutputFile, PP, CTU,
+  C.push_back(new PlistPathDiagnosticConsumer(DiagOpts, OutputFile, PP, CTU,
                                               /*supportsMultipleFiles=*/false));
   createTextMinimalPathDiagnosticConsumer(std::move(DiagOpts), C, OutputFile,
                                           PP, CTU);
 }
 
 void ento::createPlistMultiFileDiagnosticConsumer(
     PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,
     const std::string &OutputFile, const Preprocessor &PP,
     const cross_tu::CrossTranslationUnitContext &CTU) {
 
   // TODO: Emit an error here.
   if (OutputFile.empty())
     return;
 
-  C.push_back(new PlistDiagnostics(DiagOpts, OutputFile, PP, CTU,
+  C.push_back(new PlistPathDiagnosticConsumer(DiagOpts, OutputFile, PP, CTU,
                                               /*supportsMultipleFiles=*/true));
   createTextMinimalPathDiagnosticConsumer(std::move(DiagOpts), C, OutputFile,
                                           PP, CTU);
 }
 
-void PlistDiagnostics::printBugPath(llvm::raw_ostream &o, const FIDMap &FM,
+void PlistPathDiagnosticConsumer::printBugPath(llvm::raw_ostream &o,
+                                               const FIDMap &FM,
                                                const PathPieces &Path) {
   PlistPrinter Printer(FM, PP, CTU);
   assert(std::is_partitioned(Path.begin(), Path.end(),
                              [](const PathDiagnosticPieceRef &E) {
                                return E->getKind() == PathDiagnosticPiece::Note;
                              }) &&
          "PathDiagnostic is not partitioned so that notes precede the rest");
 
   PathPieces::const_iterator FirstNonNote = std::partition_point(
if (!DiagOpts.ShouldDisplayMacroExpansions)
     return;
 
   o << "   <key>macro_expansions</key>\n"
        "   <array>\n";
   Printer.ReportMacroExpansions(o, /* indent */ 4);
   o << "   </array>\n";
 }
 
-void PlistDiagnostics::FlushDiagnosticsImpl(
-                                    std::vector<const PathDiagnostic *> &Diags,
-                                    FilesMade *filesMade) {
+void PlistPathDiagnosticConsumer::FlushDiagnosticsImpl(
+    std::vector<const PathDiagnostic *> &Diags, FilesMade *filesMade) {
   // Build up a set of FIDs that we use by scanning the locations and
   // ranges of the diagnostics.
   FIDMap FM;
   SmallVector<FileID, 10> Fids;
   const SourceManager& SM = PP.getSourceManager();
   const LangOptions &LangOpts = PP.getLangOpts();
 
   auto AddPieceFID = [&FM, &Fids, &SM](const PathDiagnosticPiece &Piece) {

clang/lib/Analysis/SarifPathDiagnosticConsumer.cpp

-//===--- SarifDiagnostics.cpp - Sarif Diagnostics for Paths -----*- C++ -*-===//
+//===--- SarifPathDiagnosticConsumer.cpp - Sarif Diagnostics  ---*- 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
 //
 //===----------------------------------------------------------------------===//
 //
-//  This file defines the SarifDiagnostics object.
+//  This file defines the SarifPathDiagnosticConsumer object.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Analysis/PathDiagnostic.h"
+#include "clang/Analysis/PathDiagnosticConsumers.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/Version.h"
 #include "clang/Lex/Preprocessor.h"
-#include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/Path.h"
 
 using namespace llvm;
 using namespace clang;
 using namespace ento;
 
 namespace {
-class SarifDiagnostics : public PathDiagnosticConsumer {
+class SarifPathDiagnosticConsumer : public PathDiagnosticConsumer {
   std::string OutputFile;
   const LangOptions &LO;
 
 public:
-  SarifDiagnostics(const std::string &Output, const LangOptions &LO)
+  SarifPathDiagnosticConsumer(const std::string &Output, const LangOptions &LO)
       : OutputFile(Output), LO(LO) {}
-  ~SarifDiagnostics() override = default;
+  ~SarifPathDiagnosticConsumer() override = default;
 
   void FlushDiagnosticsImpl(std::vector<const PathDiagnostic *> &Diags,
                             FilesMade *FM) override;
 
-  StringRef getName() const override { return "SarifDiagnostics"; }
+  StringRef getName() const override { return "SarifPathDiagnosticConsumer"; }
   PathGenerationScheme getGenerationScheme() const override { return Minimal; }
   bool supportsLogicalOpControlFlow() const override { return true; }
   bool supportsCrossFileDiagnostics() const override { return true; }
 };
 } // end anonymous namespace
 
 void ento::createSarifDiagnosticConsumer(
     PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,
     const std::string &Output, const Preprocessor &PP,
     const cross_tu::CrossTranslationUnitContext &CTU) {
 
   // TODO: Emit an error here.
   if (Output.empty())
     return;
 
-  C.push_back(new SarifDiagnostics(Output, PP.getLangOpts()));
+  C.push_back(new SarifPathDiagnosticConsumer(Output, PP.getLangOpts()));
   createTextMinimalPathDiagnosticConsumer(std::move(DiagOpts), C, Output, PP,
                                           CTU);
 }
 
 static StringRef getFileName(const FileEntry &FE) {
   StringRef Filename = FE.tryGetRealPathName();
   if (Filename.empty())
     Filename = FE.getName();
return json::Object{
            LO, Diag.getLocation().asRange(),
            *Diag.getLocation().asLocation().getExpansionLoc().getFileEntry(),
            SMgr, Artifacts))}},
       {"ruleIndex", Iter->getValue()},
       {"ruleId", Diag.getCheckerName()}};
 }
 
 static StringRef getRuleDescription(StringRef CheckName) {
+  // FIXME: This is a layering violation; it only works for the particular
+  // use-case of clang static analyzer. This info should be provided
+  // as part of PathDiagnostic itself.
   return llvm::StringSwitch<StringRef>(CheckName)
 #define GET_CHECKERS
 #define CHECKER(FULLNAME, CLASS, HELPTEXT, DOC_URI, IS_HIDDEN)                 \
   .Case(FULLNAME, HELPTEXT)
 #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
 #undef CHECKER
 #undef GET_CHECKERS
       ;
 }
 
 static StringRef getRuleHelpURIStr(StringRef CheckName) {
+  // FIXME: This is a layering violation; it only works for the particular
+  // use-case of clang static analyzer. This info should be provided
+  // as part of PathDiagnostic itself.
   return llvm::StringSwitch<StringRef>(CheckName)
 #define GET_CHECKERS
 #define CHECKER(FULLNAME, CLASS, HELPTEXT, DOC_URI, IS_HIDDEN)                 \
   .Case(FULLNAME, DOC_URI)
 #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
 #undef CHECKER
 #undef GET_CHECKERS
       ;
static json::Object createRun(const LangOptions &LO,
   });
 
   return json::Object{{"tool", std::move(Tool)},
                       {"results", std::move(Results)},
                       {"artifacts", std::move(Artifacts)},
                       {"columnKind", "unicodeCodePoints"}};
 }
 
-void SarifDiagnostics::FlushDiagnosticsImpl(
+void SarifPathDiagnosticConsumer::FlushDiagnosticsImpl(
     std::vector<const PathDiagnostic *> &Diags, FilesMade *) {
   // We currently overwrite the file if it already exists. However, it may be
   // useful to add a feature someday that allows the user to append a run to an
   // existing SARIF file. One danger from that approach is that the size of the
   // file can become large very quickly, so decoding into JSON to append a run
   // may be an expensive operation.
   std::error_code EC;
   llvm::raw_fd_ostream OS(OutputFile, EC, llvm::sys::fs::OF_Text);

clang/lib/Analysis/TextPathDiagnosticConsumer.cpp

-//===--- TextDiagnostics.cpp - Text Diagnostics for Paths -------*- C++ -*-===//
+//===--- TextPathDiagnosticConsumer.cpp - Text Diagnostics ------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
-//  This file defines the TextDiagnostics object.
+//  This file defines the TextPathDiagnosticConsumer object.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Analysis/PathDiagnostic.h"
+#include "clang/Analysis/PathDiagnosticConsumers.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/Version.h"
 #include "clang/CrossTU/CrossTranslationUnit.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Rewrite/Core/Rewriter.h"
-#include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
-#include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Casting.h"
 
 using namespace clang;
 using namespace ento;
 using namespace tooling;
 
 namespace {
 /// Emitsd minimal diagnostics (report message + notes) for the 'none' output
 /// type to the standard error, or to to compliment many others. Emits detailed
 /// diagnostics in textual format for the 'text' output type.
-class TextDiagnostics : public PathDiagnosticConsumer {
+class TextPathDiagnosticConsumer : public PathDiagnosticConsumer {
   PathDiagnosticConsumerOptions DiagOpts;
   DiagnosticsEngine &DiagEng;
   const LangOptions &LO;
   bool ShouldDisplayPathNotes;
 
 public:
-  TextDiagnostics(PathDiagnosticConsumerOptions DiagOpts,
+  TextPathDiagnosticConsumer(PathDiagnosticConsumerOptions DiagOpts,
                              DiagnosticsEngine &DiagEng, const LangOptions &LO,
                              bool ShouldDisplayPathNotes)
       : DiagOpts(std::move(DiagOpts)), DiagEng(DiagEng), LO(LO),
         ShouldDisplayPathNotes(ShouldDisplayPathNotes) {}
-  ~TextDiagnostics() override {}
+  ~TextPathDiagnosticConsumer() override {}
 
-  StringRef getName() const override { return "TextDiagnostics"; }
+  StringRef getName() const override { return "TextPathDiagnosticConsumer"; }
 
   bool supportsLogicalOpControlFlow() const override { return true; }
   bool supportsCrossFileDiagnostics() const override { return true; }
 
   PathGenerationScheme getGenerationScheme() const override {
     return ShouldDisplayPathNotes ? Minimal : None;
   }
 
public:
   }
 };
 } // end anonymous namespace
 
 void ento::createTextPathDiagnosticConsumer(
     PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,
     const std::string &Prefix, const clang::Preprocessor &PP,
     const cross_tu::CrossTranslationUnitContext &CTU) {
-  C.emplace_back(new TextDiagnostics(std::move(DiagOpts), PP.getDiagnostics(),
-                                     PP.getLangOpts(),
-                                     /*ShouldDisplayPathNotes=*/true));
+  C.emplace_back(new TextPathDiagnosticConsumer(
+      std::move(DiagOpts), PP.getDiagnostics(), PP.getLangOpts(),
 }
 
 void ento::createTextMinimalPathDiagnosticConsumer(
     PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,
     const std::string &Prefix, const clang::Preprocessor &PP,
     const cross_tu::CrossTranslationUnitContext &CTU) {
-  C.emplace_back(new TextDiagnostics(std::move(DiagOpts), PP.getDiagnostics(),
-                                     PP.getLangOpts(),
-                                     /*ShouldDisplayPathNotes=*/false));
+  C.emplace_back(new TextPathDiagnosticConsumer(
+      std::move(DiagOpts), PP.getDiagnostics(), PP.getLangOpts(),
 }

clang/lib/Frontend/CompilerInvocation.cpp

#include "clang/StaticAnalyzer/Core/Analyses.def"
     }
   }
 
   if (Arg *A = Args.getLastArg(OPT_analyzer_output)) {
     StringRef Name = A->getValue();
     AnalysisDiagClients Value = llvm::StringSwitch<AnalysisDiagClients>(Name)
 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
       .Case(CMDFLAG, PD_##NAME)
-#include "clang/StaticAnalyzer/Core/Analyses.def"
+#include "clang/Analysis/PathDiagnosticConsumers.def"
       .Default(NUM_ANALYSIS_DIAG_CLIENTS);
     if (Value == NUM_ANALYSIS_DIAG_CLIENTS) {
       Diags.Report(diag::err_drv_invalid_value)
         << A->getAsString(Args) << Name;
       Success = false;
     } else {
       Opts.AnalysisDiagOpt = Value;
     }

clang/lib/StaticAnalyzer/Core/CMakeLists.txt

add_clang_library(clangStaticAnalyzerCore
   Environment.cpp
   ExplodedGraph.cpp
   ExprEngine.cpp
   ExprEngineC.cpp
   ExprEngineCXX.cpp
   ExprEngineCallAndReturn.cpp
   ExprEngineObjC.cpp
   FunctionSummary.cpp
-  HTMLDiagnostics.cpp
   LoopUnrolling.cpp
   LoopWidening.cpp
   MemRegion.cpp
-  PlistDiagnostics.cpp
   ProgramState.cpp
   RangeConstraintManager.cpp
   RangedConstraintManager.cpp
   RegionStore.cpp
-  SarifDiagnostics.cpp
   SimpleConstraintManager.cpp
   SimpleSValBuilder.cpp
   SMTConstraintManager.cpp
   Store.cpp
   SValBuilder.cpp
   SVals.cpp
   SymbolManager.cpp
-  TextDiagnostics.cpp
   WorkList.cpp
 
   LINK_LIBS
   clangAST
   clangASTMatchers
   clangAnalysis
   clangBasic
   clangCrossTU

clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp

 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Analysis/Analyses/LiveVariables.h"
 #include "clang/Analysis/CFG.h"
 #include "clang/Analysis/CallGraph.h"
 #include "clang/Analysis/CodeInjector.h"
 #include "clang/Analysis/PathDiagnostic.h"
+#include "clang/Analysis/PathDiagnosticConsumers.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/CrossTU/CrossTranslationUnit.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Rewrite/Core/Rewriter.h"
 #include "clang/StaticAnalyzer/Checkers/LocalCheckers.h"
 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
-#include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h"
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/Timer.h"
public:
   void DigestAnalyzerOptions() {
     switch (Opts->AnalysisDiagOpt) {
     case PD_NONE:
       break;
 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATEFN)                    \
   case PD_##NAME:                                                              \
     CREATEFN(Opts->getDiagOpts(), PathConsumers, OutDir, PP, CTU);             \
     break;
-#include "clang/StaticAnalyzer/Core/Analyses.def"
+#include "clang/Analysis/PathDiagnosticConsumers.def"
     default:
       llvm_unreachable("Unknown analyzer output type!");
     }
 
     // Create the analyzer component creators.
     switch (Opts->AnalysisStoreOpt) {
     default:
       llvm_unreachable("Unknown store manager.");