[analyzer] NFC: Use -verify=... in MoveChecker tests.

[NoQ]

Summary

Just wanted to give a bit more visibility to the underrated technology of writing -verify=a,b,c instead of the #ifdefclutter.

It's also a bit wonky because it seems that you have to write an exponential number of flags to verify in order to have full flexibility (which is why i didn't update the #ifdef DFS test), but it still seems to be much better in most cases.

[Charusso]

I think this functionality is unused because you would split the file into six to reduce the overhead/scroll and that is it.

It is a cool reveal, could you provide a documentation?

[riccibruno]

This is also very useful to test that a given warning is only emitted in c++xx. Funnily when grepping for verify= in test/ most matches are from tests exercising this functionality.

[jdenny]

Just wanted to give a bit more visibility to the underrated technology of writing -verify=a,b,c instead of the #ifdefclutter.

It's great to see this getting more use.

It's also a bit wonky because it seems that you have to write an exponential number of flags to verify in order to have full flexibility (which is why i didn't update the #ifdef DFS test), but it still seems to be much better in most cases.

Sometimes you can avoid an explosion of FileCheck prefixes using -D. I'm not aware of anything like -D for -verify.

In D60732#1467504, @Charusso wrote:

It is a cool reveal, could you provide a documentation?

The original patch added documentation to -cc1 -help. Doxygen for VerifyDiagnosticConsumer is another possibility except it currently doesn't mention command-line usage at all. Maybe it should?

[jdenny]

In D60732#1469026, @jdenny wrote:

Sometimes you can avoid an explosion of FileCheck prefixes using -D. I'm not aware of anything like -D for -verify.

I mean a -D that expands a variable within an expected diagnostic.

[NoQ]

In D60732#1469026, @jdenny wrote:

The original patch added documentation to -cc1 -help. Doxygen for VerifyDiagnosticConsumer is another possibility except it currently doesn't mention command-line usage at all. Maybe it should?

I would have definitely discovered this feature earlier if it was mentioned on the doxygen page for VerifyDiagnosticConsumer!

In D60732#1467504, @Charusso wrote:

I think this functionality is unused because you would split the file into six to reduce the overhead/scroll and that is it.

The current test tests all 6 modes on all functions, that's a lot of coverage. You can't obtain the same coverage by splitting the file into mode-specific tests; you'd have to duplicate all code in all files, is much harder to maintain than #ifdefs. It would probably still be easier to read, but the constant fear that the files aren't actually identical pretty much defeats the purpose.

cfe/trunk/test/Analysis/use-after-move.cpp

-// RUN: %clang_analyze_cc1 -analyzer-checker=cplusplus.Move -verify %s\
+// RUN: %clang_analyze_cc1 -analyzer-checker=cplusplus.Move %s\
 // RUN:  -std=c++11 -analyzer-output=text -analyzer-config eagerly-assume=false\
 // RUN:  -analyzer-config exploration_strategy=unexplored_first_queue\
-// RUN:  -analyzer-checker debug.ExprInspection
-// RUN: %clang_analyze_cc1 -analyzer-checker=cplusplus.Move -verify %s\
+// RUN:  -analyzer-checker debug.ExprInspection\
+// RUN:  -verify=expected,peaceful,non-aggressive
+// RUN: %clang_analyze_cc1 -analyzer-checker=cplusplus.Move %s\
 // RUN:  -std=c++11 -analyzer-output=text -analyzer-config eagerly-assume=false\
-// RUN:  -analyzer-config exploration_strategy=dfs -DDFS=1\
-// RUN:  -analyzer-checker debug.ExprInspection
-// RUN: %clang_analyze_cc1 -analyzer-checker=cplusplus.Move -verify %s\
+// RUN:  -analyzer-config exploration_strategy=dfs -DDFS\
+// RUN:  -analyzer-checker debug.ExprInspection\
+// RUN:  -verify=expected,peaceful,non-aggressive
+// RUN: %clang_analyze_cc1 -analyzer-checker=cplusplus.Move %s\
 // RUN:  -std=c++11 -analyzer-output=text -analyzer-config eagerly-assume=false\
 // RUN:  -analyzer-config exploration_strategy=unexplored_first_queue\
-// RUN:  -analyzer-config cplusplus.Move:WarnOn=KnownsOnly -DPEACEFUL\
-// RUN:  -analyzer-checker debug.ExprInspection
+// RUN:  -analyzer-config cplusplus.Move:WarnOn=KnownsOnly\
+// RUN:  -analyzer-checker debug.ExprInspection\
+// RUN:  -verify=expected,non-aggressive
 // RUN: %clang_analyze_cc1 -analyzer-checker=cplusplus.Move -verify %s\
 // RUN:  -std=c++11 -analyzer-output=text -analyzer-config eagerly-assume=false\
-// RUN:  -analyzer-config exploration_strategy=dfs -DDFS=1\
-// RUN:  -analyzer-config cplusplus.Move:WarnOn=KnownsOnly -DPEACEFUL\
-// RUN:  -analyzer-checker debug.ExprInspection
-// RUN: %clang_analyze_cc1 -analyzer-checker=cplusplus.Move -verify %s\
+// RUN:  -analyzer-config exploration_strategy=dfs -DDFS\
+// RUN:  -analyzer-config cplusplus.Move:WarnOn=KnownsOnly\
+// RUN:  -analyzer-checker debug.ExprInspection\
+// RUN:  -verify=expected,non-aggressive
+// RUN: %clang_analyze_cc1 -analyzer-checker=cplusplus.Move %s\
 // RUN:  -std=c++11 -analyzer-output=text -analyzer-config eagerly-assume=false\
 // RUN:  -analyzer-config exploration_strategy=unexplored_first_queue\
-// RUN:  -analyzer-config cplusplus.Move:WarnOn=All -DAGGRESSIVE\
-// RUN:  -analyzer-checker debug.ExprInspection
-// RUN: %clang_analyze_cc1 -analyzer-checker=cplusplus.Move -verify %s\
+// RUN:  -analyzer-config cplusplus.Move:WarnOn=All\
+// RUN:  -analyzer-checker debug.ExprInspection\
+// RUN:  -verify=expected,peaceful,aggressive
+// RUN: %clang_analyze_cc1 -analyzer-checker=cplusplus.Move %s\
 // RUN:  -std=c++11 -analyzer-output=text -analyzer-config eagerly-assume=false\
