[analyzer][draft] Increase the accuracy of bug reports

[isuckatcs]

Updated the test files

[NoQ]

LGTM!

I think this can be made more precise, but generally this is valuable as is.

clang/test/Analysis/diagnostics/no-store-func-path-notes.c

163 ↗

(On Diff #457608)

I think we should leave a TODO that ideally this should say

'localB.y' initialized here

(and ideally it's the region of field y that needs to be tracked further)

[isuckatcs]

I would wait with commiting this until everything is addressed. The purpose of this patch was to quickly find a way to
get access to more information so that we might figure out whether the results from D132752 are true or false positives.

clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

PathDiagnosticPieceRef StoreSiteFinder::VisitNode(const ExplodedNode *Succ,
   // (2) Succ has this binding and is a PostStore node for this region, i.e.
   //     the same binding was re-assigned here.
   if (!StoreSite) {
     if (Succ->getState()->getSVal(R) != V)
       return nullptr;
 
     if (hasVisibleUpdate(Pred, Pred->getState()->getSVal(R), Succ, V)) {
       Optional<PostStore> PS = Succ->getLocationAs<PostStore>();
-      if (!PS || PS->getLocationValue() != R)
+      if (!PS)
+        return nullptr;
+
+      const auto *LPtr = PS->getLocationValue();
+      if (!LPtr)
+        return nullptr;
+      const auto *L = reinterpret_cast<const MemRegion *>(LPtr);
+
+      if (PS->getLocationValue() != R && !R->isSubRegionOf(L))
         return nullptr;
     }
 
     StoreSite = Succ;
 
     if (Optional<PostStmt> P = Succ->getLocationAs<PostStmt>()) {
       // If this is an assignment expression, we can track the value
       // being assigned.
       if (const BinaryOperator *BO = P->getStmtAs<BinaryOperator>()) {
         if (BO->isAssignmentOp())
           InitE = BO->getRHS();
+      } else if (const CXXOperatorCallExpr *CE =
+                     P->getStmtAs<CXXOperatorCallExpr>()) {
+        if (CE->isAssignmentOp())
+          InitE = CE->getArg(1);
       }
+
       // If we have a declaration like 'S s{1,2}' that needs special
       // handling, we handle it here.
       else if (const auto *DS = P->getStmtAs<DeclStmt>()) {
         const auto *Decl = DS->getSingleDecl();
         if (isa<VarDecl>(Decl)) {
           const auto *VD = cast<VarDecl>(Decl);
 
           // FIXME: Here we only track the inner most region, so we lose
if (const auto *CO = dyn_cast<ConditionalOperator>(Ex)) {
     } while (NI);
   }
 
   if (auto *BO = dyn_cast<BinaryOperator>(Ex))
     if (const Expr *SubEx = peelOffPointerArithmetic(BO))
       return peelOffOuterExpr(SubEx, N);
 
   if (auto *UO = dyn_cast<UnaryOperator>(Ex)) {
-    if (UO->getOpcode() == UO_LNot)
+    if (UO->getOpcode() == UO_LNot || UO->getOpcode() == clang::UO_Minus)
       return peelOffOuterExpr(UO->getSubExpr(), N);
 
     // FIXME: There's a hack in our Store implementation that always computes
     // field offsets around null pointers as if they are always equal to 0.
     // The idea here is to report accesses to fields as null dereferences
     // even though the pointer value that's being dereferenced is actually
     // the offset of the field rather than exactly 0.
     // See the FIXME in StoreManager's getLValueFieldOrIvar() method.