[analyzer] Extract ArrayIndexHandler

[vsavchenko]

Summary

One interesting problem was discovered here. When we do interrupt
Tracker's track flow, we want to interrupt only it and not all the
other flows recursively.

[vsavchenko]

Rebase

[NoQ]

Nice and clean, thanks!

clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

Tracker::Result handle(const Expr *Inner, const ExplodedNode *InputNode,
     if (const Expr *Receiver =
             NilReceiverBRVisitor::getNilReceiver(Inner, LVNode))
       return getParentTracker().track(Receiver, LVNode, Opts);
 
     return {};
   }
 };
 
+class ArrayIndexHandler final : public ExpressionHandler {
+public:
+  using ExpressionHandler::ExpressionHandler;
+
+  Tracker::Result handle(const Expr *Inner, const ExplodedNode *InputNode,
+                         const ExplodedNode *LVNode,
+                         TrackingOptions Opts) override {
+    // Track the index if this is an array subscript.
+    if (const auto *Arr = dyn_cast<ArraySubscriptExpr>(Inner))
+      return getParentTracker().track(
+          Arr->getIdx(), LVNode,
+          {Opts.Kind, /*EnableNullFPSuppression*/ false});
+
+    return {};
+  }
+};
+
 class DefaultExpressionHandler final : public ExpressionHandler {
 public:
   using ExpressionHandler::ExpressionHandler;
 
   Tracker::Result handle(const Expr *Inner, const ExplodedNode *InputNode,
                          const ExplodedNode *LVNode,
                          TrackingOptions Opts) override {
     ProgramStateRef LVState = LVNode->getState();
     const StackFrameContext *SFC = LVNode->getStackFrame();
     PathSensitiveBugReport &Report = getParentTracker().getReport();
     Tracker::Result Result;
 
-    // Track the index if this is an array subscript.
-    if (const auto *Arr = dyn_cast<ArraySubscriptExpr>(Inner))
-      Result.combineWith(getParentTracker().track(
-          Arr->getIdx(), LVNode,
-          {Opts.Kind, /*EnableNullFPSuppression*/ false}));
-
     // See if the expression we're interested refers to a variable.
     // If so, we can track both its contents and constraints on its value.
     if (ExplodedGraph::isInterestingLValueExpr(Inner)) {
       SVal LVal = LVNode->getSVal(Inner);
 
       const MemRegion *RR = getLocationRegionIfReference(Inner, LVNode);
       bool LVIsNull = LVState->isNull(LVal).isConstrainedTrue();
 
Tracker::Result handle(const Expr *E, const ExplodedNode *InputNode,
     return CombinedResult;
   }
 };
 
 Tracker::Tracker(PathSensitiveBugReport &Report) : Report(Report) {
   // Default expression handlers.
   addLowPriorityHandler<ControlDependencyHandler>();
   addLowPriorityHandler<NilReceiverHandler>();
+  addLowPriorityHandler<ArrayIndexHandler>();
   addLowPriorityHandler<DefaultExpressionHandler>();
   addLowPriorityHandler<RValueHandler>();
   // Default store handlers.
   addHighPriorityHandler<DefaultStoreHandler>();
 }
 
 Tracker::Result Tracker::track(const Expr *E, const ExplodedNode *N,
                                TrackingOptions Opts) {
   if (!E || !N)
     return {};
 
   const Expr *Inner = peelOffOuterExpr(E, N);
   const ExplodedNode *LVNode = findNodeForExpression(N, Inner);
   if (!LVNode)
     return {};
 
   Result CombinedResult;
   // Iterate through the handlers in the order according to their priorities.
   for (ExpressionHandlerPtr &Handler : ExpressionHandlers) {
     CombinedResult.combineWith(Handler->handle(Inner, N, LVNode, Opts));
-    if (CombinedResult.WasInterrupted)
+    if (CombinedResult.WasInterrupted) {
+      // There is no need to confuse our users here.
+      // We got interrupted, but our users don't need to know about it.
+      CombinedResult.WasInterrupted = false;
       break;
     }
+  }
 
   return CombinedResult;
 }
 
 Tracker::Result Tracker::track(SVal V, const MemRegion *R, TrackingOptions Opts,
                                const StackFrameContext *Origin) {
   if (auto KV = V.getAs<KnownSVal>()) {
     Report.addVisitor<StoreSiteFinder>(this, *KV, R, Opts, Origin);