-// RUN:  -analyzer-config exploration_strategy=dfs -DDFS=1\
-// RUN:  -analyzer-config cplusplus.Move:WarnOn=All -DAGGRESSIVE\
-// RUN:  -analyzer-checker debug.ExprInspection
+// RUN:  -analyzer-config exploration_strategy=dfs -DDFS\
+// RUN:  -analyzer-config cplusplus.Move:WarnOn=All\
+// RUN:  -analyzer-checker debug.ExprInspection\
+// RUN:  -verify=expected,peaceful,aggressive
 
 // RUN: not %clang_analyze_cc1 -verify %s \
 // RUN:   -analyzer-checker=core \
 // RUN:   -analyzer-checker=cplusplus.Move \
 // RUN:   -analyzer-config cplusplus.Move:WarnOn="a bunch of things" \
 // RUN:   2>&1 | FileCheck %s -check-prefix=CHECK-MOVE-INVALID-VALUE
 
 // CHECK-MOVE-INVALID-VALUE: (frontend): invalid input for checker option
public:
   static A get() {
     A v(12, 13);
     return v;
   }
   A(A *a) {
     moveconstruct(std::move(*a));
   }
   A(const A &other) : i(other.i), d(other.d), b(other.b) {}
-  A(A &&other) : i(other.i), d(other.d), b(std::move(other.b)) {
-#ifdef AGGRESSIVE
-    // expected-note@-2{{Object 'b' is moved}}
-#endif
+  A(A &&other) : i(other.i), d(other.d), b(std::move(other.b)) { // aggressive-note{{Object 'b' is moved}}
   }
   A(A &&other, char *k) {
     moveconstruct(std::move(other));
   }
   void operator=(const A &other) {
     i = other.i;
     d = other.d;
     b = other.b;

 
 void copyOrMoveCall(A a) {
   a.foo();
 }
 
 void simpleMoveCtorTest() {
   {
     A a;
-    A b = std::move(a);
-    a.foo();
-#ifndef PEACEFUL
-    // expected-note@-3 {{Object 'a' is moved}}
-    // expected-warning@-3 {{Method called on moved-from object 'a'}}
-    // expected-note@-4    {{Method called on moved-from object 'a'}}
-#endif
+    A b = std::move(a); // peaceful-note {{Object 'a' is moved}}
+    a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
+             // peaceful-note@-1 {{Method called on moved-from object 'a'}}
   }
   {
     A a;
-    A b = std::move(a);
-    b = a;
-#ifndef PEACEFUL
-    // expected-note@-3 {{Object 'a' is moved}}
-    // expected-warning@-3 {{Moved-from object 'a' is copied}}
-    // expected-note@-4    {{Moved-from object 'a' is copied}}
-#endif
+    A b = std::move(a); // peaceful-note {{Object 'a' is moved}}
+    b = a; // peaceful-warning {{Moved-from object 'a' is copied}}
+           // peaceful-note@-1 {{Moved-from object 'a' is copied}}
   }
   {
     A a;
-    A b = std::move(a);
-    b = std::move(a);
-#ifndef PEACEFUL
-    // expected-note@-3 {{Object 'a' is moved}}
-    // expected-warning@-3 {{Moved-from object 'a' is moved}}
-    // expected-note@-4    {{Moved-from object 'a' is moved}}
-#endif
+    A b = std::move(a); // peaceful-note {{Object 'a' is moved}}
+    b = std::move(a); // peaceful-warning {{Moved-from object 'a' is moved}}
+                      // peaceful-note@-1 {{Moved-from object 'a' is moved}}
   }
 }
 
 void simpleMoveAssignementTest() {
   {
     A a;
     A b;
-    b = std::move(a);
-    a.foo();
-#ifndef PEACEFUL
-    // expected-note@-3 {{Object 'a' is moved}}
-    // expected-warning@-3 {{Method called on moved-from object 'a'}}
-    // expected-note@-4    {{Method called on moved-from object 'a'}}
-#endif
+    b = std::move(a); // peaceful-note {{Object 'a' is moved}}
+    a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
+             // peaceful-note@-1 {{Method called on moved-from object 'a'}}
   }
   {
     A a;
     A b;
-    b = std::move(a);
-    A c(a);
-#ifndef PEACEFUL
-    // expected-note@-3 {{Object 'a' is moved}}
-    // expected-warning@-3 {{Moved-from object 'a' is copied}}
-    // expected-note@-4    {{Moved-from object 'a' is copied}}
-#endif
+    b = std::move(a); // peaceful-note {{Object 'a' is moved}}
+    A c(a); // peaceful-warning {{Moved-from object 'a' is copied}}
+            // peaceful-note@-1 {{Moved-from object 'a' is copied}}
   }
   {
     A a;
     A b;
-    b = std::move(a);
-    A c(std::move(a));
-#ifndef PEACEFUL
-    // expected-note@-3 {{Object 'a' is moved}}
-    // expected-warning@-3 {{Moved-from object 'a' is moved}}
-    // expected-note@-4    {{Moved-from object 'a' is moved}}
-#endif
+    b = std::move(a); // peaceful-note {{Object 'a' is moved}}
+    A c(std::move(a)); // peaceful-warning {{Moved-from object 'a' is moved}}
+                       // peaceful-note@-1 {{Moved-from object 'a' is moved}}
   }
 }
 
 void moveInInitListTest() {
   struct S {
     A a;
   };
   A a;
-  S s{std::move(a)};
-  a.foo();
-#ifndef PEACEFUL
-  // expected-note@-3 {{Object 'a' is moved}}
-  // expected-warning@-3 {{Method called on moved-from object 'a'}}
-  // expected-note@-4 {{Method called on moved-from object 'a'}}
-#endif
+  S s{std::move(a)}; // peaceful-note {{Object 'a' is moved}}
+  a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
+           // peaceful-note@-1 {{Method called on moved-from object 'a'}}
 }
 
 // Don't report a bug if the variable was assigned to in the meantime.
 void reinitializationTest(int i) {
   {
     A a;
     A b;
     b = std::move(a);
     a = A();
     a.foo();
   }
   {
     A a;
-    if (i == 1) {
-#ifndef PEACEFUL
-      // expected-note@-2 {{Assuming 'i' is not equal to 1}}
-      // expected-note@-3 {{Taking false branch}}
-      // And the other report:
-      // expected-note@-5 {{Assuming 'i' is not equal to 1}}
-      // expected-note@-6 {{Taking false branch}}
-#endif
+    if (i == 1) { // peaceful-note 2 {{Assuming 'i' is not equal to 1}}
+                  // peaceful-note@-1 2 {{Taking false branch}}
       A b;
       b = std::move(a);
       a = A();
     }
-    if (i == 2) {
-#ifndef PEACEFUL
-      // expected-note@-2 {{Assuming 'i' is not equal to 2}}
-      // expected-note@-3 {{Taking false branch}}
-      // And the other report:
-      // expected-note@-5 {{Assuming 'i' is not equal to 2}}
-      // expected-note@-6 {{Taking false branch}}
-#endif
+    if (i == 2) { // peaceful-note 2 {{Assuming 'i' is not equal to 2}}
+                  // peaceful-note@-1 2 {{Taking false branch}}
       a.foo();    // no-warning
     }
   }
   {
     A a;
-    if (i == 1) {
-#ifndef PEACEFUL
-      // expected-note@-2 {{Taking false branch}}
-      // expected-note@-3 {{Taking false branch}}
-#endif
+    if (i == 1) { // peaceful-note 2 {{Taking false branch}}
       std::move(a);
     }
-    if (i == 2) {
-#ifndef PEACEFUL
-      // expected-note@-2 {{Taking false branch}}
-      // expected-note@-3 {{Taking false branch}}
-#endif
+    if (i == 2) { // peaceful-note 2 {{Taking false branch}}
       a = A();
       a.foo();
     }
   }
   // The built-in assignment operator should also be recognized as a
   // reinitialization. (std::move() may be called on built-in types in template
   // code.)
   {
     int a1 = 1, a2 = 2;
     std::swap(a1, a2);
   }
   // A std::move() after the assignment makes the variable invalid again.
   {
     A a;
     A b;
     b = std::move(a);
     a = A();
-    b = std::move(a);
-    a.foo();
-#ifndef PEACEFUL
-    // expected-note@-3 {{Object 'a' is moved}}
-    // expected-warning@-3 {{Method called on moved-from object 'a'}}
-    // expected-note@-4    {{Method called on moved-from object 'a'}}
-#endif
+    b = std::move(a); // peaceful-note {{Object 'a' is moved}}
+    a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
+             // peaceful-note@-1 {{Method called on moved-from object 'a'}}
   }
   // If a path exist where we not reinitialize the variable we report a bug.
   {
     A a;
     A b;
-    b = std::move(a);
-#ifndef PEACEFUL
-    // expected-note@-2 {{Object 'a' is moved}}
-#endif
-    if (i < 10) {
-#ifndef PEACEFUL
-      // expected-note@-2 {{Assuming 'i' is >= 10}}
-      // expected-note@-3 {{Taking false branch}}
-#endif
+    b = std::move(a); // peaceful-note {{Object 'a' is moved}}
+    if (i < 10) { // peaceful-note {{Assuming 'i' is >= 10}}
+                  // peaceful-note@-1 {{Taking false branch}}
       a = A();
     }
-    if (i > 5) {
-      a.foo();
-#ifndef PEACEFUL
-      // expected-note@-3 {{Taking true branch}}
-      // expected-warning@-3 {{Method called on moved-from object 'a'}}
-      // expected-note@-4    {{Method called on moved-from object 'a'}}
-#endif
+    if (i > 5) { // peaceful-note {{Taking true branch}}
+      a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
+               // peaceful-note@-1 {{Method called on moved-from object 'a'}}
     }
   }
 }
 
 // Using decltype on an expression is not a use.
 void decltypeIsNotUseTest() {
   A a;
   // A b(std::move(a));
   decltype(a) other_a; // no-warning
 }
 
 void loopTest() {
   {
     A a;
-    for (int i = 0; i < bignum(); i++) {
-#ifndef PEACEFUL
-      // expected-note@-2 {{Loop condition is false. Execution jumps to the end of the function}}
-#endif
+    // FIXME: Execution doesn't jump to the end of the function yet.
+    for (int i = 0; i < bignum(); i++) { // peaceful-note {{Loop condition is false. Execution jumps to the end of the function}}
       rightRefCall(std::move(a));        // no-warning
     }
   }
   {
     A a;
-    for (int i = 0; i < 2; i++) {
-#ifndef PEACEFUL
-      // expected-note@-2 {{Loop condition is true.  Entering loop body}}
-      // expected-note@-3 {{Loop condition is true.  Entering loop body}}
-      // expected-note@-4 {{Loop condition is false. Execution jumps to the end of the function}}
-#endif
+    for (int i = 0; i < 2; i++) { // peaceful-note    {{Loop condition is true.  Entering loop body}}
+                                  // peaceful-note@-1 {{Loop condition is true.  Entering loop body}}
+                                  // peaceful-note@-2 {{Loop condition is false. Execution jumps to the end of the function}}
       rightRefCall(std::move(a)); // no-warning
     }
   }
   {
     A a;
-    for (int i = 0; i < bignum(); i++) {
-#ifndef PEACEFUL
-      // expected-note@-2 {{Loop condition is false. Execution jumps to the end of the function}}
-#endif
+    for (int i = 0; i < bignum(); i++) { // peaceful-note {{Loop condition is false. Execution jumps to the end of the function}}
       leftRefCall(a);                    // no-warning
     }
   }
   {
     A a;
-    for (int i = 0; i < 2; i++) {
-#ifndef PEACEFUL
-      // expected-note@-2 {{Loop condition is true.  Entering loop body}}
-      // expected-note@-3 {{Loop condition is true.  Entering loop body}}
-      // expected-note@-4 {{Loop condition is false. Execution jumps to the end of the function}}
-#endif
+    for (int i = 0; i < 2; i++) { // peaceful-note    {{Loop condition is true.  Entering loop body}}
+                                  // peaceful-note@-1 {{Loop condition is true.  Entering loop body}}
+                                  // peaceful-note@-2 {{Loop condition is false. Execution jumps to the end of the function}}
       leftRefCall(a);             // no-warning
     }
   }
   {
     A a;
-    for (int i = 0; i < bignum(); i++) {
-#ifndef PEACEFUL
-      // expected-note@-2 {{Loop condition is false. Execution jumps to the end of the function}}
-#endif
+    for (int i = 0; i < bignum(); i++) { // peaceful-note {{Loop condition is false. Execution jumps to the end of the function}}
       constCopyOrMoveCall(a);            // no-warning
     }
   }
   {
     A a;
-    for (int i = 0; i < 2; i++) {
-#ifndef PEACEFUL
-      // expected-note@-2 {{Loop condition is true.  Entering loop body}}
-      // expected-note@-3 {{Loop condition is true.  Entering loop body}}
-      // expected-note@-4 {{Loop condition is false. Execution jumps to the end of the function}}
-#endif
+    for (int i = 0; i < 2; i++) { // peaceful-note    {{Loop condition is true.  Entering loop body}}
+                                  // peaceful-note@-1 {{Loop condition is true.  Entering loop body}}
+                                  // peaceful-note@-2 {{Loop condition is false. Execution jumps to the end of the function}}
       constCopyOrMoveCall(a);     // no-warning
     }
   }
   {
     A a;
-    for (int i = 0; i < bignum(); i++) {
-#ifndef PEACEFUL
-      // expected-note@-2 {{Loop condition is false. Execution jumps to the end of the function}}
-#endif
+    for (int i = 0; i < bignum(); i++) { // peaceful-note {{Loop condition is false. Execution jumps to the end of the function}}
       moveInsideFunctionCall(a);         // no-warning
     }
   }
   {
     A a;
-    for (int i = 0; i < 2; i++) {
-#ifndef PEACEFUL
-      // expected-note@-2 {{Loop condition is true.  Entering loop body}}
-      // expected-note@-3 {{Loop condition is true.  Entering loop body}}
-      // expected-note@-4 {{Loop condition is false. Execution jumps to the end of the function}}
-#endif
+    for (int i = 0; i < 2; i++) { // peaceful-note    {{Loop condition is true.  Entering loop body}}
+                                  // peaceful-note@-1 {{Loop condition is true.  Entering loop body}}
+                                  // peaceful-note@-2 {{Loop condition is false. Execution jumps to the end of the function}}
       moveInsideFunctionCall(a);  // no-warning
     }
   }
   {
     A a;
-    for (int i = 0; i < bignum(); i++) {
-#ifndef PEACEFUL
-      // expected-note@-2 {{Loop condition is false. Execution jumps to the end of the function}}
-#endif
+    for (int i = 0; i < bignum(); i++) { // peaceful-note {{Loop condition is false. Execution jumps to the end of the function}}
       copyOrMoveCall(a);                 // no-warning
     }
   }
   {
     A a;
-    for (int i = 0; i < 2; i++) {
-#ifndef PEACEFUL
-      // expected-note@-2 {{Loop condition is true.  Entering loop body}}
-      // expected-note@-3 {{Loop condition is true.  Entering loop body}}
-      // expected-note@-4 {{Loop condition is false. Execution jumps to the end of the function}}
-#endif
+    for (int i = 0; i < 2; i++) { // peaceful-note    {{Loop condition is true.  Entering loop body}}
+                                  // peaceful-note@-1 {{Loop condition is true.  Entering loop body}}
+                                  // peaceful-note@-2 {{Loop condition is false. Execution jumps to the end of the function}}
       copyOrMoveCall(a);          // no-warning
     }
   }
   {
     A a;
-    for (int i = 0; i < bignum(); i++) {
-#ifndef PEACEFUL
-      // expected-note@-2 {{Loop condition is true.  Entering loop body}}
-      // expected-note@-3 {{Loop condition is true.  Entering loop body}}
-#endif
-      constCopyOrMoveCall(std::move(a));
-#ifndef PEACEFUL
-      // expected-note@-2    {{Object 'a' is moved}}
-      // expected-warning@-3 {{Moved-from object 'a' is moved}}
-      // expected-note@-4 {{Moved-from object 'a' is moved}}
-#endif
+    for (int i = 0; i < bignum(); i++) { // peaceful-note    {{Loop condition is true.  Entering loop body}}
+                                         // peaceful-note@-1 {{Loop condition is true.  Entering loop body}}
+      constCopyOrMoveCall(std::move(a)); // peaceful-note {{Object 'a' is moved}}
+                                         // peaceful-warning@-1 {{Moved-from object 'a' is moved}}
+                                         // peaceful-note@-2    {{Moved-from object 'a' is moved}}
     }
   }
 
   // Don't warn if we return after the move.
   {
     A a;
     for (int i = 0; i < 3; ++i) {
       a.bar();
       if (a.foo() > 0) {
         A b;
         b = std::move(a); // no-warning
         return;
       }
     }
   }
 }
 
 // Report a usage of a moved-from object only at the first use.
 void uniqueTest(bool cond) {
   A a(42, 42.0);
   A b;
-  b = std::move(a);
+  b = std::move(a); // peaceful-note {{Object 'a' is moved}}
 
-  if (cond) {
-    a.foo();
-#ifndef PEACEFUL
-  // expected-note@-5 {{Object 'a' is moved}}
-  // expected-note@-4 {{Assuming 'cond' is not equal to 0}}
-  // expected-note@-5 {{Taking true branch}}
-  // expected-warning@-5 {{Method called on moved-from object 'a'}}
-  // expected-note@-6    {{Method called on moved-from object 'a'}}
-#endif
+  if (cond) { // peaceful-note {{Assuming 'cond' is not equal to 0}}
+              // peaceful-note@-1 {{Taking true branch}}
+    a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
+             // peaceful-note@-1 {{Method called on moved-from object 'a'}}
   }
   if (cond) {
     a.bar(); // no-warning
   }
 
   a.bar(); // no-warning
 }
 
 void uniqueTest2() {
   A a;
-  A a1 = std::move(a);
-  a.foo();
-#ifndef PEACEFUL
-  // expected-note@-3 {{Object 'a' is moved}}
-  // expected-warning@-3 {{Method called on moved-from object 'a'}}
-  // expected-note@-4    {{Method called on moved-from object 'a'}}
-#endif
+  A a1 = std::move(a); // peaceful-note {{Object 'a' is moved}}
+  a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
+           // peaceful-note@-1    {{Method called on moved-from object 'a'}}
 
   A a2 = std::move(a); // no-warning
   a.foo();             // no-warning
 }
 
 // There are exceptions where we assume in general that the method works fine
 //even on moved-from objects.
 void moveSafeFunctionsTest() {
   A a;
-  A b = std::move(a);
-#ifndef PEACEFUL
-  // expected-note@-2 {{Object 'a' is moved}}
-#endif
+  A b = std::move(a); // peaceful-note {{Object 'a' is moved}}
   a.empty();          // no-warning
   a.isEmpty();        // no-warning
   (void)a;            // no-warning
   (bool)a;            // expected-warning {{expression result unused}}
-  a.foo();
-#ifndef PEACEFUL
-  // expected-warning@-2 {{Method called on moved-from object 'a'}}
-  // expected-note@-3    {{Method called on moved-from object 'a'}}
-#endif
+  a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
+           // peaceful-note@-1 {{Method called on moved-from object 'a'}}
 }
 
 void moveStateResetFunctionsTest() {
   {
     A a;
     A b = std::move(a);
     a.reset(); // no-warning
     a.foo();   // no-warning

 
 // Moves of member variables.
 class memberVariablesTest {
   A a;
   static A static_a;
 
   void f() {
     A b;
-    b = std::move(a);
-    a.foo();
-#ifdef AGGRESSIVE
-    // expected-note@-3{{Object 'a' is moved}}
-    // expected-warning@-3 {{Method called on moved-from object 'a'}}
-    // expected-note@-4{{Method called on moved-from object 'a'}}
-#endif
+    b = std::move(a); // aggressive-note {{Object 'a' is moved}}
 
-    b = std::move(static_a);
-    static_a.foo();
-#ifdef AGGRESSIVE
-    // expected-note@-3{{Object 'static_a' is moved}}
-    // expected-warning@-3{{Method called on moved-from object 'static_a'}}
-    // expected-note@-4{{Method called on moved-from object 'static_a'}}
-#endif
+    a.foo(); // aggressive-warning {{Method called on moved-from object 'a'}}
+             // aggressive-note@-1 {{Method called on moved-from object 'a'}}
+
+    b = std::move(static_a); // aggressive-note {{Object 'static_a' is moved}}
+    static_a.foo(); // aggressive-warning {{Method called on moved-from object 'static_a'}}
+                    // aggressive-note@-1 {{Method called on moved-from object 'static_a'}}
   }
 };
 
 void PtrAndArrayTest() {
   A *Ptr = new A(1, 1.5);
   A Arr[10];
-  Arr[2] = std::move(*Ptr);
-  (*Ptr).foo();
-#ifdef AGGRESSIVE
-  // expected-note@-3{{Object is moved}}
-  // expected-warning@-3{{Method called on moved-from object}}
-  // expected-note@-4{{Method called on moved-from object}}
-#endif
+  Arr[2] = std::move(*Ptr); // aggressive-note{{Object is moved}}
+  (*Ptr).foo(); // aggressive-warning{{Method called on moved-from object}}
+                // aggressive-note@-1{{Method called on moved-from object}}
 
   Ptr = &Arr[1];
-  Arr[3] = std::move(Arr[1]);
-  Ptr->foo();
-#ifdef AGGRESSIVE
-  // expected-note@-3{{Object is moved}}
-  // expected-warning@-3{{Method called on moved-from object}}
-  // expected-note@-4{{Method called on moved-from object}}
-#endif
-
-  Arr[3] = std::move(Arr[2]);
-  Arr[2].foo();
-#ifdef AGGRESSIVE
-  // expected-note@-3{{Object is moved}}
-  // expected-warning@-3{{Method called on moved-from object}}
-  // expected-note@-4{{Method called on moved-from object}}
-#endif
+  Arr[3] = std::move(Arr[1]); // aggressive-note {{Object is moved}}
+  Ptr->foo(); // aggressive-warning {{Method called on moved-from object}}
+              // aggressive-note@-1 {{Method called on moved-from object}}
+
+  Arr[3] = std::move(Arr[2]); // aggressive-note{{Object is moved}}
+  Arr[2].foo(); // aggressive-warning{{Method called on moved-from object}}
+                // aggressive-note@-1{{Method called on moved-from object}}
 
   Arr[2] = std::move(Arr[3]); // reinitialization
   Arr[2].foo();               // no-warning
 }
 
 void exclusiveConditionsTest(bool cond) {
   A a;
   if (cond) {
     A b;
     b = std::move(a);
   }
   if (!cond) {
     a.bar(); // no-warning
   }
 }
 
 void differentBranchesTest(int i) {
   // Don't warn if the use is in a different branch from the move.
   {
     A a;
-    if (i > 0) {
-#ifndef PEACEFUL
-    // expected-note@-2 {{Assuming 'i' is > 0}}
-    // expected-note@-3 {{Taking true branch}}
-#endif
+    if (i > 0) { // peaceful-note {{Assuming 'i' is > 0}}
+                 // peaceful-note@-1 {{Taking true branch}}
       A b;
       b = std::move(a);
     } else {
       a.foo(); // no-warning
     }
   }
   // Same thing, but with a ternary operator.
   {
     A a, b;
-    i > 0 ? (void)(b = std::move(a)) : a.bar(); // no-warning
-#ifndef PEACEFUL
-    // expected-note@-2 {{'?' condition is true}}
-#endif
+    i > 0 ? (void)(b = std::move(a)) : a.bar(); // no-warning // peaceful-note {{'?' condition is true}}
   }
   // A variation on the theme above.
   {
     A a;
     a.foo() > 0 ? a.foo() : A(std::move(a)).foo();
 #ifdef DFS
-  #ifndef PEACEFUL
-    // expected-note@-3 {{Assuming the condition is false}}
-    // expected-note@-4 {{'?' condition is false}}
-  #endif
+    // peaceful-note@-2 {{Assuming the condition is false}}
+    // peaceful-note@-3 {{'?' condition is false}}
 #else
-  #ifndef PEACEFUL
-    // expected-note@-8 {{Assuming the condition is true}}
-    // expected-note@-9 {{'?' condition is true}}
-  #endif
+    // peaceful-note@-5 {{Assuming the condition is true}}
+    // peaceful-note@-6 {{'?' condition is true}}
 #endif
   }
   // Same thing, but with a switch statement.
   {
     A a, b;
-    switch (i) {
-#ifndef PEACEFUL
-    // expected-note@-2 {{Control jumps to 'case 1:'}}
-#endif
+    switch (i) { // peaceful-note {{Control jumps to 'case 1:'}}
     case 1:
       b = std::move(a); // no-warning
-      break;
-#ifndef PEACEFUL
-      // expected-note@-2 {{Execution jumps to the end of the function}}
-#endif
+      // FIXME: Execution doesn't jump to the end of the function yet.
+      break; // peaceful-note {{Execution jumps to the end of the function}}
     case 2:
       a.foo(); // no-warning
       break;
     }
   }
   // However, if there's a fallthrough, we do warn.
   {
     A a, b;
-    switch (i) {
-#ifndef PEACEFUL
-    // expected-note@-2 {{Control jumps to 'case 1:'}}
-#endif
+    switch (i) { // peaceful-note {{Control jumps to 'case 1:'}}
     case 1:
-      b = std::move(a);
-#ifndef PEACEFUL
-      // expected-note@-2 {{Object 'a' is moved}}
-#endif
+      b = std::move(a); // peaceful-note {{Object 'a' is moved}}
     case 2:
-      a.foo();
-#ifndef PEACEFUL
-      // expected-warning@-2 {{Method called on moved-from object}}
-      // expected-note@-3    {{Method called on moved-from object 'a'}}
-#endif
+      a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
+               // peaceful-note@-1 {{Method called on moved-from object 'a'}}
       break;
     }
   }
 }
 
 void tempTest() {
   A a = A::get();
   A::get().foo(); // no-warning
   for (int i = 0; i < bignum(); i++) {
     A::get().foo(); // no-warning
   }
 }
 
 void interFunTest1(A &a) {
-  a.bar();
-#ifndef PEACEFUL
-  // expected-warning@-2 {{Method called on moved-from object 'a'}}
-  // expected-note@-3    {{Method called on moved-from object 'a'}}
-#endif
+  a.bar(); // peaceful-warning {{Method called on moved-from object 'a'}}
+           // peaceful-note@-1 {{Method called on moved-from object 'a'}}
 }
 
 void interFunTest2() {
   A a;
   A b;
-  b = std::move(a);
-  interFunTest1(a);
-#ifndef PEACEFUL
-  // expected-note@-3 {{Object 'a' is moved}}
-  // expected-note@-3 {{Calling 'interFunTest1'}}
-#endif
+  b = std::move(a); // peaceful-note {{Object 'a' is moved}}
+  interFunTest1(a); // peaceful-note {{Calling 'interFunTest1'}}
 }
 
 void foobar(A a, int i);
 void foobar(int i, A a);
 
 void paramEvaluateOrderTest() {
   A a;
-  foobar(std::move(a), a.getI());
-#ifndef PEACEFUL
-  // expected-note@-2 {{Object 'a' is moved}}
-  // expected-warning@-3 {{Method called on moved-from object 'a'}}
-  // expected-note@-4    {{Method called on moved-from object 'a'}}
-#endif
+  foobar(std::move(a), a.getI()); // peaceful-note {{Object 'a' is moved}}
+                                  // peaceful-warning@-1 {{Method called on moved-from object 'a'}}
+                                  // peaceful-note@-2    {{Method called on moved-from object 'a'}}
 
   //FALSE NEGATIVE since parameters evaluate order is undefined
   foobar(a.getI(), std::move(a)); //no-warning
 }
 
 void not_known_pass_by_ref(A &a);
 void not_known_pass_by_const_ref(const A &a);
 void not_known_pass_by_rvalue_ref(A &&a);
 void not_known_pass_by_ptr(A *a);
 void not_known_pass_by_const_ptr(const A *a);
 
 void regionAndPointerEscapeTest() {
   {
     A a;
     A b;
     b = std::move(a);
     not_known_pass_by_ref(a);
     a.foo(); // no-warning
   }
   {
     A a;
     A b;
-    b = std::move(a);
+    b = std::move(a); // peaceful-note{{Object 'a' is moved}}
     not_known_pass_by_const_ref(a);
-    a.foo();
-#ifndef PEACEFUL
-    // expected-note@-4{{Object 'a' is moved}}
-    // expected-warning@-3{{Method called on moved-from object 'a'}}
-    // expected-note@-4   {{Method called on moved-from object 'a'}}
-#endif
+    a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
+             // peaceful-note@-1 {{Method called on moved-from object 'a'}}
   }
   {
     A a;
     A b;
     b = std::move(a);
     not_known_pass_by_rvalue_ref(std::move(a));
     a.foo(); // no-warning
   }
   {
     A a;
     A b;
     b = std::move(a);
     not_known_pass_by_ptr(&a);
     a.foo(); // no-warning
   }
   {
     A a;
     A b;
-    b = std::move(a);
+    b = std::move(a); // peaceful-note {{Object 'a' is moved}}
     not_known_pass_by_const_ptr(&a);
-    a.foo();
-#ifndef PEACEFUL
-    // expected-note@-4{{Object 'a' is moved}}
-    // expected-warning@-3{{Method called on moved-from object 'a'}}
-    // expected-note@-4   {{Method called on moved-from object 'a'}}
-#endif
+    a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
+             // peaceful-note@-1 {{Method called on moved-from object 'a'}}
   }
 }
 
 // A declaration statement containing multiple declarations sequences the
 // initializer expressions.
 void declarationSequenceTest() {
   {
     A a;
     A a1 = a, a2 = std::move(a); // no-warning
   }
   {
     A a;
-    A a1 = std::move(a), a2 = a;
-#ifndef PEACEFUL
-    // expected-note@-2 {{Object 'a' is moved}}
-    // expected-warning@-3 {{Moved-from object 'a' is copied}}
-    // expected-note@-4    {{Moved-from object 'a' is copied}}
-#endif
+    A a1 = std::move(a), a2 = a; // peaceful-note {{Object 'a' is moved}}
+                                 // peaceful-warning@-1 {{Moved-from object 'a' is copied}}
+                                 // peaceful-note@-2    {{Moved-from object 'a' is copied}}
   }
 }
 
 // The logical operators && and || sequence their operands.
 void logicalOperatorsSequenceTest() {
   {
     A a;
-    if (a.foo() > 0 && A(std::move(a)).foo() > 0) {
-#ifndef PEACEFUL
-      // expected-note@-2 {{Assuming the condition is false}}
-      // expected-note@-3 {{Left side of '&&' is false}}
-      // expected-note@-4 {{Taking false branch}}
+    if (a.foo() > 0 && A(std::move(a)).foo() > 0) { // peaceful-note    {{Assuming the condition is false}}
+                                                    // peaceful-note@-1 {{Left side of '&&' is false}}
+                                                    // peaceful-note@-2 {{Taking false branch}}
                                                     // And the other report:
-      // expected-note@-6 {{Assuming the condition is false}}
-      // expected-note@-7 {{Left side of '&&' is false}}
-      // expected-note@-8 {{Taking false branch}}
+                                                    // peaceful-note@-4 {{Assuming the condition is false}}
+                                                    // peaceful-note@-5 {{Left side of '&&' is false}}
+                                                    // peaceful-note@-6 {{Taking false branch}}
       A().bar();
-#endif
     }
   }
   // A variation: Negate the result of the && (which pushes the && further down
   // into the AST).
   {
     A a;
-    if (!(a.foo() > 0 && A(std::move(a)).foo() > 0)) {
-#ifndef PEACEFUL
-      // expected-note@-2 {{Assuming the condition is false}}
-      // expected-note@-3 {{Left side of '&&' is false}}
-      // expected-note@-4 {{Taking true branch}}
+    if (!(a.foo() > 0 && A(std::move(a)).foo() > 0)) { // peaceful-note    {{Assuming the condition is false}}
+                                                       // peaceful-note@-1 {{Left side of '&&' is false}}
+                                                       // peaceful-note@-2 {{Taking true branch}}
                                                        // And the other report:
-      // expected-note@-6 {{Assuming the condition is false}}
-      // expected-note@-7 {{Left side of '&&' is false}}
-      // expected-note@-8 {{Taking true branch}}
-#endif
+                                                       // peaceful-note@-4 {{Assuming the condition is false}}
+                                                       // peaceful-note@-5 {{Left side of '&&' is false}}
+                                                       // peaceful-note@-6 {{Taking true branch}}
       A().bar();
     }
   }
   {
     A a;
-    if (A(std::move(a)).foo() > 0 && a.foo() > 0) {
-#ifndef PEACEFUL
-      // expected-note@-2 {{Object 'a' is moved}}
-      // expected-note@-3 {{Assuming the condition is true}}
-      // expected-note@-4 {{Left side of '&&' is true}}
-      // expected-warning@-5 {{Method called on moved-from object 'a'}}
-      // expected-note@-6    {{Method called on moved-from object 'a'}}
+    if (A(std::move(a)).foo() > 0 && a.foo() > 0) { // peaceful-note    {{Object 'a' is moved}}
+                                                    // peaceful-note@-1 {{Assuming the condition is true}}
+                                                    // peaceful-note@-2 {{Left side of '&&' is true}}
+                                                    // peaceful-warning@-3 {{Method called on moved-from object 'a'}}
+                                                    // peaceful-note@-4    {{Method called on moved-from object 'a'}}
                                                     // And the other report:
-      // expected-note@-8 {{Assuming the condition is false}}
-      // expected-note@-9 {{Left side of '&&' is false}}
-      // expected-note@-10{{Taking false branch}}
-#endif
+                                                    // peaceful-note@-6 {{Assuming the condition is false}}
+                                                    // peaceful-note@-7 {{Left side of '&&' is false}}
+                                                    // peaceful-note@-8 {{Taking false branch}}
       A().bar();
     }
   }
   {
     A a;
-    if (a.foo() > 0 || A(std::move(a)).foo() > 0) {
-#ifndef PEACEFUL
-      // expected-note@-2 {{Assuming the condition is true}}
-      // expected-note@-3 {{Left side of '||' is true}}
-      // expected-note@-4 {{Taking true branch}}
-#endif
+    if (a.foo() > 0 || A(std::move(a)).foo() > 0) { // peaceful-note    {{Assuming the condition is true}}
+                                                    // peaceful-note@-1 {{Left side of '||' is true}}
+                                                    // peaceful-note@-2 {{Taking true branch}}
       A().bar();
     }
   }
   {
     A a;
-    if (A(std::move(a)).foo() > 0 || a.foo() > 0) {
-#ifndef PEACEFUL
-      // expected-note@-2 {{Object 'a' is moved}}
-      // expected-note@-3 {{Assuming the condition is false}}
-      // expected-note@-4 {{Left side of '||' is false}}
-      // expected-warning@-5 {{Method called on moved-from object 'a'}}
-      // expected-note@-6    {{Method called on moved-from object 'a'}}
-#endif
+    if (A(std::move(a)).foo() > 0 || a.foo() > 0) { // peaceful-note {{Object 'a' is moved}}
+                                                    // peaceful-note@-1 {{Assuming the condition is false}}
+                                                    // peaceful-note@-2 {{Left side of '||' is false}}
+                                                    // peaceful-warning@-3 {{Method called on moved-from object 'a'}}
+                                                    // peaceful-note@-4    {{Method called on moved-from object 'a'}}
       A().bar();
     }
   }
 }
 
 // A range-based for sequences the loop variable declaration before the body.
 void forRangeSequencesTest() {
   A v[2] = {A(), A()};

 
 struct C : public A {
   [[clang::reinitializes]] void reinit();
 };
 
 void subRegionMoveTest() {
   {
     A a;
-    B b = std::move(a.b);
-    a.b.foo();
-#ifdef AGGRESSIVE
-    // expected-note@-3{{Object 'b' is moved}}
-    // expected-warning@-3{{Method called on moved-from object 'b'}}
-    // expected-note@-4 {{Method called on moved-from object 'b'}}
-#endif
+    B b = std::move(a.b); // aggressive-note {{Object 'b' is moved}}
+    a.b.foo(); // aggressive-warning {{Method called on moved-from object 'b'}}
+               // aggressive-note@-1 {{Method called on moved-from object 'b'}}
   }
   {
     A a;
-    A a1 = std::move(a);
-    a.b.foo();
-#ifdef AGGRESSIVE
-    // expected-note@-3{{Calling move constructor for 'A'}}
-    // expected-note@-4{{Returning from move constructor for 'A'}}
-    // expected-warning@-4{{Method called on moved-from object 'b'}}
-    // expected-note@-5{{Method called on moved-from object 'b'}}
-#endif
+    A a1 = std::move(a); // aggressive-note {{Calling move constructor for 'A'}}
+                         // aggressive-note@-1 {{Returning from move constructor for 'A'}}
+    a.b.foo(); // aggressive-warning{{Method called on moved-from object 'b'}}
+               // aggressive-note@-1{{Method called on moved-from object 'b'}}
   }
   // Don't report a misuse if any SuperRegion is already reported.
   {
     A a;
-    A a1 = std::move(a);
-    a.foo();
-#ifndef PEACEFUL
-    // expected-note@-3 {{Object 'a' is moved}}
-    // expected-warning@-3 {{Method called on moved-from object 'a'}}
-    // expected-note@-4    {{Method called on moved-from object 'a'}}
-#endif
-    a.b.foo();           // no-warning
+    A a1 = std::move(a); // peaceful-note {{Object 'a' is moved}}
+    a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
+             // peaceful-note@-1 {{Method called on moved-from object 'a'}}
+    a.b.foo(); // no-warning
   }
   {
     C c;
-    C c1 = std::move(c);
-    c.foo();
-#ifndef PEACEFUL
-    // expected-note@-3 {{Object 'c' is moved}}
-    // expected-warning@-3 {{Method called on moved-from object 'c'}}
-    // expected-note@-4    {{Method called on moved-from object 'c'}}
-#endif
-    c.b.foo();           // no-warning
+    C c1 = std::move(c); // peaceful-note {{Object 'c' is moved}}
+    c.foo(); // peaceful-warning {{Method called on moved-from object 'c'}}
+             // peaceful-note@-1 {{Method called on moved-from object 'c'}}
+    c.b.foo(); // no-warning
   }
 }
 
 void resetSuperClass() {
   C c;
   C c1 = std::move(c);
   c.clear();
   C c2 = c; // no-warning
 }
 
 void resetSuperClass2() {
   C c;
   C c1 = std::move(c);
   c.reinit();
   C c2 = c; // no-warning
 }
 
 void reportSuperClass() {
   C c;
-  C c1 = std::move(c);
-  c.foo();
-#ifndef PEACEFUL
-  // expected-note@-3 {{Object 'c' is moved}}
-  // expected-warning@-3 {{Method called on moved-from object 'c'}}
-  // expected-note@-4    {{Method called on moved-from object 'c'}}
-#endif
-  C c2 = c;            // no-warning
+  C c1 = std::move(c); // peaceful-note {{Object 'c' is moved}}
+  c.foo(); // peaceful-warning {{Method called on moved-from object 'c'}}
+           // peaceful-note@-1 {{Method called on moved-from object 'c'}}
+  C c2 = c; // no-warning
 }
 
 struct Empty {};
 
 Empty inlinedCall() {
   // Used to warn because region 'e' failed to be cleaned up because no symbols
   // have ever died during the analysis and the checkDeadSymbols callback
   // was skipped entirely.
MoveOnlyWithDestructor foo() {
   return m;
 }
 
 class HasSTLField {
   std::vector<int> V;
   void testVector() {
     // Warn even in non-aggressive mode when it comes to STL, because
     // in STL the object is left in "valid but unspecified state" after move.
-    std::vector<int> W = std::move(V); // expected-note{{Object 'V' of type 'std::vector' is left in a valid but unspecified state after move}}
-    V.push_back(123); // expected-warning{{Method called on moved-from object 'V'}}
-                      // expected-note@-1{{Method called on moved-from object 'V'}}
+    std::vector<int> W = std::move(V); // expected-note {{Object 'V' of type 'std::vector' is left in a valid but unspecified state after move}}
+    V.push_back(123); // expected-warning {{Method called on moved-from object 'V'}}
+                      // expected-note@-1 {{Method called on moved-from object 'V'}}
   }
 
   std::unique_ptr<int> P;
   void testUniquePtr() {
     // unique_ptr remains in a well-defined state after move.
-    std::unique_ptr<int> Q = std::move(P);
-    P.get();
-#ifdef AGGRESSIVE
-    // expected-warning@-2{{Method called on moved-from object 'P'}}
-    // expected-note@-4{{Object 'P' is moved}}
-    // expected-note@-4{{Method called on moved-from object 'P'}}
-#endif
+    std::unique_ptr<int> Q = std::move(P); // aggressive-note {{Object 'P' is moved}}
+                                           // non-aggressive-note@-1 {{Smart pointer 'P' of type 'std::unique_ptr' is reset to null when moved from}}
+    P.get(); // aggressive-warning{{Method called on moved-from object 'P'}}
+             // aggressive-note@-1{{Method called on moved-from object 'P'}}
 
     // Because that well-defined state is null, dereference is still UB.
     // Note that in aggressive mode we already warned about 'P',
     // so no extra warning is generated.
-    *P += 1;
-#ifndef AGGRESSIVE
-    // expected-warning@-2{{Dereference of null smart pointer 'P' of type 'std::unique_ptr'}}
-    // expected-note@-14{{Smart pointer 'P' of type 'std::unique_ptr' is reset to null when moved from}}
-    // expected-note@-4{{Dereference of null smart pointer 'P' of type 'std::unique_ptr'}}
-#endif
+    *P += 1; // non-aggressive-warning{{Dereference of null smart pointer 'P' of type 'std::unique_ptr'}}
+             // non-aggressive-note@-1{{Dereference of null smart pointer 'P' of type 'std::unique_ptr'}}
 
     // The program should have crashed by now.
     clang_analyzer_warnIfReached(); // no-warning
   }
 };
 
 void localRValueMove(A &&a) {
-  A b = std::move(a);
-  a.foo();
-#ifndef PEACEFUL
-  // expected-note@-3 {{Object 'a' is moved}}
-  // expected-warning@-3 {{Method called on moved-from object 'a'}}
-  // expected-note@-4    {{Method called on moved-from object 'a'}}
-#endif
+  A b = std::move(a); // peaceful-note {{Object 'a' is moved}}
+  a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
+           // peaceful-note@-1 {{Method called on moved-from object 'a'}}
 }
 
 void localUniquePtr(std::unique_ptr<int> P) {
   // Even though unique_ptr is safe to use after move,
   // reusing a local variable this way usually indicates a bug.
-  std::unique_ptr<int> Q = std::move(P);
-  P.get();
-#ifndef PEACEFUL
-  // expected-note@-3 {{Object 'P' is moved}}
-  // expected-warning@-3 {{Method called on moved-from object 'P'}}
-  // expected-note@-4    {{Method called on moved-from object 'P'}}
-#endif
+  std::unique_ptr<int> Q = std::move(P); // peaceful-note {{Object 'P' is moved}}
+  P.get(); // peaceful-warning {{Method called on moved-from object 'P'}}
+           // peaceful-note@-1 {{Method called on moved-from object 'P'}}
 }
 
 void localUniquePtrWithArrow(std::unique_ptr<A> P) {
   std::unique_ptr<A> Q = std::move(P); // expected-note{{Smart pointer 'P' of type 'std::unique_ptr' is reset to null when moved from}}
   P->foo(); // expected-warning{{Dereference of null smart pointer 'P' of type 'std::unique_ptr'}}
             // expected-note@-1{{Dereference of null smart pointer 'P' of type 'std::unique_ptr'}}
 }