[analyzer] Mention whether an event is about a condition in a bug report part 1

Can't add much more to the title! This is part 1, the case where the collapse
point isn't in the condition point is the responsibility of ConditionBRVisitor,
which I'm addressing in part 2.

Differential Revision: https://reviews.llvm.org/D65575

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@369574 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp b/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp
index f864098a22785d87091bb9461ccdb09a740c7433..3dc50627b6f5c6b020a532a5d7d8d66abeb4de6c 100644 (file)
--- a/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp
+++ b/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp
@@ -298,6 +298,7 @@ class NoStoreFuncVisitor final : public BugReporterVisitor {
   MemRegionManager &MmrMgr;
   const SourceManager &SM;
   const PrintingPolicy &PP;
+  bugreporter::TrackingKind TKind;
 
   /// Recursion limit for dereferencing fields when looking for the
   /// region of interest.
@@ -318,10 +319,10 @@ class NoStoreFuncVisitor final : public BugReporterVisitor {
   using RegionVector = SmallVector<const MemRegion *, 5>;
 
 public:
-  NoStoreFuncVisitor(const SubRegion *R)
+  NoStoreFuncVisitor(const SubRegion *R, bugreporter::TrackingKind TKind)
       : RegionOfInterest(R), MmrMgr(*R->getMemRegionManager()),
         SM(MmrMgr.getContext().getSourceManager()),
-        PP(MmrMgr.getContext().getPrintingPolicy()) {}
+        PP(MmrMgr.getContext().getPrintingPolicy()), TKind(TKind) {}
 
   void Profile(llvm::FoldingSetNodeID &ID) const override {
     static int Tag = 0;
@@ -612,6 +613,9 @@ void NoStoreFuncVisitor::findModifyingFrames(const ExplodedNode *N) {
   } while (N);
 }
 
+static llvm::StringLiteral WillBeUsedForACondition =
+    ", which participates in a condition later";
+
 PathDiagnosticPieceRef NoStoreFuncVisitor::maybeEmitNote(
     BugReport &R, const CallEvent &Call, const ExplodedNode *N,
     const RegionVector &FieldChain, const MemRegion *MatchedRegion,
@@ -658,6 +662,8 @@ PathDiagnosticPieceRef NoStoreFuncVisitor::maybeEmitNote(
     return nullptr;
 
   os << "'";
+  if (TKind == bugreporter::TrackingKind::Condition)
+    os << WillBeUsedForACondition;
   return std::make_shared<PathDiagnosticEventPiece>(L, os.str());
 }
 
@@ -1068,6 +1074,9 @@ public:
     if (!L.isValid() || !L.asLocation().isValid())
       return nullptr;
 
+    if (TKind == bugreporter::TrackingKind::Condition)
+      Out << WillBeUsedForACondition;
+
     auto EventPiece = std::make_shared<PathDiagnosticEventPiece>(L, Out.str());
 
     // If we determined that the note is meaningless, make it prunable, and
@@ -1450,6 +1459,9 @@ FindLastStoreBRVisitor::VisitNode(const ExplodedNode *Succ,
   if (os.str().empty())
     showBRDefaultDiagnostics(os, R, V);
 
+  if (TKind == bugreporter::TrackingKind::Condition)
+    os << WillBeUsedForACondition;
+
   // Construct a new PathDiagnosticPiece.
   ProgramPoint P = StoreSite->getLocation();
   PathDiagnosticLocation L;
@@ -1933,7 +1945,7 @@ bool bugreporter::trackExpressionValue(const ExplodedNode *InputNode,
       // Mark both the variable region and its contents as interesting.
       SVal V = LVState->getRawSVal(loc::MemRegionVal(R));
       report.addVisitor(
-          std::make_unique<NoStoreFuncVisitor>(cast<SubRegion>(R)));
+          std::make_unique<NoStoreFuncVisitor>(cast<SubRegion>(R), TKind));
 
       MacroNullReturnSuppressionVisitor::addMacroVisitorIfNecessary(
           LVNode, R, EnableNullFPSuppression, report, V);

diff --git a/test/Analysis/track-control-dependency-conditions.cpp b/test/Analysis/track-control-dependency-conditions.cpp
index e02eb412a809787138b17dc807d12e2e2954299f..5f089b213da93c3cef2889ccc07a1155a24f1e99 100644 (file)
--- a/test/Analysis/track-control-dependency-conditions.cpp
+++ b/test/Analysis/track-control-dependency-conditions.cpp
@@ -29,24 +29,24 @@ int flag;
 bool coin();
 
 void foo() {
-  flag = coin(); // tracking-note{{Value assigned to 'flag'}}
+  flag = coin(); // tracking-note-re{{{{^}}Value assigned to 'flag', which participates in a condition later{{$}}}}
 }
 
 void test() {
-  int *x = 0; // expected-note{{'x' initialized to a null pointer value}}
+  int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}}
   flag = 1;
 
   foo(); // TODO: Add nodes here about flag's value being invalidated.
-  if (flag) // expected-note   {{Assuming 'flag' is 0}}
-            // expected-note@-1{{Taking false branch}}
+  if (flag) // expected-note-re   {{{{^}}Assuming 'flag' is 0{{$}}}}
+            // expected-note-re@-1{{{{^}}Taking false branch{{$}}}}
     x = new int;
 
-  foo(); // tracking-note{{Calling 'foo'}}
-         // tracking-note@-1{{Returning from 'foo'}}
+  foo(); // tracking-note-re{{{{^}}Calling 'foo'{{$}}}}
+         // tracking-note-re@-1{{{{^}}Returning from 'foo'{{$}}}}
 
-  if (flag) // expected-note   {{Assuming 'flag' is not equal to 0}}
-            // expected-note@-1{{Taking true branch}}
-            // debug-note@-2{{Tracking condition 'flag'}}
+  if (flag) // expected-note-re   {{{{^}}Assuming 'flag' is not equal to 0{{$}}}}
+            // expected-note-re@-1{{{{^}}Taking true branch{{$}}}}
+            // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}}
 
     *x = 5; // expected-warning{{Dereference of null pointer}}
             // expected-note@-1{{Dereference of null pointer}}
@@ -58,7 +58,7 @@ int flag;
 bool coin();
 
 void foo() {
-  flag = coin(); // tracking-note{{Value assigned to 'flag'}}
+  flag = coin(); // tracking-note-re{{{{^}}Value assigned to 'flag', which participates in a condition later{{$}}}}
 }
 
 void test() {
@@ -66,18 +66,18 @@ void test() {
   flag = 1;
 
   foo();
-  if (flag) // expected-note   {{Assuming 'flag' is 0}}
-            // expected-note@-1{{Taking false branch}}
+  if (flag) // expected-note-re   {{{{^}}Assuming 'flag' is 0{{$}}}}
+            // expected-note-re@-1{{{{^}}Taking false branch{{$}}}}
     x = new int;
 
-  x = 0; // expected-note{{Null pointer value stored to 'x'}}
+  x = 0; // expected-note-re{{{{^}}Null pointer value stored to 'x'{{$}}}}
 
-  foo(); // tracking-note{{Calling 'foo'}}
-         // tracking-note@-1{{Returning from 'foo'}}
+  foo(); // tracking-note-re{{{{^}}Calling 'foo'{{$}}}}
+         // tracking-note-re@-1{{{{^}}Returning from 'foo'{{$}}}}
 
-  if (flag) // expected-note   {{Assuming 'flag' is not equal to 0}}
-            // expected-note@-1{{Taking true branch}}
-            // debug-note@-2{{Tracking condition 'flag'}}
+  if (flag) // expected-note-re   {{{{^}}Assuming 'flag' is not equal to 0{{$}}}}
+            // expected-note-re@-1{{{{^}}Taking true branch{{$}}}}
+            // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}}
 
     *x = 5; // expected-warning{{Dereference of null pointer}}
             // expected-note@-1{{Dereference of null pointer}}
@@ -90,25 +90,25 @@ bool coin();
 
 void foo() {
   // coin() could write bar, do it's invalidated.
-  flag = coin(); // tracking-note{{Value assigned to 'flag'}}
-                 // tracking-note@-1{{Value assigned to 'bar'}}
+  flag = coin(); // tracking-note-re{{{{^}}Value assigned to 'flag', which participates in a condition later{{$}}}}
+                 // tracking-note-re@-1{{{{^}}Value assigned to 'bar', which participates in a condition later{{$}}}}
 }
 
 int bar;
 
 void test() {
-  int *x = 0; // expected-note{{'x' initialized to a null pointer value}}
+  int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}}
   flag = 1;
 
-  foo(); // tracking-note{{Calling 'foo'}}
-         // tracking-note@-1{{Returning from 'foo'}}
+  foo(); // tracking-note-re{{{{^}}Calling 'foo'{{$}}}}
+         // tracking-note-re@-1{{{{^}}Returning from 'foo'{{$}}}}
 
-  if (bar) // expected-note   {{Assuming 'bar' is not equal to 0}}
-           // expected-note@-1{{Taking true branch}}
-           // debug-note@-2{{Tracking condition 'bar'}}
-    if (flag) // expected-note   {{Assuming 'flag' is not equal to 0}}
-              // expected-note@-1{{Taking true branch}}
-              // debug-note@-2{{Tracking condition 'flag'}}
+  if (bar) // expected-note-re   {{{{^}}Assuming 'bar' is not equal to 0{{$}}}}
+           // expected-note-re@-1{{{{^}}Taking true branch{{$}}}}
+           // debug-note-re@-2{{{{^}}Tracking condition 'bar'{{$}}}}
+    if (flag) // expected-note-re   {{{{^}}Assuming 'flag' is not equal to 0{{$}}}}
+              // expected-note-re@-1{{{{^}}Taking true branch{{$}}}}
+              // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}}
 
       *x = 5; // expected-warning{{Dereference of null pointer}}
               // expected-note@-1{{Dereference of null pointer}}
@@ -125,11 +125,11 @@ bool foo() {
 int bar;
 
 void test() {
-  int *x = 0; // expected-note{{'x' initialized to a null pointer value}}
+  int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}}
 
-  if (int flag = foo()) // debug-note{{Tracking condition 'flag'}}
-                        // expected-note@-1{{Assuming 'flag' is not equal to 0}}
-                        // expected-note@-2{{Taking true branch}}
+  if (int flag = foo()) // debug-note-re{{{{^}}Tracking condition 'flag'{{$}}}}
+                        // expected-note-re@-1{{{{^}}Assuming 'flag' is not equal to 0{{$}}}}
+                        // expected-note-re@-2{{{{^}}Taking true branch{{$}}}}
 
     *x = 5; // expected-warning{{Dereference of null pointer}}
             // expected-note@-1{{Dereference of null pointer}}
@@ -144,12 +144,12 @@ struct ConvertsToBool {
 };
 
 void test() {
-  int *x = 0; // expected-note{{'x' initialized to a null pointer value}}
+  int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}}
 
   if (ConvertsToBool())
-    // debug-note@-1{{Tracking condition 'ConvertsToBool()'}}
-    // expected-note@-2{{Assuming the condition is true}}
-    // expected-note@-3{{Taking true branch}}
+    // debug-note-re@-1{{{{^}}Tracking condition 'ConvertsToBool()'{{$}}}}
+    // expected-note-re@-2{{{{^}}Assuming the condition is true{{$}}}}
+    // expected-note-re@-3{{{{^}}Taking true branch{{$}}}}
     *x = 5; // expected-warning{{Dereference of null pointer}}
             // expected-note@-1{{Dereference of null pointer}}
 }
@@ -159,9 +159,9 @@ void test() {
 namespace note_from_different_but_not_nested_stackframe {
 
 void nullptrDeref(int *ptr, bool True) {
-  if (True) // expected-note{{'True' is true}}
-            // expected-note@-1{{Taking true branch}}
-            // debug-note@-2{{Tracking condition 'True}}
+  if (True) // expected-note-re{{{{^}}'True' is true{{$}}}}
+            // expected-note-re@-1{{{{^}}Taking true branch{{$}}}}
+            // debug-note-re@-2{{{{^}}Tracking condition 'True'{{$}}}}
     *ptr = 5;
   // expected-note@-1{{Dereference of null pointer (loaded from variable 'ptr')}}
   // expected-warning@-2{{Dereference of null pointer (loaded from variable 'ptr')}}
@@ -169,11 +169,11 @@ void nullptrDeref(int *ptr, bool True) {
 
 void f() {
   int *ptr = nullptr;
-  // expected-note@-1{{'ptr' initialized to a null pointer value}}
+  // expected-note-re@-1{{{{^}}'ptr' initialized to a null pointer value{{$}}}}
   bool True = true;
   nullptrDeref(ptr, True);
-  // expected-note@-1{{Passing null pointer value via 1st parameter 'ptr'}}
-  // expected-note@-2{{Calling 'nullptrDeref'}}
+  // expected-note-re@-1{{{{^}}Passing null pointer value via 1st parameter 'ptr'{{$}}}}
+  // expected-note-re@-2{{{{^}}Calling 'nullptrDeref'{{$}}}}
 }
 
 } // end of namespace note_from_different_but_not_nested_stackframe
@@ -184,26 +184,26 @@ bool coin();
 int *getIntPtr();
 
 void storeValue(int **i) {
-  *i = getIntPtr(); // tracking-note{{Value assigned to 'i'}}
+  *i = getIntPtr(); // tracking-note-re{{{{^}}Value assigned to 'i', which participates in a condition later{{$}}}}
 }
 
 int *conjurePointer() {
   int *i;
-  storeValue(&i); // tracking-note{{Calling 'storeValue'}}
-                  // tracking-note@-1{{Returning from 'storeValue'}}
-  return i;       // tracking-note{{Returning pointer (loaded from 'i')}}
+  storeValue(&i); // tracking-note-re{{{{^}}Calling 'storeValue'{{$}}}}
+                  // tracking-note-re@-1{{{{^}}Returning from 'storeValue'{{$}}}}
+  return i; // tracking-note-re{{{{^}}Returning pointer (loaded from 'i'), which participates in a condition later{{$}}}}
 }
 
 void f(int *ptr) {
-  if (ptr) // expected-note{{Assuming 'ptr' is null}}
-           // expected-note@-1{{Taking false branch}}
+  if (ptr) // expected-note-re{{{{^}}Assuming 'ptr' is null{{$}}}}
+           // expected-note-re@-1{{{{^}}Taking false branch{{$}}}}
     ;
   if (!conjurePointer())
-    // tracking-note@-1{{Calling 'conjurePointer'}}
-    // tracking-note@-2{{Returning from 'conjurePointer'}}
-    // debug-note@-3{{Tracking condition '!conjurePointer()'}}
-    // expected-note@-4{{Assuming the condition is true}}
-    // expected-note@-5{{Taking true branch}}
+    // tracking-note-re@-1{{{{^}}Calling 'conjurePointer'{{$}}}}
+    // tracking-note-re@-2{{{{^}}Returning from 'conjurePointer'{{$}}}}
+    // debug-note-re@-3{{{{^}}Tracking condition '!conjurePointer()'{{$}}}}
+    // expected-note-re@-4{{{{^}}Assuming the condition is true{{$}}}}
+    // expected-note-re@-5{{{{^}}Taking true branch{{$}}}}
     *ptr = 5; // expected-warning{{Dereference of null pointer}}
               // expected-note@-1{{Dereference of null pointer}}
 }
@@ -220,13 +220,13 @@ int *conjurePointer() {
 }
 
 void f(int *ptr) {
-  if (ptr) // expected-note{{Assuming 'ptr' is null}}
-           // expected-note@-1{{Taking false branch}}
+  if (ptr) // expected-note-re{{{{^}}Assuming 'ptr' is null{{$}}}}
+           // expected-note-re@-1{{{{^}}Taking false branch{{$}}}}
     ;
   if (!conjurePointer())
-    // debug-note@-1{{Tracking condition '!conjurePointer()'}}
-    // expected-note@-2{{Assuming the condition is true}}
-    // expected-note@-3{{Taking true branch}}
+    // debug-note-re@-1{{{{^}}Tracking condition '!conjurePointer()'{{$}}}}
+    // expected-note-re@-2{{{{^}}Assuming the condition is true{{$}}}}
+    // expected-note-re@-3{{{{^}}Taking true branch{{$}}}}
     *ptr = 5; // expected-warning{{Dereference of null pointer}}
               // expected-note@-1{{Dereference of null pointer}}
 }
@@ -241,12 +241,12 @@ int *cast(void *P) {
 }
 
 void f() {
-  int *x = 0; // expected-note{{'x' initialized to a null pointer value}}
+  int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}}
 
   if (cast(conjure()))
-    // debug-note@-1{{Tracking condition 'cast(conjure())'}}
-    // expected-note@-2{{Assuming the condition is false}}
-    // expected-note@-3{{Taking false branch}}
+    // debug-note-re@-1{{{{^}}Tracking condition 'cast(conjure())'{{$}}}}
+    // expected-note-re@-2{{{{^}}Assuming the condition is false{{$}}}}
+    // expected-note-re@-3{{{{^}}Taking false branch{{$}}}}
     return;
   *x = 5; // expected-warning{{Dereference of null pointer}}
           // expected-note@-1{{Dereference of null pointer}}
@@ -260,13 +260,13 @@ bool coin();
 bool flipCoin() { return coin(); }
 
 void i(int *ptr) {
-  if (ptr) // expected-note{{Assuming 'ptr' is null}}
-           // expected-note@-1{{Taking false branch}}
+  if (ptr) // expected-note-re{{{{^}}Assuming 'ptr' is null{{$}}}}
+           // expected-note-re@-1{{{{^}}Taking false branch{{$}}}}
     ;
   if (!flipCoin())
-    // debug-note@-1{{Tracking condition '!flipCoin()'}}
-    // expected-note@-2{{Assuming the condition is true}}
-    // expected-note@-3{{Taking true branch}}
+    // debug-note-re@-1{{{{^}}Tracking condition '!flipCoin()'{{$}}}}
+    // expected-note-re@-2{{{{^}}Assuming the condition is true{{$}}}}
+    // expected-note-re@-3{{{{^}}Taking true branch{{$}}}}
     *ptr = 5; // expected-warning{{Dereference of null pointer}}
               // expected-note@-1{{Dereference of null pointer}}
 }
@@ -276,23 +276,23 @@ namespace important_returning_value_note {
 bool coin();
 
 bool flipCoin() {
-  if (coin()) // tracking-note{{Assuming the condition is false}}
-              // tracking-note@-1{{Taking false branch}}
-              // debug-note@-2{{Tracking condition 'coin()'}}
+  if (coin()) // tracking-note-re{{{{^}}Assuming the condition is false{{$}}}}
+              // tracking-note-re@-1{{{{^}}Taking false branch{{$}}}}
+              // debug-note-re@-2{{{{^}}Tracking condition 'coin()'{{$}}}}
     return true;
-  return coin(); // tracking-note{{Returning value}}
+  return coin(); // tracking-note-re{{{{^}}Returning value, which participates in a condition later{{$}}}}
 }
 
 void i(int *ptr) {
-  if (ptr) // expected-note{{Assuming 'ptr' is null}}
-           // expected-note@-1{{Taking false branch}}
+  if (ptr) // expected-note-re{{{{^}}Assuming 'ptr' is null{{$}}}}
+           // expected-note-re@-1{{{{^}}Taking false branch{{$}}}}
     ;
   if (!flipCoin())
-    // tracking-note@-1{{Calling 'flipCoin'}}
-    // tracking-note@-2{{Returning from 'flipCoin'}}
-    // debug-note@-3{{Tracking condition '!flipCoin()'}}
-    // expected-note@-4{{Assuming the condition is true}}
-    // expected-note@-5{{Taking true branch}}
+    // tracking-note-re@-1{{{{^}}Calling 'flipCoin'{{$}}}}
+    // tracking-note-re@-2{{{{^}}Returning from 'flipCoin'{{$}}}}
+    // debug-note-re@-3{{{{^}}Tracking condition '!flipCoin()'{{$}}}}
+    // expected-note-re@-4{{{{^}}Assuming the condition is true{{$}}}}
+    // expected-note-re@-5{{{{^}}Taking true branch{{$}}}}
     *ptr = 5; // expected-warning{{Dereference of null pointer}}
               // expected-note@-1{{Dereference of null pointer}}
 }
@@ -307,22 +307,22 @@ struct super_complicated_template_hackery {
 
 bool flipCoin() {
   if (super_complicated_template_hackery::value)
-    // tracking-note@-1{{'value' is false}}
-    // tracking-note@-2{{Taking false branch}}
+    // tracking-note-re@-1{{{{^}}'value' is false{{$}}}}
+    // tracking-note-re@-2{{{{^}}Taking false branch{{$}}}}
     return true;
-  return coin(); // tracking-note{{Returning value}}
+  return coin(); // tracking-note-re{{{{^}}Returning value, which participates in a condition later{{$}}}}
 }
 
 void i(int *ptr) {
-  if (ptr) // expected-note{{Assuming 'ptr' is null}}
-           // expected-note@-1{{Taking false branch}}
+  if (ptr) // expected-note-re{{{{^}}Assuming 'ptr' is null{{$}}}}
+           // expected-note-re@-1{{{{^}}Taking false branch{{$}}}}
     ;
   if (!flipCoin())
-    // tracking-note@-1{{Calling 'flipCoin'}}
-    // tracking-note@-2{{Returning from 'flipCoin'}}
-    // debug-note@-3{{Tracking condition '!flipCoin()'}}
-    // expected-note@-4{{Assuming the condition is true}}
-    // expected-note@-5{{Taking true branch}}
+    // tracking-note-re@-1{{{{^}}Calling 'flipCoin'{{$}}}}
+    // tracking-note-re@-2{{{{^}}Returning from 'flipCoin'{{$}}}}
+    // debug-note-re@-3{{{{^}}Tracking condition '!flipCoin()'{{$}}}}
+    // expected-note-re@-4{{{{^}}Assuming the condition is true{{$}}}}
+    // expected-note-re@-5{{{{^}}Taking true branch{{$}}}}
     *ptr = 5; // expected-warning{{Dereference of null pointer}}
               // expected-note@-1{{Dereference of null pointer}}
 }
@@ -333,10 +333,10 @@ int getInt();
 
 void f() {
   int flag = getInt();
-  int *x = 0; // expected-note{{'x' initialized to a null pointer value}}
-  if (flag) // expected-note{{Assuming 'flag' is not equal to 0}}
-            // expected-note@-1{{Taking true branch}}
-            // debug-note@-2{{Tracking condition 'flag'}}
+  int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}}
+  if (flag) // expected-note-re{{{{^}}Assuming 'flag' is not equal to 0{{$}}}}
+            // expected-note-re@-1{{{{^}}Taking true branch{{$}}}}
+            // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}}
     *x = 5; // expected-warning{{Dereference of null pointer}}
             // expected-note@-1{{Dereference of null pointer}}
 }
@@ -350,10 +350,10 @@ void f(int y) {
   y = 1;
   flag = y;
 
-  int *x = 0; // expected-note{{'x' initialized to a null pointer value}}
-  if (flag) // expected-note{{'flag' is 1}}
-            // expected-note@-1{{Taking true branch}}
-            // debug-note@-2{{Tracking condition 'flag'}}
+  int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}}
+  if (flag) // expected-note-re{{{{^}}'flag' is 1{{$}}}}
+            // expected-note-re@-1{{{{^}}Taking true branch{{$}}}}
+            // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}}
     *x = 5; // expected-warning{{Dereference of null pointer}}
             // expected-note@-1{{Dereference of null pointer}}
 }
@@ -366,18 +366,18 @@ int getInt();
 void foo() {
   int y;
   y = 1;
-  flag = y; // tracking-note{{The value 1 is assigned to 'flag'}}
+  flag = y; // tracking-note-re{{{{^}}The value 1 is assigned to 'flag', which participates in a condition later{{$}}}}
 }
 
 void f(int y) {
-  int *x = 0; // expected-note{{'x' initialized to a null pointer value}}
+  int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}}
 
-  foo(); // tracking-note{{Calling 'foo'}}
-         // tracking-note@-1{{Returning from 'foo'}}
+  foo(); // tracking-note-re{{{{^}}Calling 'foo'{{$}}}}
+         // tracking-note-re@-1{{{{^}}Returning from 'foo'{{$}}}}
 
-  if (flag) // expected-note{{'flag' is 1}}
-            // expected-note@-1{{Taking true branch}}
-            // debug-note@-2{{Tracking condition 'flag'}}
+  if (flag) // expected-note-re{{{{^}}'flag' is 1{{$}}}}
+            // expected-note-re@-1{{{{^}}Taking true branch{{$}}}}
+            // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}}
     *x = 5; // expected-warning{{Dereference of null pointer}}
             // expected-note@-1{{Dereference of null pointer}}
 }
