[analyzer] Removed some dead code in BugReporter and related files

[NoQ]

Yay, that'll make my life a lot easier! I heard you have an automatic tool for this sort of stuff, right?

clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h

408

Hey, i just added that! :D (well, renamed) (rC369320)

I believe we do want a separation between a {bug report, bug reporter} classes that's only suitable for path-insensitive reports (which would live in libAnalysis and we could handle them to clang-tidy while still being able to compile it without CLANG_ENABLE_STATIC_ANALYZER) and all the path-sensitive report logic that is pretty huge but only Static Analyzer needs it. For that purpose we'd better leave this in. WDYT? See also D66460.

Should i ask on the mailing list whether you're willing to sacrifice building clang-tidy without CLANG_ENABLE_STATIC_ANALYZER in order to transition to BugReporter? Cause i thought it was obvious that it's not a great idea, even if it causes me to do a bit of cleanup work on my end.

That said, i'm surprised that it's deadcode, i.e. that nobody ever dyn_casts bug reporters, even though we already have two bug reporter classes. Maybe we can indeed remove this facility.

clang/lib/StaticAnalyzer/Core/BugReporter.cpp

2343

Btw these days we strongly suspect that the whole graph trimming thing is useless and should be removed.

clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

1169

Woohooo!

[gribozavr]

clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h

408

I believe we do want a separation between a {bug report, bug reporter} classes [...]

Yes, the separation is nice.

For that purpose we'd better leave this in.

Kind is only needed for dynamic casting between different bug reporters. I'm not sure that is useful in practice (case in point -- the classof is not used today), specifically because the client that produces diagnostics will need to work with a bug reporter of the correct kind. If a path-sensitive client is handed a pointer to the base class, BugReporter, would it try to dyn_cast it to the derived class?.. what if it fails?..

Basically, I don't understand why one would want dynamic casting for these classes. I totally agree with the separation though.

Should i ask on the mailing list whether you're willing to sacrifice building clang-tidy without CLANG_ENABLE_STATIC_ANALYZER in order to transition to BugReporter?

I personally don't mind CLANG_ENABLE_STATIC_ANALYZER going away completely (I have a fast machine and use a build system with strong caching), however, there are other people who are a lot more sensitive to build time, and for whom it might be important.

clang/lib/StaticAnalyzer/Core/BugReporter.cpp

2343

TBH, I don't understand what this code is doing, I was just following the leads from dead code analysis :)

[Szelethus]

No way the entire NodeResolver is dead code! I spent so much time trying to understand it! I mean, now that I think about it, we literally deep copy every ExplodedNode, so why would we need the mapping to the original, right?

Wow. Thank you so much for clearing this out.

clang/lib/StaticAnalyzer/Core/BugReporter.cpp

2263–2264

Let's keep the comment up to date as well :)

[Szelethus]

clang/lib/StaticAnalyzer/Core/BugReporter.cpp

2343

TL;DR: When creating a linear path from the root of the ExplodedGraph to a given error node (a point at which a bug was emitted), we first trim be graph of all nodes that do not lead to an error node, and then create the path from that, instead of skipping the entire trimming process.

This isn't that simple (though probably not that difficult either), so feel free to leave it as it, the code is already much easier to read!

[NoQ]

clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h

408

I personally don't mind CLANG_ENABLE_STATIC_ANALYZER going away completely (I have a fast machine and use a build system with strong caching), however, there are other people who are a lot more sensitive to build time, and for whom it might be important.

I think for clang it's mostly about binary size; people occasionally want compact clangs.

I'm not sure that is useful in practice (case in point -- the classof is not used today), specifically because the client that produces diagnostics will need to work with a bug reporter of the correct kind.

Yeah, i agree. I'll add it back if i ever need it.

[gribozavr]

clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h

408

I think for clang it's mostly about binary size; people occasionally want compact clangs.

That's true -- some people also want to have a small clang binary; however you asked about clang-tidy without CLANG_ENABLE_STATIC_ANALYZER :)

