[clang-tidy] Fix bug in bugprone-use-after-move check

[ymandel]

Summary

The bugprone-use-after-move check exhibits false positives for certain uses of
the C++17 if/switch init statements. These false positives are caused by a bug
in the ExprSequence calculations.

This revision adds tests for the false positives and fixes the corresponding
sequence calculation.

Patch by Shuai Wang.

[gribozavr]

Thanks for the quick fix!

clang-tools-extra/test/clang-tidy/bugprone-use-after-move.cpp

1198 ↗

(On Diff #219140)

Unless you think it is redundant, could you also add

if (A a1; A(std::move(a2)).getInt() > 0) {}

Also some true positive tests would be good:

if (A a1; A(std::move(a2)).getInt() > A(std::move(a2)).getInt()) {}

A a1;
if (A a2 = std::move(a1); A(std::move(a1)) > 0) {}

[ymandel]

Added tests.

[ymandel]

clang-tools-extra/test/clang-tidy/bugprone-use-after-move.cpp

1198 ↗

(On Diff #219140)

Done, but any idea why everything in this function is placed inside a loop? Looks like its just for scoping, but then why not just a compound statement, as is done above? This feels very odd.

[gribozavr]

clang-tools-extra/test/clang-tidy/bugprone-use-after-move.cpp

1198 ↗

(On Diff #219140)

I think it is to ensure that the checker understands the sequencing. If it didn't, then the loop would trigger the "moved twice" logic.

[mboehme]

clang-tools-extra/test/clang-tidy/bugprone-use-after-move.cpp

1198 ↗

(On Diff #219140)

(Original author of the test here.)

Correct. I should probably have added a comment explaining this when I wrote the test. Feel free to add such a comment.

[ymandel]

clang-tools-extra/test/clang-tidy/bugprone-use-after-move.cpp

1198 ↗

(On Diff #219140)

Thanks for clarifying. I added a sentence to the comment as you suggested.

clang-tools-extra/trunk/clang-tidy/utils/ExprSequence.cpp

for (const Stmt *Parent : getParentStmts(S, Context)) {
     } else if (const auto *ForRange = dyn_cast<CXXForRangeStmt>(Parent)) {
       // Range-based for: Loop variable declaration is sequenced before the
       // body. (We need this rule because these get placed in the same
       // CFGBlock.)
       if (S == ForRange->getLoopVarStmt())
         return ForRange->getBody();
     } else if (const auto *TheIfStmt = dyn_cast<IfStmt>(Parent)) {
       // If statement:
-      // - Sequence init statement before variable declaration.
+      // - Sequence init statement before variable declaration, if present;
+      //   before condition evaluation, otherwise.
       // - Sequence variable declaration (along with the expression used to
       //   initialize it) before the evaluation of the condition.
-      if (S == TheIfStmt->getInit())
+      if (S == TheIfStmt->getInit()) {
+        if (TheIfStmt->getConditionVariableDeclStmt() != nullptr)
           return TheIfStmt->getConditionVariableDeclStmt();
+        return TheIfStmt->getCond();
+      }
       if (S == TheIfStmt->getConditionVariableDeclStmt())
         return TheIfStmt->getCond();
     } else if (const auto *TheSwitchStmt = dyn_cast<SwitchStmt>(Parent)) {
       // Ditto for switch statements.
-      if (S == TheSwitchStmt->getInit())
+      if (S == TheSwitchStmt->getInit()) {
+        if (TheSwitchStmt->getConditionVariableDeclStmt() != nullptr)
           return TheSwitchStmt->getConditionVariableDeclStmt();
+        return TheSwitchStmt->getCond();
+      }
       if (S == TheSwitchStmt->getConditionVariableDeclStmt())
         return TheSwitchStmt->getCond();
     } else if (const auto *TheWhileStmt = dyn_cast<WhileStmt>(Parent)) {
       // While statement: Sequence variable declaration (along with the
       // expression used to initialize it) before the evaluation of the
       // condition.
       if (S == TheWhileStmt->getConditionVariableDeclStmt())
         return TheWhileStmt->getCond();

clang-tools-extra/trunk/test/clang-tidy/bugprone-use-after-move.cpp

void forRangeSequences() {
   A v[2] = {A(), A()};
   for (A &a : v) {
     std::move(a);
   }
 }
 
 // If a variable is declared in an if, while or switch statement, the init
 // statement (for if and switch) is sequenced before the variable declaration,
-// which in turn is sequenced before the evaluation of the condition.
+// which in turn is sequenced before the evaluation of the condition. We place
+// all tests inside a for loop to ensure that the checker understands the
+// sequencing. If it didn't, then the loop would trigger the "moved twice"
+// logic.
 void ifWhileAndSwitchSequenceInitDeclAndCondition() {
   for (int i = 0; i < 10; ++i) {
     A a1;
     if (A a2 = std::move(a1)) {
       std::move(a2);
     }
   }
   for (int i = 0; i < 10; ++i) {
     A a1;
+    if (A a2 = std::move(a1); a2) {
+      std::move(a2);
+    }
+  }
+  for (int i = 0; i < 10; ++i) {
+    A a1;
     if (A a2 = std::move(a1); A a3 = std::move(a2)) {
       std::move(a3);
     }
   }
+  for (int i = 0; i < 10; ++i) {
+    // init followed by condition with move, but without variable declaration.
+    if (A a1; A(std::move(a1)).getInt() > 0) {}
+  }
+  for (int i = 0; i < 10; ++i) {
+    if (A a1; A(std::move(a1)).getInt() > a1.getInt()) {}
+    // CHECK-NOTES: [[@LINE-1]]:43: warning: 'a1' used after it was moved
+    // CHECK-NOTES: [[@LINE-2]]:15: note: move occurred here
+    // CHECK-NOTES: [[@LINE-3]]:43: note: the use and move are unsequenced
+  }
+  for (int i = 0; i < 10; ++i) {
+    A a1;
+    if (A a2 = std::move(a1); A(a1) > 0) {}
+    // CHECK-NOTES: [[@LINE-1]]:33: warning: 'a1' used after it was moved
+    // CHECK-NOTES: [[@LINE-2]]:16: note: move occurred here
+  }
   while (A a = A()) {
     std::move(a);
   }
   for (int i = 0; i < 10; ++i) {
     A a1;
+    switch (A a2 = std::move(a1); a2) {
+      case true:
+        std::move(a2);
+    }
+  }
+  for (int i = 0; i < 10; ++i) {
+    A a1;
     switch (A a2 = a1; A a3 = std::move(a2)) {
       case true:
         std::move(a3);
     }
   }
 }
 
 // Some statements in templates (e.g. null, break and continue statements) may