@@ -388,20 +388,20 @@ int flag = 0;
 int getInt();
 
 void foo() {
-  flag = getInt(); // tracking-note{{Value assigned to 'flag'}}
+  flag = getInt(); // tracking-note-re{{{{^}}Value assigned to 'flag', which participates in a condition later{{$}}}}
 }
 
 void f() {
-  int *x = 0; // expected-note{{'x' initialized to a null pointer value}}
+  int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}}
   int y = 0;
 
-  foo(); // tracking-note{{Calling 'foo'}}
-         // tracking-note@-1{{Returning from 'foo'}}
+  foo(); // tracking-note-re{{{{^}}Calling 'foo'{{$}}}}
+         // tracking-note-re@-1{{{{^}}Returning from 'foo'{{$}}}}
   y = flag;
 
-  if (y)    // expected-note{{Assuming 'y' is not equal to 0}}
-            // expected-note@-1{{Taking true branch}}
-            // debug-note@-2{{Tracking condition 'y'}}
+  if (y)    // expected-note-re{{{{^}}Assuming 'y' is not equal to 0{{$}}}}
+            // expected-note-re@-1{{{{^}}Taking true branch{{$}}}}
+            // debug-note-re@-2{{{{^}}Tracking condition 'y'{{$}}}}
     *x = 5; // expected-warning{{Dereference of null pointer}}
             // expected-note@-1{{Dereference of null pointer}}
 }
