[analyzer] Refactor trackExpressionValue to accept TrackingOptions

[vsavchenko]

Rebase

[vsavchenko]

Rebase

[NoQ]

clang/lib/StaticAnalyzer/Checkers/MIGChecker.cpp

288

I think false deserves a /*comment=*/.

[vsavchenko]

Rebase

[vsavchenko]

Rebase

[vsavchenko]

Oof, I also screwed up rebasing this commit as well.

[vsavchenko]

Remove unintnentionally merged changes from the next commit

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

 /// \param R The bug report to which visitors should be attached.
 /// \param EnableNullFPSuppression Whether we should employ false positive
 ///         suppression (inlined defensive checks, returned null).
 ///
 /// \return Whether or not the function was able to add visitors for this
 ///         statement. Note that returning \c true does not actually imply
 ///         that any visitors were added.
 bool trackExpressionValue(const ExplodedNode *N, const Expr *E,
-                          PathSensitiveBugReport &R,
-                          TrackingKind TKind = TrackingKind::Thorough,
-                          bool EnableNullFPSuppression = true);
+                          PathSensitiveBugReport &R, TrackingOptions Opts = {});
 
 /// Track how the value got stored into the given region and where it came
 /// from.
 ///
 /// \param V We're searching for the store where \c R received this value.
 /// \param R The region we're tracking.
 /// \param Opts Tracking options specifying how we want to track the value.
 /// \param Origin Only adds notes when the last store happened in a

clang/lib/StaticAnalyzer/Checkers/MIGChecker.cpp

void MIGChecker::checkReturnAux(const ReturnStmt *RS, CheckerContext &C) const {
   auto R = std::make_unique<PathSensitiveBugReport>(
       BT,
       "MIG callback fails with error after deallocating argument value. "
       "This is a use-after-free vulnerability because the caller will try to "
       "deallocate it again",
       N);
 
   R->addRange(RS->getSourceRange());
-  bugreporter::trackExpressionValue(N, RS->getRetValue(), *R,
-                                    bugreporter::TrackingKind::Thorough, false);
+  bugreporter::trackExpressionValue(
+      N, RS->getRetValue(), *R,
+      {bugreporter::TrackingKind::Thorough, /*EnableNullFPSuppression=*/false});
   C.emitReport(std::move(R));
 }
 
 void ento::registerMIGChecker(CheckerManager &Mgr) {
   Mgr.registerChecker<MIGChecker>();
 }
 
 bool ento::shouldRegisterMIGChecker(const CheckerManager &mgr) {
   return true;
 }

clang/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp

if (Name.equals("CFArrayGetValueAtIndex")) {
     if (StOutBound && !StInBound) {
       ExplodedNode *N = C.generateErrorNode(StOutBound);
       if (!N)
         return;
       initBugType();
       auto R = std::make_unique<PathSensitiveBugReport>(
           *BT, "Index is out of bounds", N);
       R->addRange(IdxExpr->getSourceRange());
-      bugreporter::trackExpressionValue(
-          N, IdxExpr, *R, bugreporter::TrackingKind::Thorough, false);
+      bugreporter::trackExpressionValue(N, IdxExpr, *R,
+                                        {bugreporter::TrackingKind::Thorough,
+                                         /*EnableNullFPSuppression=*/false});
       C.emitReport(std::move(R));
       return;
     }
   }
 }
 
 ProgramStateRef
 ObjCContainersChecker::checkPointerEscape(ProgramStateRef State,

clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

if (PathDiagnosticPieceRef Result = Handler->handle(SI, Opts))
       // There is no need in asking other handlers.
       return Result;
   }
   return {};
 }
 
 bool bugreporter::trackExpressionValue(const ExplodedNode *InputNode,
                                        const Expr *E,
-                                       PathSensitiveBugReport &report,
-                                       bugreporter::TrackingKind TKind,
-                                       bool EnableNullFPSuppression) {
-  return Tracker::create(report)
-      ->track(E, InputNode, {TKind, EnableNullFPSuppression})
+
+                                       PathSensitiveBugReport &Report,
+                                       TrackingOptions Opts) {
+  return Tracker::create(Report)
+      ->track(E, InputNode, Opts)
       .FoundSomethingToTrack;
 }
 
 void bugreporter::trackStoredValue(KnownSVal V, const MemRegion *R,
                                    PathSensitiveBugReport &Report,
                                    TrackingOptions Opts,
                                    const StackFrameContext *Origin) {
   Tracker::create(Report)->track(V, R, Opts, Origin);
NilReceiverBRVisitor::VisitNode(const ExplodedNode *N, BugReporterContext &BRC,
   else {
     OS << "No method is called";
   }
   OS << " because the receiver is nil";
 
   // The receiver was nil, and hence the method was skipped.
   // Register a BugReporterVisitor to issue a message telling us how
   // the receiver was null.
-  bugreporter::trackExpressionValue(
-      N, Receiver, BR, bugreporter::TrackingKind::Thorough,
-      /*EnableNullFPSuppression*/ false);
+  bugreporter::trackExpressionValue(N, Receiver, BR,
+                                    {bugreporter::TrackingKind::Thorough,
+                                     /*EnableNullFPSuppression*/ false});
   // Issue a message saying that the method was skipped.
   PathDiagnosticLocation L(Receiver, BRC.getSourceManager(),
                                      N->getLocationContext());
   return std::make_shared<PathDiagnosticEventPiece>(L, OS.str());
 }
 
 //===----------------------------------------------------------------------===//
 // Visitor that tries to report interesting diagnostics from conditions.