[clang-tidy] misc-use-after-move: Fix failing assertion

[mboehme]

Summary

I've added a test case that (without the fix) triggers the assertion,
which happens when a move happens in an implicitly called conversion
operator.

[mboehme]

test/clang-tidy/misc-use-after-move.cpp

285

I've seen this column number flapping back and forth between 6 and 7 before.

This seems to be unrelated to my fix and instead is triggered simply by adding the extra test case below; even with my fix present, this reverts back to 7 if I remove the test case. Looks like an obscure bug in the way the column number is computed...

[mboehme]

test/clang-tidy/misc-use-after-move.cpp

285

Should be "reverts back to 6"

[alexfh]

LG. Thanks!

test/clang-tidy/misc-use-after-move.cpp

285

Interesting. Are you sure there's nothing else here in play? Like non-ascii characters or weird line endings?

[mboehme]

test/clang-tidy/misc-use-after-move.cpp

285

I just checked -- nothing I can find. The file doesn't contain any bytes with the high bit set, and there aren't any '\r' either.

[alexfh]

test/clang-tidy/misc-use-after-move.cpp

285

Anyway, the patch LG. We can take a look at the column glitch offline.

clang-tidy/misc/UseAfterMoveCheck.cpp

void UseAfterMoveCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *ContainingLambda =
       Result.Nodes.getNodeAs<LambdaExpr>("containing-lambda");
   const auto *ContainingFunc =
       Result.Nodes.getNodeAs<FunctionDecl>("containing-func");
   const auto *CallMove = Result.Nodes.getNodeAs<CallExpr>("call-move");
   const auto *MovingCall = Result.Nodes.getNodeAs<Expr>("moving-call");
   const auto *Arg = Result.Nodes.getNodeAs<DeclRefExpr>("arg");
 
-  if (!MovingCall)
+  if (!MovingCall || !MovingCall->getExprLoc().isValid())
     MovingCall = CallMove;
 
   Stmt *FunctionBody = nullptr;
   if (ContainingLambda)
     FunctionBody = ContainingLambda->getBody();
   else if (ContainingFunc)
     FunctionBody = ContainingFunc->getBody();
   else

test/clang-tidy/misc-use-after-move.cpp

 void moveInInitList() {
   struct S {
     A a;
   };
   A a;
   S s{std::move(a)};
   a.foo();
   // CHECK-MESSAGES: [[@LINE-1]]:3: warning: 'a' used after it was moved
-  // CHECK-MESSAGES: [[@LINE-3]]:6: note: move occurred here
+  // CHECK-MESSAGES: [[@LINE-3]]:7: note: move occurred here
 }
 
 void lambdas() {
   // Use-after-moves inside a lambda should be detected.
   {
     A a;
     auto lambda = [a] {
       std::move(a);
void movedTypeIsDependentType() {
   T t;
   std::move(t);
   t.foo();
   // CHECK-MESSAGES: [[@LINE-1]]:3: warning: 't' used after it was moved
   // CHECK-MESSAGES: [[@LINE-3]]:3: note: move occurred here
 }
 template void movedTypeIsDependentType<A>();
 
+// We handle the case correctly where the move consists of an implicit call
+// to a conversion operator.
+void implicitConversionOperator() {
+  struct Convertible {
+    operator A() && { return A(); }
+  };
+  void takeA(A a);
+
+  Convertible convertible;
+  takeA(std::move(convertible));
+  convertible;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: 'convertible' used after it was moved
+  // CHECK-MESSAGES: [[@LINE-3]]:9: note: move occurred here
+}
+
 // Using decltype on an expression is not a use.
 void decltypeIsNotUse() {
   A a;
   std::move(a);
   decltype(a) other_a;
 }
 
 // Ignore moves or uses that occur as part of template arguments.