@@ -412,20 +412,20 @@ namespace collapse_point_not_in_condition {
 [[noreturn]] void halt();
 
 void assert(int b) {
-  if (!b) // tracking-note{{Assuming 'b' is not equal to 0}}
-          // tracking-note@-1{{Taking false branch}}
+  if (!b) // tracking-note-re{{{{^}}Assuming 'b' is not equal to 0{{$}}}}
+          // tracking-note-re@-1{{{{^}}Taking false branch{{$}}}}
     halt();
 }
 
 void f(int flag) {
-  int *x = 0; // expected-note{{'x' initialized to a null pointer value}}
+  int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}}
 
-  assert(flag); // tracking-note{{Calling 'assert'}}
-                // tracking-note@-1{{Returning from 'assert'}}
+  assert(flag); // tracking-note-re{{{{^}}Calling 'assert'{{$}}}}
+                // tracking-note-re@-1{{{{^}}Returning from 'assert'{{$}}}}
 
-  if (flag) // expected-note{{'flag' is not equal to 0}}
-            // expected-note@-1{{Taking true branch}}
-            // debug-note@-2{{Tracking condition 'flag'}}
+  if (flag) // expected-note-re{{{{^}}'flag' is not equal to 0{{$}}}}
+            // expected-note-re@-1{{{{^}}Taking true branch{{$}}}}
+            // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}}
     *x = 5; // expected-warning{{Dereference of null pointer}}
             // expected-note@-1{{Dereference of null pointer}}
 }
