[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

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.

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

typedef struct {
   B b;
 } C;
 
 void partial_nested_initializer(C *c) {
   c->b.x = 0;
 } // expected-note{{Returning without writing to 'c->b.y'}}
 
 int use_partial_nested_initializer(void) {
-  B localB;
+  B localB; // expected-note{{'localB' initialized here}}
   C localC;
-  localC.b = localB;
+  localC.b = localB; // expected-note{{Uninitialized value stored to 'localC.b.y'}}
   partial_nested_initializer(&localC); // expected-note{{Calling 'partial_nested_initializer'}}
                                        // expected-note@-1{{Returning from 'partial_nested_initializer'}}
   return localC.b.y;                   // expected-warning{{Undefined or garbage value returned to caller}}
                                        // expected-note@-1{{Undefined or garbage value returned to caller}}
 }
 
 void test_subregion_assignment(C* c) {
-  B b;
-  c->b = b;
+  B b; // expected-note{{'b' initialized here}}
+  c->b = b; // expected-note{{Uninitialized value stored to 'c.b.x'}}
 }
 
 int use_subregion_assignment(void) {
   C c;
   test_subregion_assignment(&c); // expected-note{{Calling 'test_subregion_assignment'}}
                                  // expected-note@-1{{Returning from 'test_subregion_assignment'}}
   return c.b.x; // expected-warning{{Undefined or garbage value returned to caller}}
                 // expected-note@-1{{Undefined or garbage value returned to caller}}

clang/test/Analysis/uninit-vals.m

IntPoint2D makeIntPoint2D(int x, int y) {
   result.y = y;
   return result;
 }
 
 void testSmallStructsCopiedPerField(void) {
   IntPoint2D a;
   a.x = 0;
 
-  IntPoint2D b = a;
+  IntPoint2D b = a; // expected-note{{'b.y'}}
   extern void useInt(int);
   useInt(b.x); // no-warning
   useInt(b.y); // expected-warning{{uninitialized}}
                // expected-note@-1{{uninitialized}}
 }
 
 void testLargeStructsNotCopiedPerField(void) {
   IntPoint a;
void testSmallStructBitfields(void) {
   clang_analyzer_eval(b.y == 2); // expected-warning{{TRUE}}
                                  // expected-note@-1{{TRUE}}
 }
 
 void testSmallStructBitfieldsFirstUndef(void) {
   struct {
     int x : 4;
     int y : 4;
-  } a, b;
+  } a, b; // expected-note{{'a' initialized here}}
 
   a.y = 2;
 
-  b = a;
+  b = a; // expected-note{{Uninitialized value stored to 'b.x'}}
   clang_analyzer_eval(b.y == 2); // expected-warning{{TRUE}}
                                  // expected-note@-1{{TRUE}}
   clang_analyzer_eval(b.x == 1); // expected-warning{{garbage}}
                                  // expected-note@-1{{garbage}}
 }
 
 void testSmallStructBitfieldsSecondUndef(void) {
   struct {
     int x : 4;
     int y : 4;
-  } a, b;
+  } a, b; // expected-note{{'a' initialized here}}
 
   a.x = 1;
 
-  b = a;
+  b = a; // expected-note{{Uninitialized value stored to 'b.y'}}
   clang_analyzer_eval(b.x == 1); // expected-warning{{TRUE}}
                                  // expected-note@-1{{TRUE}}
   clang_analyzer_eval(b.y == 2); // expected-warning{{garbage}}
                                  // expected-note@-1{{garbage}}
 }
 
 void testSmallStructBitfieldsFirstUnnamed(void) {
   struct {