[gribozavr]

Updated a comment.

[gribozavr]

clang/lib/StaticAnalyzer/Core/BugReporter.cpp

2343

Thanks for the explanation, I'll leave it as is in this patch.

clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h

 /// consume.
 using DiagnosticForConsumerMapTy =
     llvm::DenseMap<PathDiagnosticConsumer *, std::unique_ptr<PathDiagnostic>>;
 
 /// This class provides an interface through which checkers can create
 /// individual bug reports.
 class BugReport : public llvm::ilist_node<BugReport> {
 public:
-  class NodeResolver {
-    virtual void anchor();
-
-  public:
-    virtual ~NodeResolver() = default;
-
-    virtual const ExplodedNode*
-            getOriginalNode(const ExplodedNode *N) = 0;
-  };
-
   using ranges_iterator = const SourceRange *;
   using VisitorList = SmallVector<std::unique_ptr<BugReporterVisitor>, 8>;
   using visitor_iterator = VisitorList::iterator;
   using visitor_range = llvm::iterator_range<visitor_iterator>;
   using NoteList = SmallVector<std::shared_ptr<PathDiagnosticNotePiece>, 4>;
 
 protected:
   friend class BugReportEquivClass;

 //===----------------------------------------------------------------------===//
 // BugReporter and friends.
 //===----------------------------------------------------------------------===//
 
 class BugReporterData {
 public:
   virtual ~BugReporterData() = default;
 
-  virtual DiagnosticsEngine& getDiagnostic() = 0;
   virtual ArrayRef<PathDiagnosticConsumer*> getPathDiagnosticConsumers() = 0;
   virtual ASTContext &getASTContext() = 0;
   virtual SourceManager &getSourceManager() = 0;
   virtual AnalyzerOptions &getAnalyzerOptions() = 0;
 };
 
 /// BugReporter is a utility class for generating PathDiagnostics for analysis.
 /// It collects the BugReports and BugTypes and knows how to generate
 /// and flush the corresponding diagnostics.
 ///
 /// The base class is used for generating path-insensitive
 class BugReporter {
-public:
-  enum Kind { BasicBRKind, PathSensitiveBRKind };
-
 private:
   using BugTypesTy = llvm::ImmutableSet<BugType *>;
 
   BugTypesTy::Factory F;
   BugTypesTy BugTypes;
 
-  const Kind kind;
   BugReporterData& D;
 
   /// Generate and flush the diagnostics for the given bug report.
   void FlushReport(BugReportEquivClass& EQ);
 
   /// Generate the diagnostics for the given bug report.
   std::unique_ptr<DiagnosticForConsumerMapTy>
   generateDiagnosticForConsumerMap(BugReport *exampleReport,
                                    ArrayRef<PathDiagnosticConsumer *> consumers,
                                    ArrayRef<BugReport *> bugReports);
 
   /// The set of bug reports tracked by the BugReporter.
   llvm::FoldingSet<BugReportEquivClass> EQClasses;
 
   /// A vector of BugReports for tracking the allocated pointers and cleanup.
   std::vector<BugReportEquivClass *> EQClassesVector;
 
-protected:
-  BugReporter(BugReporterData& d, Kind k)
-      : BugTypes(F.getEmptySet()), kind(k), D(d) {}
-
 public:
-  BugReporter(BugReporterData& d)
-      : BugTypes(F.getEmptySet()), kind(BasicBRKind), D(d) {}
+  BugReporter(BugReporterData &d) : BugTypes(F.getEmptySet()), D(d) {}
   virtual ~BugReporter();
 
   /// Generate and flush diagnostics for all bug reports.
   void FlushReports();
 
-  Kind getKind() const { return kind; }
-
-  DiagnosticsEngine& getDiagnostic() {
-    return D.getDiagnostic();
-  }
-
   ArrayRef<PathDiagnosticConsumer*> getPathDiagnosticConsumers() {
     return D.getPathDiagnosticConsumers();
   }
 
   /// Iterator over the set of BugTypes tracked by the BugReporter.
   using iterator = BugTypesTy::iterator;
   iterator begin() { return BugTypes.begin(); }
   iterator end() { return BugTypes.end(); }

 };
 
 /// GRBugReporter is used for generating path-sensitive reports.
 class PathSensitiveBugReporter : public BugReporter {
   ExprEngine& Eng;
 
 public:
   PathSensitiveBugReporter(BugReporterData& d, ExprEngine& eng)
-      : BugReporter(d, PathSensitiveBRKind), Eng(eng) {}
+      : BugReporter(d), Eng(eng) {}
 
   ~PathSensitiveBugReporter() override = default;
 
   /// getGraph - Get the exploded graph created by the analysis engine
   ///  for the analyzed method or function.
   const ExplodedGraph &getGraph() const;
 
   /// getStateManager - Return the state manager used by the analysis
   ///  engine.
-  ProgramStateManager &getStateManager();
-
   ProgramStateManager &getStateManager() const;
 
   /// \p bugReports A set of bug reports within a *single* equivalence class
   ///
   /// \return A mapping from consumers to the corresponding diagnostics.
   /// Iterates through the bug reports within a single equivalence class,
   /// stops at a first non-invalidated report.
   std::unique_ptr<DiagnosticForConsumerMapTy>
   generatePathDiagnostics(ArrayRef<PathDiagnosticConsumer *> consumers,
                           ArrayRef<BugReport *> &bugReports) override;
-
-  /// classof - Used by isa<>, cast<>, and dyn_cast<>.
-  static bool classof(const BugReporter* R) {
-    return R->getKind() == PathSensitiveBRKind;
-  }
 };
 
 
-class NodeMapClosure : public BugReport::NodeResolver {
-  InterExplodedGraphMap &M;
-
-public:
-  NodeMapClosure(InterExplodedGraphMap &m) : M(m) {}
-
-  const ExplodedNode *getOriginalNode(const ExplodedNode *N) override {
-    return M.lookup(N);
-  }
-};
-
 class BugReporterContext {
   PathSensitiveBugReporter &BR;
-  NodeMapClosure NMC;
 
   virtual void anchor();
 
 public:
-  BugReporterContext(PathSensitiveBugReporter &br,
-                     InterExplodedGraphMap &Backmap)
-      : BR(br), NMC(Backmap) {}
+  BugReporterContext(PathSensitiveBugReporter &br) : BR(br) {}
 
   virtual ~BugReporterContext() = default;
 
   PathSensitiveBugReporter& getBugReporter() { return BR; }
 
-  const ExplodedGraph &getGraph() const { return BR.getGraph(); }
-
   ProgramStateManager& getStateManager() const {
     return BR.getStateManager();
   }
 
-  SValBuilder &getSValBuilder() const {
-    return getStateManager().getSValBuilder();
-  }
-
   ASTContext &getASTContext() const {
     return BR.getContext();
   }
 
   const SourceManager& getSourceManager() const {
     return BR.getSourceManager();
   }
 
   const AnalyzerOptions &getAnalyzerOptions() const {
     return BR.getAnalyzerOptions();
   }
-
-  NodeMapClosure& getNodeResolver() { return NMC; }
 };
 
 
 /// The tag upon which the TagVisitor reacts. Add these in order to display
 /// additional PathDiagnosticEventPieces along the path.
 class NoteTag : public ProgramPointTag {
 public:
   using Callback =

clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h

class FindLastStoreBRVisitor final : public BugReporterVisitor {
   /// bug, we are going to employ false positive suppression.
   bool EnableNullFPSuppression;
 
   using TrackingKind = bugreporter::TrackingKind;
   TrackingKind TKind;
   const StackFrameContext *OriginSFC;
 
 public:
-  /// Creates a visitor for every VarDecl inside a Stmt and registers it with
-  /// the BugReport.
-  static void registerStatementVarDecls(BugReport &BR, const Stmt *S,
-                                        bool EnableNullFPSuppression,
-                                        TrackingKind TKind);
-
   /// \param V We're searching for the store where \c R received this value.
   /// \param R The region we're tracking.
   /// \param TKind May limit the amount of notes added to the bug report.
   /// \param OriginSFC Only adds notes when the last store happened in a
   ///        different stackframe to this one. Disregarded if the tracking kind
   ///        is thorough.
   ///        This is useful, because for non-tracked regions, notes about
   ///        changes to its value in a nested stackframe could be pruned, and

clang/include/clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h

 class PathDiagnosticMacroPiece : public PathDiagnosticSpotPiece {
 public:
   PathDiagnosticMacroPiece(const PathDiagnosticLocation &pos)
       : PathDiagnosticSpotPiece(pos, "", Macro) {}
   ~PathDiagnosticMacroPiece() override;
 
   PathPieces subPieces;
 
-  bool containsEvent() const;
-
   void flattenLocations() override {
     PathDiagnosticSpotPiece::flattenLocations();
     for (const auto &I : subPieces)
       I->flattenLocations();
   }
 
   static bool classof(const PathDiagnosticPiece *P) {
     return P->getKind() == Macro;

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

 namespace ento {
   class CheckerManager;
 
 class AnalysisManager : public BugReporterData {
   virtual void anchor();
   AnalysisDeclContextManager AnaCtxMgr;
 
   ASTContext &Ctx;
-  DiagnosticsEngine &Diags;
   const LangOptions &LangOpts;
   PathDiagnosticConsumers PathConsumers;
 
   // Configurable components creators.
   StoreManagerCreator CreateStoreMgr;
   ConstraintManagerCreator CreateConstraintMgr;
 
   CheckerManager *CheckerMgr;
 
 public:
   AnalyzerOptions &options;
 
-  AnalysisManager(ASTContext &ctx, DiagnosticsEngine &diags,
+  AnalysisManager(ASTContext &ctx,
                   const PathDiagnosticConsumers &Consumers,
                   StoreManagerCreator storemgr,
                   ConstraintManagerCreator constraintmgr,
                   CheckerManager *checkerMgr, AnalyzerOptions &Options,
                   CodeInjector *injector = nullptr);
 
   ~AnalysisManager() override;
 
public:
   ASTContext &getASTContext() override {
     return Ctx;
   }
 
   SourceManager &getSourceManager() override {
     return getASTContext().getSourceManager();
   }
 
-  DiagnosticsEngine &getDiagnostic() override {
-    return Diags;
-  }
-
   const LangOptions &getLangOpts() const {
     return LangOpts;
   }
 
   ArrayRef<PathDiagnosticConsumer*> getPathDiagnosticConsumers() override {
     return PathConsumers;
   }
 

clang/lib/StaticAnalyzer/Core/AnalysisManager.cpp

 //===-- AnalysisManager.cpp -------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
 
 using namespace clang;
 using namespace ento;
 
 void AnalysisManager::anchor() { }
 
-AnalysisManager::AnalysisManager(ASTContext &ASTCtx, DiagnosticsEngine &diags,
+AnalysisManager::AnalysisManager(ASTContext &ASTCtx,
                                  const PathDiagnosticConsumers &PDC,
                                  StoreManagerCreator storemgr,
                                  ConstraintManagerCreator constraintmgr,
                                  CheckerManager *checkerMgr,
                                  AnalyzerOptions &Options,
                                  CodeInjector *injector)
     : AnaCtxMgr(
           ASTCtx, Options.UnoptimizedCFG,
           Options.ShouldIncludeImplicitDtorsInCFG,
           /*addInitializers=*/true,
           Options.ShouldIncludeTemporaryDtorsInCFG,
           Options.ShouldIncludeLifetimeInCFG,
           // Adding LoopExit elements to the CFG is a requirement for loop
           // unrolling.
           Options.ShouldIncludeLoopExitInCFG ||
             Options.ShouldUnrollLoops,
           Options.ShouldIncludeScopesInCFG,
           Options.ShouldSynthesizeBodies,
           Options.ShouldConditionalizeStaticInitializers,
           /*addCXXNewAllocator=*/true,
           Options.ShouldIncludeRichConstructorsInCFG,
           Options.ShouldElideConstructors,
           /*addVirtualBaseBranches=*/true,
           injector),
-      Ctx(ASTCtx), Diags(diags), LangOpts(ASTCtx.getLangOpts()),
+      Ctx(ASTCtx), LangOpts(ASTCtx.getLangOpts()),
       PathConsumers(PDC), CreateStoreMgr(storemgr),
       CreateConstraintMgr(constraintmgr), CheckerMgr(checkerMgr),
       options(Options) {
   AnaCtxMgr.getCFGBuildOptions().setAllAlwaysAdd();
 }
 
 AnalysisManager::~AnalysisManager() {
   FlushDiagnostics();

clang/lib/StaticAnalyzer/Core/BugReporter.cpp

 void BugType::anchor() {}
 
 void BuiltinBug::anchor() {}
 
 //===----------------------------------------------------------------------===//
 // Methods for BugReport and subclasses.
 //===----------------------------------------------------------------------===//
 
-void BugReport::NodeResolver::anchor() {}
-
 void BugReport::addVisitor(std::unique_ptr<BugReporterVisitor> visitor) {
   if (!visitor)
     return;
 
   llvm::FoldingSetNodeID ID;
   visitor->Profile(ID);
 
   void *InsertPos = nullptr;

 //===----------------------------------------------------------------------===//
 // Methods for BugReporter and subclasses.
 //===----------------------------------------------------------------------===//
 
 const ExplodedGraph &PathSensitiveBugReporter::getGraph() const {
   return Eng.getGraph();
 }
 
-ProgramStateManager &PathSensitiveBugReporter::getStateManager() {
-  return Eng.getStateManager();
-}
-
 ProgramStateManager &PathSensitiveBugReporter::getStateManager() const {
   return Eng.getStateManager();
 }
 
 BugReporter::~BugReporter() {
   FlushReports();
 
   // Free the bug reports we are tracking.

 
 //===----------------------------------------------------------------------===//
 // PathDiagnostics generation.
 //===----------------------------------------------------------------------===//
 
 namespace {
 
 /// A wrapper around an ExplodedGraph that contains a single path from the root
 /// to the error node, and a map that maps the nodes in this path to the ones in
 /// the original ExplodedGraph.
 class BugPathInfo {
 public:
-  InterExplodedGraphMap MapToOriginNodes;
   std::unique_ptr<ExplodedGraph> BugPath;
   BugReport *Report;
   const ExplodedNode *ErrorNode;
 };
 
 /// A wrapper around an ExplodedGraph whose leafs are all error nodes. Can
 /// conveniently retrieve bug paths from a single error node to the root.
 class BugPathGetter {
   std::unique_ptr<ExplodedGraph> TrimmedGraph;
 
-  /// Map from the trimmed graph to the original.
-  InterExplodedGraphMap InverseMap;
-
   using PriorityMapTy = llvm::DenseMap<const ExplodedNode *, unsigned>;
 
   /// Assign each node with its distance from the root.
   PriorityMapTy PriorityMap;
 
   /// Since the getErrorNode() or BugReport refers to the original ExplodedGraph,
   /// we need to pair it to the error node of the constructed trimmed graph.
   using ReportNewNodePair = std::pair<BugReport *, const ExplodedNode *>;
assert(I->isValid() &&
            "We only allow BugReporterVisitors and BugReporter itself to "
            "invalidate reports!");
     Nodes.emplace_back(I->getErrorNode());
   }
 
   // The trimmed graph is created in the body of the constructor to ensure
   // that the DenseMaps have been initialized already.
   InterExplodedGraphMap ForwardMap;
-  TrimmedGraph = OriginalGraph->trim(Nodes, &ForwardMap, &InverseMap);
+  TrimmedGraph = OriginalGraph->trim(Nodes, &ForwardMap);
 
   // Find the (first) error node in the trimmed graph.  We just need to consult
   // the node map which maps from nodes in the original graph to nodes
   // in the new graph.
   llvm::SmallPtrSet<const ExplodedNode *, 32> RemainingNodes;
 
   for (BugReport *Report : bugReports) {
     const ExplodedNode *NewNode = ForwardMap.lookup(Report->getErrorNode());
BugPathInfo *BugPathGetter::getNextBugPath() {
   const ExplodedNode *OrigN;
   std::tie(CurrentBugPath.Report, OrigN) = ReportNodes.pop_back_val();
   assert(PriorityMap.find(OrigN) != PriorityMap.end() &&
          "error node not accessible from root");
 
   // Create a new graph with a single path. This is the graph that will be
   // returned to the caller.
   auto GNew = std::make_unique<ExplodedGraph>();
-  CurrentBugPath.MapToOriginNodes.clear();
 
   // Now walk from the error node up the BFS path, always taking the
   // predeccessor with the lowest number.
   ExplodedNode *Succ = nullptr;
   while (true) {
     // Create the equivalent node in the new graph with the same state
     // and location.
     ExplodedNode *NewN = GNew->createUncachedNode(
         OrigN->getLocation(), OrigN->getState(), OrigN->isSink());
 
-    // Store the mapping to the original node.
-    InterExplodedGraphMap::const_iterator IMitr = InverseMap.find(OrigN);
-    assert(IMitr != InverseMap.end() && "No mapping to original node.");
-    CurrentBugPath.MapToOriginNodes[NewN] = IMitr->second;
-
     // Link up the new node with the previous node.
     if (Succ)
       Succ->addPredecessor(NewN, *GNew);
     else
       CurrentBugPath.ErrorNode = NewN;
 
     Succ = NewN;
 
while (BugPathInfo *BugPath = BugGraph.getNextBugPath()) {
     // further analysis is required
     R->addVisitor(std::make_unique<LikelyFalsePositiveSuppressionBRVisitor>());
 
     // Register additional node visitors.
     R->addVisitor(std::make_unique<NilReceiverBRVisitor>());
     R->addVisitor(std::make_unique<ConditionBRVisitor>());
     R->addVisitor(std::make_unique<TagVisitor>());
 
-    BugReporterContext BRC(Reporter, BugPath->MapToOriginNodes);
+    BugReporterContext BRC(Reporter);
 
     // Run all visitors on a given graph, once.
     std::unique_ptr<VisitorsDiagnosticsTy> visitorNotes =
         generateVisitorsDiagnostics(R, ErrorNode, BRC);
 
     if (R->isValid()) {
       if (Reporter.getAnalyzerOptions().ShouldCrosscheckWithZ3) {
         // If crosscheck is enabled, remove all visitors, add the refutation

clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

void FindLastStoreBRVisitor::Profile(llvm::FoldingSetNodeID &ID) const {
   static int tag = 0;
   ID.AddPointer(&tag);
   ID.AddPointer(R);
   ID.Add(V);
   ID.AddInteger(static_cast<int>(TKind));
   ID.AddBoolean(EnableNullFPSuppression);
 }
 
-void FindLastStoreBRVisitor::registerStatementVarDecls(
-    BugReport &BR, const Stmt *S, bool EnableNullFPSuppression,
-    TrackingKind TKind) {
-
-  const ExplodedNode *N = BR.getErrorNode();
-  std::deque<const Stmt *> WorkList;
-  WorkList.push_back(S);
-
-  while (!WorkList.empty()) {
-    const Stmt *Head = WorkList.front();
-    WorkList.pop_front();
-
-    ProgramStateManager &StateMgr = N->getState()->getStateManager();
-
-    if (const auto *DR = dyn_cast<DeclRefExpr>(Head)) {
-      if (const auto *VD = dyn_cast<VarDecl>(DR->getDecl())) {
-        const VarRegion *R =
-        StateMgr.getRegionManager().getVarRegion(VD, N->getLocationContext());
-
-        // What did we load?
-        SVal V = N->getSVal(S);
-
-        if (V.getAs<loc::ConcreteInt>() || V.getAs<nonloc::ConcreteInt>()) {
-          // Register a new visitor with the BugReport.
-          BR.addVisitor(std::make_unique<FindLastStoreBRVisitor>(
-              V.castAs<KnownSVal>(), R, EnableNullFPSuppression, TKind));
-        }
-      }
-    }
-
-    for (const Stmt *SubStmt : Head->children())
-      WorkList.push_back(SubStmt);
-  }
-}
-
 /// Returns true if \p N represents the DeclStmt declaring and initializing
 /// \p VR.
 static bool isInitializationOfVar(const ExplodedNode *N, const VarRegion *VR) {
   Optional<PostStmt> P = N->getLocationAs<PostStmt>();
   if (!P)
     return false;
 
   const DeclStmt *DS = P->getStmtAs<DeclStmt>();

clang/lib/StaticAnalyzer/Core/PathDiagnostic.cpp

 #include <cstring>
 #include <memory>
 #include <utility>
 #include <vector>
 
 using namespace clang;
 using namespace ento;
 
-bool PathDiagnosticMacroPiece::containsEvent() const {
-  for (const auto &P : subPieces) {
-    if (isa<PathDiagnosticEventPiece>(*P))
-      return true;
-    if (const auto *MP = dyn_cast<PathDiagnosticMacroPiece>(P.get()))
-      if (MP->containsEvent())
-        return true;
-  }
-  return false;
-}
-
 static StringRef StripTrailingDots(StringRef s) {
   for (StringRef::size_type i = s.size(); i != 0; --i)
     if (s[i - 1] != '.')
       return s.substr(0, i);
   return {};
 }
 
 PathDiagnosticPiece::PathDiagnosticPiece(StringRef s,

clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp

void DisplayFunction(const Decl *D, AnalysisMode Mode,
     }
   }
 
   void Initialize(ASTContext &Context) override {
     Ctx = &Context;
     checkerMgr = createCheckerManager(
         *Ctx, *Opts, Plugins, CheckerRegistrationFns, PP.getDiagnostics());
 
-    Mgr = std::make_unique<AnalysisManager>(
-        *Ctx, PP.getDiagnostics(), PathConsumers, CreateStoreMgr,
-        CreateConstraintMgr, checkerMgr.get(), *Opts, Injector);
+    Mgr = std::make_unique<AnalysisManager>(*Ctx, PathConsumers, CreateStoreMgr,
+                                            CreateConstraintMgr,
+                                            checkerMgr.get(), *Opts, Injector);
   }
 
   /// Store the top level decls in the set to be processed later on.
   /// (Doing this pre-processing avoids deserialization of data from PCH.)
   bool HandleTopLevelDecl(DeclGroupRef D) override;
   void HandleTopLevelDeclInObjCContainer(DeclGroupRef D) override;
 
   void HandleTranslationUnit(ASTContext &C) override;

clang/unittests/StaticAnalyzer/Reusables.h

 
 protected:
   ExprEngine Eng;
 
 public:
   ExprEngineConsumer(CompilerInstance &C)
       : C(C), ChkMgr(C.getASTContext(), *C.getAnalyzerOpts()), CTU(C),
         Consumers(),
-        AMgr(C.getASTContext(), C.getDiagnostics(), Consumers,
+        AMgr(C.getASTContext(), Consumers,
              CreateRegionStoreManager, CreateRangeConstraintManager, &ChkMgr,
              *C.getAnalyzerOpts()),
         VisitedCallees(), FS(),
         Eng(CTU, AMgr, &VisitedCallees, &FS, ExprEngine::Inline_Regular) {}
 };
 
 } // namespace ento
 } // namespace clang
 
 #endif