@@ -437,22 +437,22 @@ namespace unimportant_write_before_collapse_point {
 [[noreturn]] void halt();
 
 void assert(int b) {
-  if (!b) // tracking-note{{Assuming 'b' is not equal to 0}}
-          // tracking-note@-1{{Taking false branch}}
+  if (!b) // tracking-note-re{{{{^}}Assuming 'b' is not equal to 0{{$}}}}
+          // tracking-note-re@-1{{{{^}}Taking false branch{{$}}}}
     halt();
 }
 int getInt();
 
 void f(int flag) {
-  int *x = 0; // expected-note{{'x' initialized to a null pointer value}}
+  int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}}
 
   flag = getInt();
-  assert(flag); // tracking-note{{Calling 'assert'}}
-                // tracking-note@-1{{Returning from 'assert'}}
+  assert(flag); // tracking-note-re{{{{^}}Calling 'assert'{{$}}}}
+                // tracking-note-re@-1{{{{^}}Returning from 'assert'{{$}}}}
 
-  if (flag) // expected-note{{'flag' is not equal to 0}}
-            // expected-note@-1{{Taking true branch}}
-            // debug-note@-2{{Tracking condition 'flag'}}
+  if (flag) // expected-note-re{{{{^}}'flag' is not equal to 0{{$}}}}
+            // expected-note-re@-1{{{{^}}Taking true branch{{$}}}}
+            // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}}
     *x = 5; // expected-warning{{Dereference of null pointer}}
             // expected-note@-1{{Dereference of null pointer}}
 }
