[analyzer] MoveChecker Pt.3: Improve warning messages a bit.

[NoQ]

Summary

The warning piece traditionally describes the bug itself, i.e., "The bug is a _____": "Attempt to delete released memory", "Resource leak", "Method call on a moved-from object".

The "moved-from" terminology we adopt here still feels a bit weird to me, but i don't have a better suggestion, so i just removed the single-quotes so that to at least feel proud about what we have.

Event pieces produced by the visitor are usually in a present tense, i.e., "At this moment _____": "Memory is released", "File is closed", "Object is moved", etc.

Additionally, type information is added into the event pieces for STL objects (in order to highlight that it is in fact an STL object), and the respective event piece now mentions that the object is left in an unspecified state after it was moved, which is a vital piece of information to understand the bug.

[Szelethus]

Awesome! :D

lib/StaticAnalyzer/Checkers/MoveChecker.cpp

385–386

Maybe move this in-class?

[NoQ]

Write down full messages in tests. When the message was updated from 'x' is moved' to Object 'x' is moved, the tests were not updated because they kept passing because the former is still a sub-string of the latter.

lib/StaticAnalyzer/Checkers/MoveChecker.cpp

385–386

Mmm, what do you mean?

test/Analysis/use-after-move.cpp

789–791

Note how when an object is both a local and an STL object, the bug is reported as an STL bug. Which is good because it's more dangerous to use an STL object after move than to use your average local variable after move.

[MTC]

The "moved-from" terminology we adopt here still feels a bit weird to me, but i don't have a better suggestion, so i just removed the single-quotes so that to at least feel proud about what we have.

I am personally fine with this terminology, this checker corresponds to the cert rule EXP63-CPP. Do not rely on the value of a moved-from object, and moved from is also used in many places in CppCoreGuidelines.

[Charusso]

In D54560#1301870, @NoQ wrote:

Write down full messages in tests. When the message was updated from 'x' is moved' to Object 'x' is moved, the tests were not updated because they kept passing because the former is still a sub-string of the latter.

It would not be cool to rewrite this contains effect to equality like in the regex file-checks? I have ran in the same problem and I was very surprised (for an hour) why my error-dumps does not show up on rewriting bug-report messages.

[Szelethus]

lib/StaticAnalyzer/Checkers/MoveChecker.cpp

385–386

explain.* sounds like it either returns a string, or writes a stream object, but the return type isn't void nor string, maybe it'd be worth to put this comment in-class.

But yea, this is over the top nitpicking, I don't insist :)

[dcoughlin]

Looks good! Some suggested minor tweaks to diagnostic text inline.

test/Analysis/use-after-move.cpp

146

"Moved-from object is copied 'a'" doesn't read quite right. I think the object name is in the wrong spot. Instead, I would suggest: "Moved-from object 'a' is copied"

789–791

I think the diagnostic text is missing an "a". It should be "... left in a valid but ... "

[NoQ]

Address comments!

In D54560#1304155, @Charusso wrote:

In D54560#1301870, @NoQ wrote:

Write down full messages in tests. When the message was updated from 'x' is moved' to Object 'x' is moved, the tests were not updated because they kept passing because the former is still a sub-string of the latter.

It would not be cool to rewrite this contains effect to equality like in the regex file-checks? I have ran in the same problem and I was very surprised (for an hour) why my error-dumps does not show up on rewriting bug-report messages.

We already have // expected-warning-re{{{{^Message$}}}} for that purpose, it's just annoying to write and is rarely an issue, so nobody uses them until it's absolutely necessary (cf. test/Analysis/explain-svals.cpp). Same with FileCheck tests.

lib/StaticAnalyzer/Checkers/MoveChecker.cpp

385–386

Fxd!

test/Analysis/use-after-move.cpp

146

Whoops!!

[NoQ]

In D54560#1302051, @MTC wrote:

The "moved-from" terminology we adopt here still feels a bit weird to me, but i don't have a better suggestion, so i just removed the single-quotes so that to at least feel proud about what we have.

I am personally fine with this terminology, this checker corresponds to the cert rule EXP63-CPP. Do not rely on the value of a moved-from object, and moved from is also used in many places in CppCoreGuidelines.

Double-checked - this terminology does indeed come from the Standard:

