[analyzer] Extract InterestingLValueHandler

[NoQ]

clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

2154–2155

I honestly think this code has much bigger problems than that. This code (together with whatever remains in the default handler) is basically what encouraged me to come up with note tags; it's a prime example of a clumsy reverse engineering effort that could be communicated directly instead. Whoever untangles this will forever be ingrained in the history of the static analyzer :D

clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

if (const auto *Arr = dyn_cast<ArraySubscriptExpr>(Inner))
       return getParentTracker().track(
           Arr->getIdx(), LVNode,
           {Opts.Kind, /*EnableNullFPSuppression*/ false});
 
     return {};
   }
 };
 
-class DefaultExpressionHandler final : public ExpressionHandler {
+// TODO: extract it into more handlers
+class InterestingLValueHandler 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();
if (ExplodedGraph::isInterestingLValueExpr(Inner)) {
             // Note that LVNode may be too late (i.e., too far from the
             // InputNode) because the lvalue may have been computed before the
             // inlined call was evaluated. InputNode may as well be too early
             // here, because the symbol is already dead; this, however, is fine
             // because we can still find the node in which it collapsed to null
             // previously.
             Report.addVisitor<SuppressInlineDefensiveChecksVisitor>(*DV,
                                                                     InputNode);
-
         getParentTracker().track(V, R, Opts, SFC);
+      }
+    }
 
-        return Result;
-      }
-    }
+};
+
+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;
 
     // If the expression is not an "lvalue expression", we can still
     // track the constraints on its contents.
     SVal V = LVState->getSValAsScalarOrLoc(Inner, LVNode->getLocationContext());
 
     ReturnVisitor::addVisitorIfNecessary(&getParentTracker(), LVNode, Inner,
                                          Report, Opts.EnableNullFPSuppression,
                                          Opts.Kind);
public:
   }
 };
 
 Tracker::Tracker(PathSensitiveBugReport &Report) : Report(Report) {
   // Default expression handlers.
   addLowPriorityHandler<ControlDependencyHandler>();
   addLowPriorityHandler<NilReceiverHandler>();
   addLowPriorityHandler<ArrayIndexHandler>();
+  addLowPriorityHandler<InterestingLValueHandler>();
   addLowPriorityHandler<DefaultExpressionHandler>();
   addLowPriorityHandler<PRValueHandler>();
   // Default store handlers.
   addHighPriorityHandler<DefaultStoreHandler>();
 }
 
 Tracker::Result Tracker::track(const Expr *E, const ExplodedNode *N,
                                TrackingOptions Opts) {