@@ -488,17 +488,17 @@ void bar() {
 }
 
 void f(int flag) {
-  int *x = 0; // expected-note{{'x' initialized to a null pointer value}}
+  int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}}
 
   flag = getInt();
 
   bar();
-  assert(cond1); // expected-note{{Assuming 'cond1' is not equal to 0}}
-                 // expected-note@-1{{'?' condition is true}}
+  assert(cond1); // expected-note-re{{{{^}}Assuming 'cond1' is not equal to 0{{$}}}}
+                 // expected-note-re@-1{{{{^}}'?' condition is true{{$}}}}
 
-  if (flag) // expected-note{{'flag' is not equal to 0}}
-            // expected-note@-1{{Taking true branch}}
-            // debug-note@-2{{Tracking condition 'flag'}}
+  if (flag) // expected-note-re{{{{^}}Assuming 'flag' is not equal to 0{{$}}}}
+            // expected-note-re@-1{{{{^}}Taking true branch{{$}}}}
+            // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}}
     *x = 5; // expected-warning{{Dereference of null pointer}}
             // expected-note@-1{{Dereference of null pointer}}
 }
@@ -525,20 +525,20 @@ void bar() {
 }
 
 void f(int flag) {
-  int *x = 0; // expected-note{{'x' initialized to a null pointer value}}
+  int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}}
 
   flag = getInt();
 
   bar();
   assert(cond1 && cond2);