15.5.5.15 Moved-from state of library types [lib.types.movedfrom]
1 Objects of types defined in the C++ standard library may be moved from (10.3.4.2). Move operations may be explicitly specified or implicitly generated. Unless otherwise specified, such moved-from objects shall be placed in a valid but unspecified state.

lib/StaticAnalyzer/Checkers/MoveChecker.cpp

private:
 
   struct ObjectKind {
     bool Local : 1; // Is this a local variable or a local rvalue reference?
     bool STL : 1; // Is this an object of a standard type?
   };
 
   static ObjectKind classifyObject(const MemRegion *MR,
                                    const CXXRecordDecl *RD);
+  static ObjectKind explainObject(llvm::raw_ostream &OS,
+                                  const MemRegion *MR, const CXXRecordDecl *RD);
 
   class MovedBugVisitor : public BugReporterVisitor {
   public:
-    MovedBugVisitor(const MemRegion *R) : Region(R), Found(false) {}
+    MovedBugVisitor(const MemRegion *R, const CXXRecordDecl *RD)
+        : Region(R), RD(RD), Found(false) {}
 
     void Profile(llvm::FoldingSetNodeID &ID) const override {
       static int X = 0;
       ID.AddPointer(&X);
       ID.AddPointer(Region);
+      // Don't add RD because it's, in theory, uniquely determined by
+      // the region. In practice though, it's not always possible to obtain
+      // the declaration directly from the region, that's why we store it
+      // in the first place.
     }
 
     std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
                                                    BugReporterContext &BRC,
                                                    BugReport &BR) override;
 
   private:
     // The tracked region.
     const MemRegion *Region;
+    // The class of the tracked object.
+    const CXXRecordDecl *RD;
     bool Found;
   };
 
   bool IsAggressive = false;
 
 public:
   void setAggressiveness(bool Aggressive) { IsAggressive = Aggressive; }
 
if (TrackedObjectPrev && TrackedObject)
     return nullptr;
 
   // Retrieve the associated statement.
   const Stmt *S = PathDiagnosticLocation::getStmt(N);
   if (!S)
     return nullptr;
   Found = true;
 
-  std::string ObjectName;
-  if (const auto DecReg =
-          unwrapRValueReferenceIndirection(Region)->getAs<DeclRegion>()) {
-    const auto *RegionDecl = dyn_cast<NamedDecl>(DecReg->getDecl());
-    ObjectName = RegionDecl->getNameAsString();
-  }
-  std::string InfoText;
-  if (ObjectName != "")
-    InfoText = "'" + ObjectName + "' became 'moved-from' here";
+  SmallString<128> Str;
+  llvm::raw_svector_ostream OS(Str);
+
+  OS << "Object";
+  ObjectKind OK = explainObject(OS, Region, RD);
+  if (OK.STL)
+    OS << " is left in valid but unspecified state after move";
   else
-    InfoText = "Became 'moved-from' here";
+    OS << " is moved";
 
   // Generate the extra diagnostic.
   PathDiagnosticLocation Pos(S, BRC.getSourceManager(),
                              N->getLocationContext());
