[analyzer] Fix tracking expressions through negation operator

[NoQ]

LG.

cfe/trunk/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

do {
       NI = NI->getFirstPred();
     } 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)
+      return peelOffOuterExpr(UO->getSubExpr(), N);
+
   return Ex;
 }
 
 /// Walk through nodes until we get one that matches the statement exactly.
 /// Alternately, if we hit a known lvalue for the statement, we know we've
 /// gone too far (though we can likely track the lvalue better anyway).
 static const ExplodedNode* findNodeForStatement(const ExplodedNode *N,
                                                 const Stmt *S,

cfe/trunk/test/Analysis/diagnostics/no-store-func-path-notes.cpp

 
 int forceElementRegionApperence() {
   HasFieldA a;
   maybeInitializeHasField(&a); // expected-note{{Calling 'maybeInitializeHasField'}}
                                // expected-note@-1{{Returning from 'maybeInitializeHasField'}}
   return ((HasFieldB*)&a)->x; // expected-warning{{Undefined or garbage value returned to caller}}
                               // expected-note@-1{{Undefined or garbage value returned to caller}}
 }
+
+////////
+
+struct HasForgottenField {
+  int x;
+  HasForgottenField() {} // expected-note{{Returning without writing to 'this->x'}}
+};
+
+// Test that tracking across exclamation mark works.
+bool tracksThroughExclamationMark() {
+  HasForgottenField a; // expected-note{{Calling default constructor for 'HasForgottenField'}}
+                       // expected-note@-1{{Returning from default constructor for 'HasForgottenField'}}
+  return !a.x; // expected-warning{{Undefined or garbage value returned to caller}}
+               // expected-note@-1{{Undefined or garbage value returned to caller}}
+}