-  // expected-note@-1{{Assuming 'cond1' is not equal to 0}}
-  // expected-note@-2{{Assuming 'cond2' is not equal to 0}}
-  // expected-note@-3{{'?' condition is true}}
-  // expected-note@-4{{Left side of '&&' is true}}
-
-  if (flag) // expected-note{{'flag' is not equal to 0}}
-            // expected-note@-1{{Taking true branch}}
-            // debug-note@-2{{Tracking condition 'flag'}}
+  // expected-note-re@-1{{{{^}}Assuming 'cond1' is not equal to 0{{$}}}}
+  // expected-note-re@-2{{{{^}}Assuming 'cond2' is not equal to 0{{$}}}}
+  // expected-note-re@-3{{{{^}}'?' condition is true{{$}}}}
+  // expected-note-re@-4{{{{^}}Left side of '&&' is true{{$}}}}
+
+  if (flag) // expected-note-re{{{{^}}Assuming 'flag' is not equal to 0{{$}}}}
+            // expected-note-re@-1{{{{^}}Taking true branch{{$}}}}
+            // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}}
     *x = 5; // expected-warning{{Dereference of null pointer}}
             // expected-note@-1{{Dereference of null pointer}}
 }
@@ -565,18 +565,18 @@ void bar() {
 }
 
 void f(int flag) {
-  int *x = 0; // expected-note{{'x' initialized to a null pointer value}}
+  int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}}
 
   flag = getInt();
 
   bar();
   assert(cond1 || cond2);
