[analyzer] Hide and rename FindLastStoreBRVisitor

[vsavchenko]

Summary

This component should not be used directly at this point and it is
simply an implementation detail, that's why StoreSiteFinder is
out of the header file.

[vsavchenko]

Rebase

[NoQ]

Excellent!

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

 void trackStoredValue(KnownSVal V, const MemRegion *R,
                       PathSensitiveBugReport &Report, TrackingOptions Opts = {},
                       const StackFrameContext *Origin = nullptr);
 
 const Expr *getDerefExpr(const Stmt *S);
 
 } // namespace bugreporter
 
-/// Finds last store into the given region,
-/// which is different from a given symbolic value.
-class FindLastStoreBRVisitor final
-    : public bugreporter::TrackingBugReporterVisitor {
-  const MemRegion *R;
-  SVal V;
-  bool Satisfied = false;
-
-  /// If the visitor is tracking the value directly responsible for the
-  /// bug, we are going to employ false positive suppression.
-  bool EnableNullFPSuppression;
-
-  using TrackingKind = bugreporter::TrackingKind;
-  TrackingKind TKind;
-  const StackFrameContext *OriginSFC;
-
-public:
-  /// \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
-  ///        this visitor can prevent that without polluting the bugpath too
-  ///        much.
-  FindLastStoreBRVisitor(bugreporter::TrackerRef ParentTracker, KnownSVal V,
-                         const MemRegion *R, bool InEnableNullFPSuppression,
-                         TrackingKind TKind,
-                         const StackFrameContext *OriginSFC = nullptr)
-      : TrackingBugReporterVisitor(ParentTracker), R(R), V(V),
-        EnableNullFPSuppression(InEnableNullFPSuppression), TKind(TKind),
-        OriginSFC(OriginSFC) {
-    assert(R);
-  }
-
-  void Profile(llvm::FoldingSetNodeID &ID) const override;
-
-  PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
-                                   BugReporterContext &BRC,
-                                   PathSensitiveBugReport &BR) override;
-};
-
 class TrackConstraintBRVisitor final : public BugReporterVisitor {
   DefinedSVal Constraint;
   bool Assumption;
   bool IsSatisfied = false;
   bool IsZeroCheck;
 
   /// We should start tracking from the last node along the path in which the
   /// value is constrained.

clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

void finalizeVisitor(BugReporterContext &, const ExplodedNode *,
     if (EnableNullFPSuppression && ShouldInvalidate)
       BR.markInvalid(ReturnVisitor::getTag(), CalleeSFC);
   }
 };
 
 } // end of anonymous namespace
 
 //===----------------------------------------------------------------------===//
-// Implementation of FindLastStoreBRVisitor.
+//                               StoreSiteFinder
 //===----------------------------------------------------------------------===//
 
-void FindLastStoreBRVisitor::Profile(llvm::FoldingSetNodeID &ID) const {
+/// Finds last store into the given region,
+/// which is different from a given symbolic value.
+class StoreSiteFinder final : public TrackingBugReporterVisitor {
+  const MemRegion *R;
+  SVal V;
+  bool Satisfied = false;
+
+  /// If the visitor is tracking the value directly responsible for the
+  /// bug, we are going to employ false positive suppression.
+  bool EnableNullFPSuppression;
+
+  using TrackingKind = bugreporter::TrackingKind;
+  TrackingKind TKind;
+  const StackFrameContext *OriginSFC;
+
+public:
+  /// \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
+  ///        this visitor can prevent that without polluting the bugpath too
+  ///        much.
+  StoreSiteFinder(bugreporter::TrackerRef ParentTracker, KnownSVal V,
+                  const MemRegion *R, bool InEnableNullFPSuppression,
+                  TrackingKind TKind,
+                  const StackFrameContext *OriginSFC = nullptr)
+      : TrackingBugReporterVisitor(ParentTracker), R(R), V(V),
+        EnableNullFPSuppression(InEnableNullFPSuppression), TKind(TKind),
+        OriginSFC(OriginSFC) {
+    assert(R);
+  }
+
+  void Profile(llvm::FoldingSetNodeID &ID) const override;
+
+  PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
+                                   BugReporterContext &BRC,
+                                   PathSensitiveBugReport &BR) override;
+};
+
+void StoreSiteFinder::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);
 }
 
static void showBRDefaultDiagnostics(llvm::raw_svector_ostream &os,
   }
 
   if (NewR->canPrintPretty()) {
     os << " to ";
     NewR->printPretty(os);
   }
 }
 
-PathDiagnosticPieceRef
-FindLastStoreBRVisitor::VisitNode(const ExplodedNode *Succ,
+PathDiagnosticPieceRef StoreSiteFinder::VisitNode(const ExplodedNode *Succ,
                                                   BugReporterContext &BRC,
                                                   PathSensitiveBugReport &BR) {
   if (Satisfied)
     return nullptr;
 
   const ExplodedNode *StoreSite = nullptr;
   const ExplodedNode *Pred = Succ->getFirstPred();
   const Expr *InitE = nullptr;
   bool IsParam = false;
 
Tracker::Result Tracker::track(const Expr *E, const ExplodedNode *N,
   }
 
   return CombinedResult;
 }
 
 Tracker::Result Tracker::track(KnownSVal V, const MemRegion *R,
                                TrackingOptions Opts,
                                const StackFrameContext *Origin) {
-  Report.addVisitor<FindLastStoreBRVisitor>(
-      this, V, R, Opts.EnableNullFPSuppression, Opts.Kind, Origin);
+  Report.addVisitor<StoreSiteFinder>(this, V, R, Opts.EnableNullFPSuppression,
+                                     Opts.Kind, Origin);
   return {true, false};
 }
 
 PathDiagnosticPieceRef Tracker::handle(StoreInfo SI, TrackingOptions Opts) {
   // Iterate through the handlers in the order according to their priorities.
   for (StoreHandlerPtr &Handler : StoreHandlers) {
     if (PathDiagnosticPieceRef Result = Handler->handle(SI, Opts))
       // If the handler produced a non-null piece, return it.