[Analyzer][NFC] Change parameter of NoteTag lambdas to PathSensitiveBugReport

[baloghadamsoftware]

Summary

Lambdas creating path notes using NoteTags still take BugReport as their parameter. Since path notes obviously only appear in PathSensitiveBugReports it is straightforward that lambdas of NoteTags take PathSensitiveBugReport as their parameter.

[NoQ]

Thanks!!

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

public:
   }
 };
 
 
 /// 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 =
-      std::function<std::string(BugReporterContext &, BugReport &)>;
+      std::function<std::string(BugReporterContext &,
+                                PathSensitiveBugReport &)>;
 
 private:
   static int Kind;
 
   const Callback Cb;
   const bool IsPrunable;
 
   NoteTag(Callback &&Cb, bool IsPrunable)
       : ProgramPointTag(&Kind), Cb(std::move(Cb)), IsPrunable(IsPrunable) {}
 
 public:
   static bool classof(const ProgramPointTag *T) {
     return T->getTagKind() == &Kind;
   }
 
   Optional<std::string> generateMessage(BugReporterContext &BRC,
-                                        BugReport &R) const {
+                                        PathSensitiveBugReport &R) const {
     std::string Msg = Cb(BRC, R);
     if (Msg.empty())
       return None;
 
     return std::move(Msg);
   }
 
   StringRef getTagDescription() const override {

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

public:
 
   /// A shorthand version of getNoteTag that doesn't require you to accept
   /// the 'BugReporterContext' argument when you don't need it.
   ///
   /// @param Cb Callback only with 'BugReport &' parameter.
   /// @param IsPrunable Whether the note is prunable. It allows BugReporter
   ///        to omit the note from the report if it would make the displayed
   ///        bug path significantly shorter.
-  const NoteTag *getNoteTag(std::function<std::string(BugReport &)> &&Cb,
-                            bool IsPrunable = false) {
+  const NoteTag
+  *getNoteTag(std::function<std::string(PathSensitiveBugReport &)> &&Cb,
     return getNoteTag(
-        [Cb](BugReporterContext &, BugReport &BR) { return Cb(BR); },
+        [Cb](BugReporterContext &,
+             PathSensitiveBugReport &BR) { return Cb(BR); },
         IsPrunable);
   }
 
   /// A shorthand version of getNoteTag that doesn't require you to accept
   /// the arguments when you don't need it.
   ///
   /// @param Cb Callback without parameters.
   /// @param IsPrunable Whether the note is prunable. It allows BugReporter
   ///        to omit the note from the report if it would make the displayed
   ///        bug path significantly shorter.
   const NoteTag *getNoteTag(std::function<std::string()> &&Cb,
                             bool IsPrunable = false) {
-    return getNoteTag([Cb](BugReporterContext &, BugReport &) { return Cb(); },
+    return getNoteTag([Cb](BugReporterContext &,
+                           PathSensitiveBugReport &) { return Cb(); },
                       IsPrunable);
   }
 
   /// A shorthand version of getNoteTag that accepts a plain note.
   ///
   /// @param Note The note.
   /// @param IsPrunable Whether the note is prunable. It allows BugReporter
   ///        to omit the note from the report if it would make the displayed
   ///        bug path significantly shorter.
   const NoteTag *getNoteTag(StringRef Note, bool IsPrunable = false) {
     return getNoteTag(
-        [Note](BugReporterContext &, BugReport &) { return std::string(Note); },
+        [Note](BugReporterContext &,
+               PathSensitiveBugReport &) { return std::string(Note); },
         IsPrunable);
   }
 
   /// Returns the word that should be used to refer to the declaration
   /// in the report.
   StringRef getDeclDescription(const Decl *D);
 
   /// Get the declaration of the called function (path-sensitive).

clang/lib/StaticAnalyzer/Checkers/CXXSelfAssignmentChecker.cpp

void CXXSelfAssignmentChecker::checkBeginFunction(CheckerContext &C) const {
   auto &SVB = C.getSValBuilder();
   auto ThisVal =
       State->getSVal(SVB.getCXXThis(MD, LCtx->getStackFrame()));
   auto Param = SVB.makeLoc(State->getRegion(MD->getParamDecl(0), LCtx));
   auto ParamVal = State->getSVal(Param);
 
   ProgramStateRef SelfAssignState = State->bindLoc(Param, ThisVal, LCtx);
   const NoteTag *SelfAssignTag =
-    C.getNoteTag([MD](BugReport &BR) -> std::string {
+    C.getNoteTag([MD](PathSensitiveBugReport &BR) -> std::string {
         SmallString<256> Msg;
         llvm::raw_svector_ostream Out(Msg);
         Out << "Assuming " << MD->getParamDecl(0)->getName() << " == *this";
         return std::string(Out.str());
       });
   C.addTransition(SelfAssignState, SelfAssignTag);
 
   ProgramStateRef NonSelfAssignState = State->bindLoc(Param, ParamVal, LCtx);
   const NoteTag *NonSelfAssignTag =
-    C.getNoteTag([MD](BugReport &BR) -> std::string {
+    C.getNoteTag([MD](PathSensitiveBugReport &BR) -> std::string {
         SmallString<256> Msg;
         llvm::raw_svector_ostream Out(Msg);
         Out << "Assuming " << MD->getParamDecl(0)->getName() << " != *this";
         return std::string(Out.str());
       });
   C.addTransition(NonSelfAssignState, NonSelfAssignTag);
 }
 
 void ento::registerCXXSelfAssignmentChecker(CheckerManager &Mgr) {
   Mgr.registerChecker<CXXSelfAssignmentChecker>();
 }
 
 bool ento::shouldRegisterCXXSelfAssignmentChecker(const LangOptions &LO) {
   return true;
 }

clang/lib/StaticAnalyzer/Checkers/FuchsiaHandleChecker.cpp

if (hasFuchsiaAttr<ReleaseHandleAttr>(PVD)) {
           return "";
       });
       State = State->set<HStateMap>(
           Handle, HandleState::getMaybeAllocated(ResultSymbol));
     }
   }
   const NoteTag *T = nullptr;
   if (!Notes.empty()) {
     T = C.getNoteTag(
-        [this, Notes{std::move(Notes)}](BugReport &BR) -> std::string {
+          [this, Notes{std::move(Notes)}](PathSensitiveBugReport &BR)
+                                                                -> std::string {
           if (&BR.getBugType() != &UseAfterReleaseBugType &&
               &BR.getBugType() != &LeakBugType &&
               &BR.getBugType() != &DoubleReleaseBugType)
             return "";
           for (auto &Note : Notes) {
             std::string Text = Note(BR);
             if (!Text.empty())
               return Text;

clang/lib/StaticAnalyzer/Checkers/MIGChecker.cpp

void MIGChecker::checkPostCall(const CallEvent &Call, CheckerContext &C) const {
 
   ProgramStateRef State = C.getState();
   unsigned ArgIdx = I->second;
   SVal Arg = Call.getArgSVal(ArgIdx);
   const ParmVarDecl *PVD = getOriginParam(Arg, C);
   if (!PVD || State->contains<RefCountedParameters>(PVD))
     return;
 
-  const NoteTag *T = C.getNoteTag([this, PVD](BugReport &BR) -> std::string {
+  const NoteTag *T =
+    C.getNoteTag([this, PVD](PathSensitiveBugReport &BR) -> std::string {
         if (&BR.getBugType() != &BT)
           return "";
         SmallString<64> Str;
         llvm::raw_svector_ostream OS(Str);
         OS << "Value passed through parameter '" << PVD->getName()
            << "\' is deallocated";
         return std::string(OS.str());
       });
   C.addTransition(State->set<ReleasedParameter>(true), T);
 }
 
 // Returns true if V can potentially represent a "successful" kern_return_t.
 static bool mayBeSuccess(SVal V, CheckerContext &C) {
   ProgramStateRef State = C.getState();
 
   // Can V represent KERN_SUCCESS?

clang/lib/StaticAnalyzer/Checkers/ReturnValueChecker.cpp

if (!IsInvariantBreak)
     return;
 
   // If the invariant is broken it is reported by 'checkEndFunction()'.
   if (*IsInvariantBreak)
     return;
 
   std::string Name = getName(Call);
   const NoteTag *CallTag = C.getNoteTag(
-      [Name, ExpectedValue](BugReport &) -> std::string {
+      [Name, ExpectedValue](PathSensitiveBugReport &) -> std::string {
         SmallString<128> Msg;
         llvm::raw_svector_ostream Out(Msg);
 
         Out << '\'' << Name << "' returns "
             << (ExpectedValue ? "true" : "false");
         return std::string(Out.str());
       },
       /*IsPrunable=*/true);

clang/lib/StaticAnalyzer/Core/CoreEngine.cpp

FunctionSummaries->markVisitedBasicBlock(Blk->getBlockID(),
                                            LC->getDecl(),
                                            LC->getCFG()->getNumBlockIDs());
 
   // Display a prunable path note to the user if it's a virtual bases branch
   // and we're taking the path that skips virtual base constructors.
   if (L.getSrc()->getTerminator().isVirtualBaseBranch() &&
       L.getDst() == *L.getSrc()->succ_begin()) {
     ProgramPoint P = L.withTag(getNoteTags().makeNoteTag(
-        [](BugReporterContext &, BugReport &) -> std::string {
+        [](BugReporterContext &, PathSensitiveBugReport &) -> std::string {
           // TODO: Just call out the name of the most derived class
           // when we know it.
           return "Virtual base initialization skipped because "
                  "it has already been handled by the most derived class";
         }, /*IsPrunable=*/true));
     // Perform the transition.
     ExplodedNodeSet Dst;
     NodeBuilder Bldr(Pred, Dst, BuilderCtx);
     Pred = Bldr.generateNode(P, Pred->getState(), Pred);
     if (!Pred)
       return;
   }