-  // expected-note@-1{{Assuming 'cond1' is not equal to 0}}
-  // expected-note@-2{{Left side of '||' is true}}
+  // expected-note-re@-1{{{{^}}Assuming 'cond1' is not equal to 0{{$}}}}
+  // expected-note-re@-2{{{{^}}Left side of '||' is true{{$}}}}
 
-  if (flag) // expected-note{{'flag' is not equal to 0}}
-            // expected-note@-1{{Taking true branch}}
-            // debug-note@-2{{Tracking condition 'flag'}}
+  if (flag) // expected-note-re{{{{^}}Assuming 'flag' is not equal to 0{{$}}}}
+            // expected-note-re@-1{{{{^}}Taking true branch{{$}}}}
+            // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}}
     *x = 5; // expected-warning{{Dereference of null pointer}}
             // expected-note@-1{{Dereference of null pointer}}
 }
@@ -604,18 +604,18 @@ void bar() {
 }
 
 void f(int flag) {
-  int *x = 0; // expected-note{{'x' initialized to a null pointer value}}
+  int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}}
 
   flag = getInt();
 
   bar();
-  assert(cond1); // expected-note{{Assuming 'cond1' is not equal to 0}}
-                 // expected-note@-1{{Taking false branch}}
-                 // expected-note@-2{{Loop condition is false.  Exiting loop}}
+  assert(cond1); // expected-note-re{{{{^}}Assuming 'cond1' is not equal to 0{{$}}}}
+                 // expected-note-re@-1{{{{^}}Taking false branch{{$}}}}
+                 // expected-note-re@-2{{{{^}}Loop condition is false.  Exiting loop{{$}}}}
 
-  if (flag) // expected-note{{'flag' is not equal to 0}}
-            // expected-note@-1{{Taking true branch}}
-            // debug-note@-2{{Tracking condition 'flag'}}
+  if (flag) // expected-note-re{{{{^}}Assuming 'flag' is not equal to 0{{$}}}}
+            // expected-note-re@-1{{{{^}}Taking true branch{{$}}}}
+            // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}}
     *x = 5; // expected-warning{{Dereference of null pointer}}
             // expected-note@-1{{Dereference of null pointer}}
 }