-  return std::make_shared<PathDiagnosticEventPiece>(Pos, InfoText, true);
+  return std::make_shared<PathDiagnosticEventPiece>(Pos, OS.str(), true);
   }
 
 const ExplodedNode *MoveChecker::getMoveLocation(const ExplodedNode *N,
                                                  const MemRegion *Region,
                                                  CheckerContext &C) const {
   // Walk the ExplodedGraph backwards and find the first node that referred to
   // the tracked region.
   const ExplodedNode *MoveNode = N;
 
   while (N) {
     ProgramStateRef State = N->getState();
     if (!State->get<TrackedRegionMap>(Region))
       break;
     MoveNode = N;
     N = N->pred_empty() ? nullptr : *(N->pred_begin());
   }
   return MoveNode;
 }
 
 ExplodedNode *MoveChecker::reportBug(const MemRegion *Region,
                                      const CXXRecordDecl *RD,
                                      CheckerContext &C,
                                      MisuseKind MK) const {
   if (ExplodedNode *N = C.generateNonFatalErrorNode()) {
     if (!BT)
-      BT.reset(new BugType(this, "Usage of a 'moved-from' object",
+      BT.reset(new BugType(this, "Use-after-move",
                            "C++ move semantics"));
 
     // Uniqueing report to the same object.
     PathDiagnosticLocation LocUsedForUniqueing;
     const ExplodedNode *MoveNode = getMoveLocation(N, Region, C);
 
     if (const Stmt *MoveStmt = PathDiagnosticLocation::getStmt(MoveNode))
       LocUsedForUniqueing = PathDiagnosticLocation::createBegin(
           MoveStmt, C.getSourceManager(), MoveNode->getLocationContext());
 
     // Creating the error message.
-    std::string ErrorMessage;
+    llvm::SmallString<128> Str;
+    llvm::raw_svector_ostream OS(Str);
     switch(MK) {
       case MK_FunCall:
-        ErrorMessage = "Method call on a 'moved-from' object";
+        OS << "Method called on moved-from object";
         break;
       case MK_Copy:
-        ErrorMessage = "Copying a 'moved-from' object";
+        OS << "Moved-from object is copied";
         break;
       case MK_Move:
-        ErrorMessage = "Moving a 'moved-from' object";
+        OS << "Moved-from object is moved";
         break;
     }
-    if (const auto DecReg = Region->getAs<DeclRegion>()) {
-      const auto *RegionDecl = dyn_cast<NamedDecl>(DecReg->getDecl());
-      ErrorMessage += " '" + RegionDecl->getNameAsString() + "'";
-    }
+    explainObject(OS, Region, RD);
 
     auto R =
-        llvm::make_unique<BugReport>(*BT, ErrorMessage, N, LocUsedForUniqueing,
+        llvm::make_unique<BugReport>(*BT, OS.str(), N, LocUsedForUniqueing,
                                      MoveNode->getLocationContext()->getDecl());
-    R->addVisitor(llvm::make_unique<MovedBugVisitor>(Region));
+    R->addVisitor(llvm::make_unique<MovedBugVisitor>(Region, RD));
     C.emitReport(std::move(R));
     return N;
   }
   return nullptr;
 }
 
 void MoveChecker::checkPostCall(const CallEvent &Call,
                                 CheckerContext &C) const {
MoveChecker::ObjectKind MoveChecker::classifyObject(const MemRegion *MR,
   return {
     /*Local=*/
         MR && isa<VarRegion>(MR) && isa<StackSpaceRegion>(MR->getMemorySpace()),
     /*STL=*/
         RD && RD->getDeclContext()->isStdNamespace()
   };
 }
 
+MoveChecker::ObjectKind MoveChecker::explainObject(llvm::raw_ostream &OS,
+                                                   const MemRegion *MR,
+                                                   const CXXRecordDecl *RD) {
+  // We may need a leading space every time we actually explain anything,
+  // and we never know if we are to explain anything until we try.
+  if (const auto DR =
+          dyn_cast_or_null<DeclRegion>(unwrapRValueReferenceIndirection(MR))) {
+    const auto *RegionDecl = cast<NamedDecl>(DR->getDecl());
+    OS << " '" << RegionDecl->getNameAsString() << "'";
+  }
+  ObjectKind OK = classifyObject(MR, RD);
+  if (OK.STL) {
+    OS << " of type '" << RD->getQualifiedNameAsString() << "'";
+  }
+  // Provide the caller with the classification of the object
+  // we've obtained here accidentally, for later use.
+  return OK;
+}
+
 void MoveChecker::checkPreCall(const CallEvent &Call, CheckerContext &C) const {
   ProgramStateRef State = C.getState();
   const LocationContext *LC = C.getLocationContext();
   ExplodedNode *N = nullptr;
 
   // Remove the MemRegions from the map on which a ctor/dtor call or assignment
   // happened.
 

test/Analysis/use-after-move.cpp

static A get() {
     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{{'b' became 'moved-from' here}}
+    // expected-note@-2{{'b' is moved}}
 #endif
   }
   A(A &&other, char *k) {
     moveconstruct(std::move(other));
   }
   void operator=(const A &other) {
     i = other.i;
     d = other.d;

 
 void copyOrMoveCall(A a) {
   a.foo();
 }
 
 void simpleMoveCtorTest() {
   {
     A a;
-    A b = std::move(a); // expected-note {{'a' became 'moved-from' here}}
-    a.foo();            // expected-warning {{Method call on a 'moved-from' object 'a'}} expected-note {{Method call on a 'moved-from' object 'a'}}
+    A b = std::move(a); // expected-note {{'a' is moved}}
+    a.foo();            // expected-warning {{Method called on moved-from object 'a'}} expected-note {{Method called on moved-from object 'a'}}
   }
   {
     A a;
-    A b = std::move(a); // expected-note {{'a' became 'moved-from' here}}
-    b = a;              // expected-warning {{Copying a 'moved-from' object 'a'}} expected-note {{Copying a 'moved-from' object 'a'}}
+    A b = std::move(a); // expected-note {{'a' is moved}}
+    b = a;              // expected-warning {{Moved-from object is copied 'a'}} expected-note {{Moved-from object is copied 'a'}}
   }
   {
     A a;
-    A b = std::move(a); // expected-note {{'a' became 'moved-from' here}}
-    b = std::move(a);   // expected-warning {{Moving a 'moved-from' object 'a'}} expected-note {{Moving a 'moved-from' object 'a'}}
+    A b = std::move(a); // expected-note {{'a' is moved}}
+    b = std::move(a);   // expected-warning {{Moved-from object is moved 'a'}} expected-note {{Moved-from object is moved 'a'}}
   }
 }
 
 void simpleMoveAssignementTest() {
   {
     A a;
     A b;
-    b = std::move(a); // expected-note {{'a' became 'moved-from' here}}
-    a.foo();          // expected-warning {{Method call on a 'moved-from' object 'a'}} expected-note {{Method call on a 'moved-from' object 'a'}}
+    b = std::move(a); // expected-note {{'a' is moved}}
+    a.foo();          // expected-warning {{Method called on moved-from object 'a'}} expected-note {{Method called on moved-from object 'a'}}
   }
   {
     A a;
     A b;
-    b = std::move(a); // expected-note {{'a' became 'moved-from' here}}
-    A c(a);           // expected-warning {{Copying a 'moved-from' object 'a'}} expected-note {{Copying a 'moved-from' object 'a'}}
+    b = std::move(a); // expected-note {{'a' is moved}}
+    A c(a);           // expected-warning {{Moved-from object is copied 'a'}} expected-note {{Moved-from object is copied 'a'}}
   }
   {
     A a;
     A b;
-    b = std::move(a);  // expected-note {{'a' became 'moved-from' here}}
-    A c(std::move(a)); // expected-warning {{Moving a 'moved-from' object 'a'}} expected-note {{Moving a 'moved-from' object 'a'}}
+    b = std::move(a);  // expected-note {{'a' is moved}}
+    A c(std::move(a)); // expected-warning {{Moved-from object is moved 'a'}} expected-note {{Moved-from object is moved 'a'}}
   }
 }
 
 void moveInInitListTest() {
   struct S {
     A a;
   };
   A a;
-  S s{std::move(a)}; // expected-note {{'a' became 'moved-from' here}}
-  a.foo();           // expected-warning {{Method call on a 'moved-from' object 'a'}} expected-note {{Method call on a 'moved-from' object 'a'}}
+  S s{std::move(a)}; // expected-note {{'a' is moved}}
+  a.foo();           // expected-warning {{Method called on moved-from object 'a'}} expected-note {{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);
// code.)
     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); // expected-note {{'a' became 'moved-from' here}}
-    a.foo();          // expected-warning {{Method call on a 'moved-from' object 'a'}} expected-note {{Method call on a 'moved-from' object 'a'}}
+    b = std::move(a); // expected-note {{'a' is moved}}
+    a.foo();          // expected-warning {{Method called on moved-from object 'a'}} expected-note {{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); // expected-note {{'a' became 'moved-from' here}}
+    b = std::move(a); // expected-note {{'a' is moved}}
     if (i < 10) {     // expected-note {{Assuming 'i' is >= 10}} expected-note {{Taking false branch}}
       a = A();
     }
     if (i > 5) { // expected-note {{Taking true branch}}
-      a.foo();   // expected-warning {{Method call on a 'moved-from' object 'a'}} expected-note {{Method call on a 'moved-from' object 'a'}}
+      a.foo();   // expected-warning {{Method called on moved-from object 'a'}} expected-note {{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));
for (int i = 0; i < 2; i++) { // expected-note {{Loop condition is true.}}
       //expected-note@-1 {{Loop condition is true.  Entering loop body}}
       //expected-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++) { // expected-note {{Loop condition is true.  Entering loop body}} expected-note {{Loop condition is true.  Entering loop body}}
-      constCopyOrMoveCall(std::move(a)); // expected-warning {{Moving a 'moved-from' object 'a'}} expected-note {{Moving a 'moved-from' object 'a'}}
-      // expected-note@-1 {{'a' became 'moved-from' here}}
+      constCopyOrMoveCall(std::move(a)); // expected-warning {{Moved-from object is moved 'a'}} expected-note {{Moved-from object is moved 'a'}}
+      // expected-note@-1 {{'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); // expected-note {{'a' became 'moved-from' here}}
+  b = std::move(a); // expected-note {{'a' is moved}}
 
   if (cond) { // expected-note {{Assuming 'cond' is not equal to 0}} expected-note {{Taking true branch}}
-    a.foo();  // expected-warning {{Method call on a 'moved-from' object 'a'}} expected-note {{Method call on a 'moved-from' object 'a'}}
+    a.foo();  // expected-warning {{Method called on moved-from object 'a'}} expected-note {{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); // expected-note {{'a' became 'moved-from' here}}
-  a.foo();             // expected-warning {{Method call on a 'moved-from' object 'a'}} expected-note {{Method call on a 'moved-from' object 'a'}}
+  A a1 = std::move(a); // expected-note {{'a' is moved}}
+  a.foo();             // expected-warning {{Method called on moved-from object 'a'}} expected-note {{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); // expected-note {{'a' became 'moved-from' here}}
+  A b = std::move(a); // expected-note {{'a' is moved}}
   a.empty();          // no-warning
   a.isEmpty();        // no-warning
   (void)a;            // no-warning
   (bool)a;            // expected-warning {{expression result unused}}
-  a.foo();            // expected-warning {{Method call on a 'moved-from' object 'a'}} expected-note {{Method call on a 'moved-from' object 'a'}}
+  a.foo();            // expected-warning {{Method called on moved-from object 'a'}} expected-note {{Method called on moved-from object 'a'}}
 }
 
 void moveStateResetFunctionsTest() {
   {
     A a;
     A b = std::move(a);
     a.reset(); // no-warning
     a.foo();   // no-warning
class memberVariablesTest {
   A a;
   static A static_a;
 
   void f() {
     A b;
     b = std::move(a);
     a.foo();
 #ifdef AGGRESSIVE
-    // expected-note@-3{{'a' became 'moved-from' here}}
-    // expected-warning@-3 {{Method call on a 'moved-from' object 'a'}}
-    // expected-note@-4{{Method call on a 'moved-from' object 'a'}}
+    // expected-note@-3{{'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(static_a);
     static_a.foo();
 #ifdef AGGRESSIVE
-    // expected-note@-3{{'static_a' became 'moved-from' here}}
-    // expected-warning@-3{{Method call on a 'moved-from' object 'static_a'}}
-    // expected-note@-4{{Method call on a 'moved-from' object 'static_a'}}
+    // expected-note@-3{{'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
   }
 };
 
 void PtrAndArrayTest() {
   A *Ptr = new A(1, 1.5);
   A Arr[10];
   Arr[2] = std::move(*Ptr);
   (*Ptr).foo();
 #ifdef AGGRESSIVE
-  // expected-note@-3{{Became 'moved-from' here}}
-  // expected-warning@-3{{Method call on a 'moved-from' object}}
-  // expected-note@-4{{Method call on a 'moved-from' object}}
+  // 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
 
   Ptr = &Arr[1];
   Arr[3] = std::move(Arr[1]);
   Ptr->foo();
 #ifdef AGGRESSIVE
-  // expected-note@-3{{Became 'moved-from' here}}
-  // expected-warning@-3{{Method call on a 'moved-from' object}}
-  // expected-note@-4{{Method call on a 'moved-from' object}}
+  // 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{{Became 'moved-from' here}}
-  // expected-warning@-3{{Method call on a 'moved-from' object}}
-  // expected-note@-4{{Method call on a 'moved-from' object}}
+  // 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(Arr[3]); // reinitialization
   Arr[2].foo();               // no-warning
 }
 
 void exclusiveConditionsTest(bool cond) {
   A a;
case 2:
       break;
     }
   }
   // However, if there's a fallthrough, we do warn.
   {
     A a, b;
     switch (i) { // expected-note {{Control jumps to 'case 1:'}}
     case 1:
-      b = std::move(a); // expected-note {{'a' became 'moved-from' here}}
+      b = std::move(a); // expected-note {{'a' is moved}}
     case 2:
-      a.foo(); // expected-warning {{Method call on a 'moved-from' object}} expected-note {{Method call on a 'moved-from' object 'a'}}
+      a.foo(); // expected-warning {{Method called on moved-from object}} expected-note {{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(); // expected-warning {{Method call on a 'moved-from' object 'a'}} expected-note {{Method call on a 'moved-from' object 'a'}}
+  a.bar(); // expected-warning {{Method called on moved-from object 'a'}} expected-note {{Method called on moved-from object 'a'}}
 }
 
 void interFunTest2() {
   A a;
   A b;
-  b = std::move(a); // expected-note {{'a' became 'moved-from' here}}
+  b = std::move(a); // expected-note {{'a' is moved}}
   interFunTest1(a); // expected-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()); // expected-warning {{Method call on a 'moved-from' object 'a'}} expected-note {{Method call on a 'moved-from' object 'a'}}
-  // expected-note@-1 {{'a' became 'moved-from' here}}
+  foobar(std::move(a), a.getI()); // expected-warning {{Method called on moved-from object 'a'}} expected-note {{Method called on moved-from object 'a'}}
+  // expected-note@-1 {{'a' is moved}}
 
   //FALSE NEGATIVE since parameters evaluate order is undefined
   foobar(a.getI(), std::move(a)); //no-warning
 }
 
 void not_known(A &a);
 void not_known(A *a);
 

 // initializer expressions.
 void declarationSequenceTest() {
   {
     A a;
     A a1 = a, a2 = std::move(a); // no-warning
   }
   {
     A a;
-    A a1 = std::move(a), a2 = a; // expected-warning {{Copying a 'moved-from' object 'a'}} expected-note {{Copying a 'moved-from' object 'a'}}
-    // expected-note@-1 {{'a' became 'moved-from' here}}
+    A a1 = std::move(a), a2 = a; // expected-warning {{Moved-from object is copied 'a'}} expected-note {{Moved-from object is copied 'a'}}
+    // expected-note@-1 {{'a' is moved}}
   }
 }
 
 // The logical operators && and || sequence their operands.
 void logicalOperatorsSequenceTest() {
   {
     A a;
     if (a.foo() > 0 && A(std::move(a)).foo() > 0) { // expected-note {{Assuming the condition is false}} expected-note {{Assuming the condition is false}} 
// into the AST).
     if (!(a.foo() > 0 && A(std::move(a)).foo() > 0)) { // expected-note {{Assuming the condition is false}} expected-note {{Assuming the condition is false}}
       // expected-note@-1 {{Left side of '&&' is false}} expected-note@-1 {{Left side of '&&' is false}}
       // expected-note@-2 {{Taking true branch}} expected-note@-2 {{Taking true branch}}
       A().bar();
     }
   }
   {
     A a;
-    if (A(std::move(a)).foo() > 0 && a.foo() > 0) { // expected-warning {{Method call on a 'moved-from' object 'a'}} expected-note {{Method call on a 'moved-from' object 'a'}}
-      // expected-note@-1 {{'a' became 'moved-from' here}} expected-note@-1 {{Assuming the condition is true}} expected-note@-1 {{Assuming the condition is false}}
+    if (A(std::move(a)).foo() > 0 && a.foo() > 0) { // expected-warning {{Method called on moved-from object 'a'}} expected-note {{Method called on moved-from object 'a'}}
+      // expected-note@-1 {{'a' is moved}} expected-note@-1 {{Assuming the condition is true}} expected-note@-1 {{Assuming the condition is false}}
       // expected-note@-2 {{Left side of '&&' is false}} expected-note@-2 {{Left side of '&&' is true}}
       // expected-note@-3 {{Taking false branch}}
       A().bar();
     }
   }
   {
     A a;
     if (a.foo() > 0 || A(std::move(a)).foo() > 0) { // expected-note {{Assuming the condition is true}} 
       //expected-note@-1 {{Left side of '||' is true}}
       //expected-note@-2 {{Taking true branch}}
       A().bar();
     }
   }
   {
     A a;
-    if (A(std::move(a)).foo() > 0 || a.foo() > 0) { // expected-warning {{Method call on a 'moved-from' object 'a'}} expected-note {{Method call on a 'moved-from' object 'a'}}
-      // expected-note@-1 {{'a' became 'moved-from' here}} expected-note@-1 {{Assuming the condition is false}} expected-note@-1 {{Left side of '||' is false}}
+    if (A(std::move(a)).foo() > 0 || a.foo() > 0) { // expected-warning {{Method called on moved-from object 'a'}} expected-note {{Method called on moved-from object 'a'}}
+      // expected-note@-1 {{'a' is moved}} expected-note@-1 {{Assuming the condition is false}} expected-note@-1 {{Left side of '||' is false}}
       A().bar();
     }
   }
 }
 
 // A range-based for sequences the loop variable declaration before the body.
 void forRangeSequencesTest() {
   A v[2] = {A(), A()};

 };
 
 void subRegionMoveTest() {
   {
     A a;
     B b = std::move(a.b);
     a.b.foo();
 #ifdef AGGRESSIVE
-    // expected-note@-3{{'b' became 'moved-from' here}}
-    // expected-warning@-3{{Method call on a 'moved-from' object 'b'}}
-    // expected-note@-4 {{Method call on a 'moved-from' object 'b'}}
+    // expected-note@-3{{'b' is moved}}
+    // expected-warning@-3{{Method called on moved-from object 'b'}}
+    // expected-note@-4 {{Method called on moved-from object 'b'}}
 #endif
   }
   {
     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 call on a 'moved-from' object 'b'}}
-    // expected-note@-5{{Method call on a 'moved-from' object 'b'}}
+    // expected-warning@-4{{Method called on moved-from object 'b'}}
+    // expected-note@-5{{Method called on moved-from object 'b'}}
 #endif
   }
   // Don't report a misuse if any SuperRegion is already reported.
   {
     A a;
-    A a1 = std::move(a); // expected-note {{'a' became 'moved-from' here}}
-    a.foo();             // expected-warning {{Method call on a 'moved-from' object 'a'}} expected-note {{Method call on a 'moved-from' object 'a'}}
+    A a1 = std::move(a); // expected-note {{'a' is moved}}
+    a.foo();             // expected-warning {{Method called on moved-from object 'a'}} expected-note {{Method called on moved-from object 'a'}}
     a.b.foo();           // no-warning
   }
   {
     C c;
-    C c1 = std::move(c); // expected-note {{'c' became 'moved-from' here}}
-    c.foo();             // expected-warning {{Method call on a 'moved-from' object 'c'}} expected-note {{Method call on a 'moved-from' object 'c'}}
+    C c1 = std::move(c); // expected-note {{'c' is moved}}
+    c.foo();             // expected-warning {{Method called on moved-from object 'c'}} expected-note {{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); // expected-note {{'c' became 'moved-from' here}}
-  c.foo();             // expected-warning {{Method call on a 'moved-from' object 'c'}} expected-note {{Method call on a 'moved-from' object 'c'}}
+  C c1 = std::move(c); // expected-note {{'c' is moved}}
+  c.foo();             // expected-warning {{Method called on moved-from object 'c'}} expected-note {{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
MoveOnlyWithDestructor foo() {
   return m;
 }
 
 class HasSTLField {
   std::vector<int> V;
   void foo() {
     // 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{{'V' became 'moved-from' here}}
-    V.push_back(123); // expected-warning{{Method call on a 'moved-from' object 'V'}}
-                      // expected-note@-1{{Method call on a 'moved-from' object 'V'}}
+    std::vector<int> W = std::move(V); // expected-note{{Object 'V' of type 'std::vector' is left in 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'}}
   }
 };
 
 void foo(A &&a) {
-  A b = std::move(a); // expected-note{{'a' became 'moved-from' here}}
-  a.foo(); // expected-warning{{Method call on a 'moved-from' object}}
-           // expected-note@-1{{Method call on a 'moved-from' object}}
+  A b = std::move(a); // expected-note{{Object 'a' is moved}}
+  a.foo(); // expected-warning{{Method called on moved-from object 'a'}}
+           // expected-note@-1{{Method called on moved-from object 'a'}}
 }