@@ -645,21 +645,21 @@ void bar() {
 }
 
 void f(int flag) {
-  int *x = 0; // expected-note{{'x' initialized to a null pointer value}}
+  int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}}
 
   flag = getInt();
 
   bar();
   assert(cond1 && cond2);
-  // expected-note@-1{{Assuming 'cond1' is not equal to 0}}
-  // expected-note@-2{{Left side of '&&' is true}}
-  // expected-note@-3{{Assuming the condition is false}}
-  // expected-note@-4{{Taking false branch}}
-  // expected-note@-5{{Loop condition is false.  Exiting loop}}
-
-  if (flag) // expected-note{{'flag' is not equal to 0}}
-            // expected-note@-1{{Taking true branch}}
-            // debug-note@-2{{Tracking condition 'flag'}}
+  // expected-note-re@-1{{{{^}}Assuming 'cond1' is not equal to 0{{$}}}}
+  // expected-note-re@-2{{{{^}}Left side of '&&' is true{{$}}}}
+  // expected-note-re@-3{{{{^}}Assuming the condition is false{{$}}}}
+  // expected-note-re@-4{{{{^}}Taking false branch{{$}}}}
+  // expected-note-re@-5{{{{^}}Loop condition is false.  Exiting loop{{$}}}}
+
+  if (flag) // expected-note-re{{{{^}}Assuming 'flag' is not equal to 0{{$}}}}
+            // expected-note-re@-1{{{{^}}Taking true branch{{$}}}}
+            // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}}
     *x = 5; // expected-warning{{Dereference of null pointer}}
             // expected-note@-1{{Dereference of null pointer}}
 }
@@ -689,20 +689,20 @@ void bar() {
 }
 
 void f(int flag) {
-  int *x = 0; // expected-note{{'x' initialized to a null pointer value}}
+  int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}}
 
   flag = getInt();
 
   bar();
   assert(cond1 || cond2);
-  // expected-note@-1{{Assuming 'cond1' is not equal to 0}}
-  // expected-note@-2{{Left side of '||' is true}}
-  // expected-note@-3{{Taking false branch}}
-  // expected-note@-4{{Loop condition is false.  Exiting loop}}
-
-  if (flag) // expected-note{{'flag' is not equal to 0}}
-            // expected-note@-1{{Taking true branch}}
-            // debug-note@-2{{Tracking condition 'flag'}}
+  // expected-note-re@-1{{{{^}}Assuming 'cond1' is not equal to 0{{$}}}}
+  // expected-note-re@-2{{{{^}}Left side of '||' is true{{$}}}}
+  // expected-note-re@-3{{{{^}}Taking false branch{{$}}}}
+  // expected-note-re@-4{{{{^}}Loop condition is false.  Exiting loop{{$}}}}
+
+  if (flag) // expected-note-re{{{{^}}Assuming 'flag' is not equal to 0{{$}}}}
+            // expected-note-re@-1{{{{^}}Taking true branch{{$}}}}
+            // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}}
     *x = 5; // expected-warning{{Dereference of null pointer}}
             // expected-note@-1{{Dereference of null pointer}}
 }
@@ -715,7 +715,7 @@ namespace only_track_the_evaluated_condition {
 bool coin();
 
 void bar(int &flag) {
-  flag = coin(); // tracking-note{{Value assigned to 'flag'}}
+  flag = coin(); // tracking-note-re{{{{^}}Value assigned to 'flag', which participates in a condition later{{$}}}}
 }
 
 void bar2(int &flag2) {
@@ -723,19 +723,19 @@ void bar2(int &flag2) {
 }
 
 void f(int *x) {
-  if (x) // expected-note{{Assuming 'x' is null}}
-         // debug-note@-1{{Tracking condition 'x'}}
-         // expected-note@-2{{Taking false branch}}
+  if (x) // expected-note-re{{{{^}}Assuming 'x' is null{{$}}}}
+         // debug-note-re@-1{{{{^}}Tracking condition 'x'{{$}}}}
+         // expected-note-re@-2{{{{^}}Taking false branch{{$}}}}
     return;
 
   int flag, flag2;
-  bar(flag); // tracking-note{{Calling 'bar'}}
-             // tracking-note@-1{{Returning from 'bar'}}
+  bar(flag); // tracking-note-re{{{{^}}Calling 'bar'{{$}}}}
+             // tracking-note-re@-1{{{{^}}Returning from 'bar'{{$}}}}
   bar2(flag2);
 
-  if (flag && flag2) // expected-note   {{Assuming 'flag' is 0}}
-                     // expected-note@-1{{Left side of '&&' is false}}
-                     // debug-note@-2{{Tracking condition 'flag'}}
+  if (flag && flag2) // expected-note-re   {{{{^}}Assuming 'flag' is 0{{$}}}}
+                     // expected-note-re@-1{{{{^}}Left side of '&&' is false{{$}}}}
+                     // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}}
     return;
 
   *x = 5; // expected-warning{{Dereference of null pointer}}