This is an archive of the discontinued LLVM Phabricator instance.

Differential D52228

[clang-tidy] use CHECK-NOTES in tests for bugprone-use-after-move
ClosedPublic

Authored by JonasToth on Sep 18 2018, 4:49 AM.

Details

Reviewers
alexfh
aaron.ballman
hokein
Commits
rG7dd69f15e16c: [clang-tidy] use CHECK-NOTES in tests for bugprone-use-after-move
rCTE343199: [clang-tidy] use CHECK-NOTES in tests for bugprone-use-after-move
rL343199: [clang-tidy] use CHECK-NOTES in tests for bugprone-use-after-move

Diff Detail

Repository
rL LLVM

Event Timeline

JonasToth created this revision.Sep 18 2018, 4:49 AM
Herald added subscribers: cfe-commits, xazax.hun. · View Herald TranscriptSep 18 2018, 4:49 AM
This revision was not accepted when it landed; it landed in state Needs Review.Sep 27 2018, 5:24 AM
Closed by commit rL343199: [clang-tidy] use CHECK-NOTES in tests for bugprone-use-after-move (authored by JonasToth). · Explain Why
This revision was automatically updated to reflect the committed changes.
Herald added a subscriber: llvm-commits. · View Herald TranscriptSep 27 2018, 5:24 AM

Revision Contents

PathSize
clang-tools-extra/
trunk/
test/
clang-tidy/
220 lines

Diff 167293

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

Show First 20 Lines • Show All 119 Lines • ▼ Show 20 Lines
// General tests. // General tests.
// Simple case. // Simple case.
void simple() { void simple() {
A a; A a;
a.foo(); a.foo();
A other_a = std::move(a); A other_a = std::move(a);
a.foo(); a.foo();
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:3: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:15: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:15: note: move occurred here
} }
// A warning should only be emitted for one use-after-move. // A warning should only be emitted for one use-after-move.
void onlyFlagOneUseAfterMove() { void onlyFlagOneUseAfterMove() {
A a; A a;
a.foo(); a.foo();
A other_a = std::move(a); A other_a = std::move(a);
a.foo(); a.foo();
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:3: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:15: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:15: note: move occurred here
a.foo(); a.foo();
} }
void moveAfterMove() { void moveAfterMove() {
// Move-after-move also counts as a use. // Move-after-move also counts as a use.
{ {
A a; A a;
std::move(a); std::move(a);
std::move(a); std::move(a);
// CHECK-MESSAGES: [[@LINE-1]]:15: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:15: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:5: note: move occurred here
} }
// This is also true if the move itself turns into the use on the second loop // This is also true if the move itself turns into the use on the second loop
// iteration. // iteration.
{ {
A a; A a;
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
std::move(a); std::move(a);
// CHECK-MESSAGES: [[@LINE-1]]:17: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:17: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-2]]:7: note: move occurred here // CHECK-NOTES: [[@LINE-2]]:7: note: move occurred here
// CHECK-MESSAGES: [[@LINE-3]]:17: note: the use happens in a later loop // CHECK-NOTES: [[@LINE-3]]:17: note: the use happens in a later loop
} }
} }
} }
// Checks also works on function parameters that have a use-after move. // Checks also works on function parameters that have a use-after move.
void parameters(A a) { void parameters(A a) {
std::move(a); std::move(a);
a.foo(); a.foo();
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:3: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:3: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:3: note: move occurred here
} }
void standardSmartPtr() { void standardSmartPtr() {
// std::unique_ptr<>, std::shared_ptr<> and std::weak_ptr<> are guaranteed to // std::unique_ptr<>, std::shared_ptr<> and std::weak_ptr<> are guaranteed to
// be null after a std::move. So the check only flags accesses that would // be null after a std::move. So the check only flags accesses that would
// dereference the pointer. // dereference the pointer.
{ {
std::unique_ptr<A> ptr; std::unique_ptr<A> ptr;
std::move(ptr); std::move(ptr);
ptr.get(); ptr.get();
static_cast<bool>(ptr); static_cast<bool>(ptr);
*ptr; *ptr;
// CHECK-MESSAGES: [[@LINE-1]]:6: warning: 'ptr' used after it was moved // CHECK-NOTES: [[@LINE-1]]:6: warning: 'ptr' used after it was moved
// CHECK-MESSAGES: [[@LINE-5]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-5]]:5: note: move occurred here
} }
{ {
std::unique_ptr<A> ptr; std::unique_ptr<A> ptr;
std::move(ptr); std::move(ptr);
ptr->foo(); ptr->foo();
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: 'ptr' used after it was moved // CHECK-NOTES: [[@LINE-1]]:5: warning: 'ptr' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:5: note: move occurred here
} }
{ {
std::unique_ptr<A> ptr; std::unique_ptr<A> ptr;
std::move(ptr); std::move(ptr);
ptr[0]; ptr[0];
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: 'ptr' used after it was moved // CHECK-NOTES: [[@LINE-1]]:5: warning: 'ptr' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:5: note: move occurred here
} }
{ {
std::shared_ptr<A> ptr; std::shared_ptr<A> ptr;
std::move(ptr); std::move(ptr);
ptr.get(); ptr.get();
static_cast<bool>(ptr); static_cast<bool>(ptr);
*ptr; *ptr;
// CHECK-MESSAGES: [[@LINE-1]]:6: warning: 'ptr' used after it was moved // CHECK-NOTES: [[@LINE-1]]:6: warning: 'ptr' used after it was moved
// CHECK-MESSAGES: [[@LINE-5]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-5]]:5: note: move occurred here
} }
{ {
std::shared_ptr<A> ptr; std::shared_ptr<A> ptr;
std::move(ptr); std::move(ptr);
ptr->foo(); ptr->foo();
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: 'ptr' used after it was moved // CHECK-NOTES: [[@LINE-1]]:5: warning: 'ptr' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:5: note: move occurred here
} }
{ {
// std::weak_ptr<> cannot be dereferenced directly, so we only check that // std::weak_ptr<> cannot be dereferenced directly, so we only check that
// member functions may be called on it after a move. // member functions may be called on it after a move.
std::weak_ptr<A> ptr; std::weak_ptr<A> ptr;
std::move(ptr); std::move(ptr);
ptr.expired(); ptr.expired();
} }
Show All 24 Linesvoid standardSmartPtr() {
// We don't give any special treatment to types that are called "unique_ptr" // We don't give any special treatment to types that are called "unique_ptr"
// or "shared_ptr" but are not in the "::std" namespace. // or "shared_ptr" but are not in the "::std" namespace.
{ {
struct unique_ptr { struct unique_ptr {
void get(); void get();
} ptr; } ptr;
std::move(ptr); std::move(ptr);
ptr.get(); ptr.get();
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: 'ptr' used after it was moved // CHECK-NOTES: [[@LINE-1]]:5: warning: 'ptr' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:5: note: move occurred here
} }
} }
// The check also works in member functions. // The check also works in member functions.
class Container { class Container {
void useAfterMoveInMemberFunction() { void useAfterMoveInMemberFunction() {
A a; A a;
std::move(a); std::move(a);
a.foo(); a.foo();
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:5: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:5: note: move occurred here
} }
}; };
// We see the std::move() if it's inside a declaration. // We see the std::move() if it's inside a declaration.
void moveInDeclaration() { void moveInDeclaration() {
A a; A a;
A another_a(std::move(a)); A another_a(std::move(a));
a.foo(); a.foo();
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:3: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:5: note: move occurred here
} }
// We see the std::move if it's inside an initializer list. Initializer lists // We see the std::move if it's inside an initializer list. Initializer lists
// are a special case because they cause ASTContext::getParents() to return // are a special case because they cause ASTContext::getParents() to return
// multiple parents for certain nodes in their subtree. This is because // multiple parents for certain nodes in their subtree. This is because
// RecursiveASTVisitor visits both the syntactic and semantic forms of // RecursiveASTVisitor visits both the syntactic and semantic forms of
// InitListExpr, and the parent-child relationships are different between the // InitListExpr, and the parent-child relationships are different between the
// two forms. // two forms.
void moveInInitList() { void moveInInitList() {
struct S { struct S {
A a; A a;
}; };
A a; A a;
S s{std::move(a)}; S s{std::move(a)};
a.foo(); a.foo();
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:3: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:7: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:7: note: move occurred here
} }
void lambdas() { void lambdas() {
// Use-after-moves inside a lambda should be detected. // Use-after-moves inside a lambda should be detected.
{ {
A a; A a;
auto lambda = [a] { auto lambda = [a] {
std::move(a); std::move(a);
a.foo(); a.foo();
// CHECK-MESSAGES: [[@LINE-1]]:7: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:7: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:7: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:7: note: move occurred here
}; };
} }
// This is just as true if the variable was declared inside the lambda. // This is just as true if the variable was declared inside the lambda.
{ {
auto lambda = [] { auto lambda = [] {
A a; A a;
std::move(a); std::move(a);
a.foo(); a.foo();
// CHECK-MESSAGES: [[@LINE-1]]:7: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:7: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:7: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:7: note: move occurred here
}; };
} }
// But don't warn if the move happened inside the lambda but the use happened // But don't warn if the move happened inside the lambda but the use happened
// outside -- because // outside -- because
// - the 'a' inside the lambda is a copy, and // - the 'a' inside the lambda is a copy, and
// - we don't know when the lambda will get called anyway // - we don't know when the lambda will get called anyway
{ {
A a; A a;
auto lambda = [a] { auto lambda = [a] {
std::move(a); std::move(a);
}; };
a.foo(); a.foo();
} }
// Warn if the use consists of a capture that happens after a move. // Warn if the use consists of a capture that happens after a move.
{ {
A a; A a;
std::move(a); std::move(a);
auto lambda = [a]() { a.foo(); }; auto lambda = [a]() { a.foo(); };
// CHECK-MESSAGES: [[@LINE-1]]:20: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:20: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:5: note: move occurred here
} }
// ...even if the capture was implicit. // ...even if the capture was implicit.
{ {
A a; A a;
std::move(a); std::move(a);
auto lambda = [=]() { a.foo(); }; auto lambda = [=]() { a.foo(); };
// CHECK-MESSAGES: [[@LINE-1]]:20: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:20: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:5: note: move occurred here
} }
// Same tests but for capture by reference. // Same tests but for capture by reference.
{ {
A a; A a;
std::move(a); std::move(a);
auto lambda = [&a]() { a.foo(); }; auto lambda = [&a]() { a.foo(); };
// CHECK-MESSAGES: [[@LINE-1]]:21: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:21: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:5: note: move occurred here
} }
{ {
A a; A a;
std::move(a); std::move(a);
auto lambda = [&]() { a.foo(); }; auto lambda = [&]() { a.foo(); };
// CHECK-MESSAGES: [[@LINE-1]]:20: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:20: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:5: note: move occurred here
} }
// But don't warn if the move happened after the capture. // But don't warn if the move happened after the capture.
{ {
A a; A a;
auto lambda = [a]() { a.foo(); }; auto lambda = [a]() { a.foo(); };
std::move(a); std::move(a);
} }
// ...and again, same thing with an implicit move. // ...and again, same thing with an implicit move.
Show All 18 Lines
// Use-after-moves are detected in uninstantiated templates if the moved type // Use-after-moves are detected in uninstantiated templates if the moved type
// is not a dependent type. // is not a dependent type.
template <class T> template <class T>
void movedTypeIsNotDependentType() { void movedTypeIsNotDependentType() {
T t; T t;
A a; A a;
std::move(a); std::move(a);
a.foo(); a.foo();
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:3: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:3: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:3: note: move occurred here
} }
// And if the moved type is a dependent type, the use-after-move is detected if // And if the moved type is a dependent type, the use-after-move is detected if
// the template is instantiated. // the template is instantiated.
template <class T> template <class T>
void movedTypeIsDependentType() { void movedTypeIsDependentType() {
T t; T t;
std::move(t); std::move(t);
t.foo(); t.foo();
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: 't' used after it was moved // CHECK-NOTES: [[@LINE-1]]:3: warning: 't' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:3: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:3: note: move occurred here
} }
template void movedTypeIsDependentType<A>(); template void movedTypeIsDependentType<A>();
// We handle the case correctly where the move consists of an implicit call // We handle the case correctly where the move consists of an implicit call
// to a conversion operator. // to a conversion operator.
void implicitConversionOperator() { void implicitConversionOperator() {
struct Convertible { struct Convertible {
operator A() && { return A(); } operator A() && { return A(); }
}; };
void takeA(A a); void takeA(A a);
Convertible convertible; Convertible convertible;
takeA(std::move(convertible)); takeA(std::move(convertible));
convertible; convertible;
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: 'convertible' used after it was moved // CHECK-NOTES: [[@LINE-1]]:3: warning: 'convertible' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:9: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:9: note: move occurred here
} }
// Using decltype on an expression is not a use. // Using decltype on an expression is not a use.
void decltypeIsNotUse() { void decltypeIsNotUse() {
A a; A a;
std::move(a); std::move(a);
decltype(a) other_a; decltype(a) other_a;
} }
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
void useAndMoveInLoop() { void useAndMoveInLoop() {
// Warn about use-after-moves if they happen in a later loop iteration than // Warn about use-after-moves if they happen in a later loop iteration than
// the std::move(). // the std::move().
{ {
A a; A a;
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
a.foo(); a.foo();
// CHECK-MESSAGES: [[@LINE-1]]:7: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:7: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE+2]]:7: note: move occurred here // CHECK-NOTES: [[@LINE+2]]:7: note: move occurred here
// CHECK-MESSAGES: [[@LINE-3]]:7: note: the use happens in a later loop // CHECK-NOTES: [[@LINE-3]]:7: note: the use happens in a later loop
std::move(a); std::move(a);
} }
} }
// However, this case shouldn't be flagged -- the scope of the declaration of // However, this case shouldn't be flagged -- the scope of the declaration of
// 'a' is important. // 'a' is important.
{ {
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
A a; A a;
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Linesvoid differentBranches(int i) {
// However, if there's a fallthrough, we do warn. // However, if there's a fallthrough, we do warn.
{ {
A a; A a;
switch (i) { switch (i) {
case 1: case 1:
std::move(a); std::move(a);
case 2: case 2:
a.foo(); a.foo();
// CHECK-MESSAGES: [[@LINE-1]]:7: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:7: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-4]]:7: note: move occurred here // CHECK-NOTES: [[@LINE-4]]:7: note: move occurred here
break; break;
} }
} }
} }
// False positive: A use-after-move is flagged even though the "if (b)" and // False positive: A use-after-move is flagged even though the "if (b)" and
// "if (!b)" are mutually exclusive. // "if (!b)" are mutually exclusive.
void mutuallyExclusiveBranchesFalsePositive(bool b) { void mutuallyExclusiveBranchesFalsePositive(bool b) {
A a; A a;
if (b) { if (b) {
std::move(a); std::move(a);
} }
if (!b) { if (!b) {
a.foo(); a.foo();
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:5: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-5]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-5]]:5: note: move occurred here
} }
} }
// Destructors marked [[noreturn]] are handled correctly in the control flow // Destructors marked [[noreturn]] are handled correctly in the control flow
// analysis. (These are used in some styles of assertion macros.) // analysis. (These are used in some styles of assertion macros.)
class FailureLogger { class FailureLogger {
public: public:
FailureLogger(); FailureLogger();
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Linesvoid assignments(int i) {
} }
// A std::move() after the assignment makes the variable invalid again. // A std::move() after the assignment makes the variable invalid again.
{ {
A a; A a;
std::move(a); std::move(a);
a = A(); a = A();
std::move(a); std::move(a);
a.foo(); a.foo();
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:5: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:5: note: move occurred here
} }
// Report a use-after-move if we can't be sure that the variable was assigned // Report a use-after-move if we can't be sure that the variable was assigned
// to. // to.
{ {
A a; A a;
std::move(a); std::move(a);
if (i < 10) { if (i < 10) {
a = A(); a = A();
} }
if (i > 5) { if (i > 5) {
a.foo(); a.foo();
// CHECK-MESSAGES: [[@LINE-1]]:7: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:7: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-7]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-7]]:5: note: move occurred here
} }
} }
} }
// Passing the object to a function through a non-const pointer or reference // Passing the object to a function through a non-const pointer or reference
// counts as a re-initialization. // counts as a re-initialization.
void passByNonConstPointer(A *); void passByNonConstPointer(A *);
void passByNonConstReference(A &); void passByNonConstReference(A &);
Show All 19 Lines
void passByConstPointerIsUse() { void passByConstPointerIsUse() {
{ {
// Declaring 'a' as const so that no ImplicitCastExpr is inserted into the // Declaring 'a' as const so that no ImplicitCastExpr is inserted into the
// AST -- we wouldn't want the check to rely solely on that to detect a // AST -- we wouldn't want the check to rely solely on that to detect a
// const pointer argument. // const pointer argument.
const A a; const A a;
std::move(a); std::move(a);
passByConstPointer(&a); passByConstPointer(&a);
// CHECK-MESSAGES: [[@LINE-1]]:25: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:25: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:5: note: move occurred here
} }
const A a; const A a;
std::move(a); std::move(a);
passByConstReference(a); passByConstReference(a);
// CHECK-MESSAGES: [[@LINE-1]]:24: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:24: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:3: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:3: note: move occurred here
} }
// Clearing a standard container using clear() is treated as a // Clearing a standard container using clear() is treated as a
// re-initialization. // re-initialization.
void standardContainerClearIsReinit() { void standardContainerClearIsReinit() {
{ {
std::string container; std::string container;
std::move(container); std::move(container);
▲ Show 20 Lines • Show All 88 Lines • ▼ Show 20 Linesvoid standardContainerClearIsReinit() {
// But it shouldn't work for non-standard containers. // But it shouldn't work for non-standard containers.
{ {
// This might be called "vector", but it's not in namespace "std". // This might be called "vector", but it's not in namespace "std".
struct vector { struct vector {
void clear() {} void clear() {}
} container; } container;
std::move(container); std::move(container);
container.clear(); container.clear();
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: 'container' used after it was // CHECK-NOTES: [[@LINE-1]]:5: warning: 'container' used after it was
// CHECK-MESSAGES: [[@LINE-3]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:5: note: move occurred here
} }
// An intervening clear() on a different container does not reinitialize. // An intervening clear() on a different container does not reinitialize.
{ {
std::vector<int> container1, container2; std::vector<int> container1, container2;
std::move(container1); std::move(container1);
container2.clear(); container2.clear();
container1.empty(); container1.empty();
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: 'container1' used after it was // CHECK-NOTES: [[@LINE-1]]:5: warning: 'container1' used after it was
// CHECK-MESSAGES: [[@LINE-4]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-4]]:5: note: move occurred here
} }
} }
// Clearing a standard container using assign() is treated as a // Clearing a standard container using assign() is treated as a
// re-initialization. // re-initialization.
void standardContainerAssignIsReinit() { void standardContainerAssignIsReinit() {
{ {
std::string container; std::string container;
Show All 28 Linesvoid standardContainerAssignIsReinit() {
// But it doesn't work for non-standard containers. // But it doesn't work for non-standard containers.
{ {
// This might be called "vector", but it's not in namespace "std". // This might be called "vector", but it's not in namespace "std".
struct vector { struct vector {
void assign(std::size_t, int) {} void assign(std::size_t, int) {}
} container; } container;
std::move(container); std::move(container);
container.assign(0, 0); container.assign(0, 0);
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: 'container' used after it was // CHECK-NOTES: [[@LINE-1]]:5: warning: 'container' used after it was
// CHECK-MESSAGES: [[@LINE-3]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:5: note: move occurred here
} }
// An intervening assign() on a different container does not reinitialize. // An intervening assign() on a different container does not reinitialize.
{ {
std::vector<int> container1, container2; std::vector<int> container1, container2;
std::move(container1); std::move(container1);
container2.assign(0, 0); container2.assign(0, 0);
container1.empty(); container1.empty();
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: 'container1' used after it was // CHECK-NOTES: [[@LINE-1]]:5: warning: 'container1' used after it was
// CHECK-MESSAGES: [[@LINE-4]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-4]]:5: note: move occurred here
} }
} }
// Resetting the standard smart pointer types using reset() is treated as a // Resetting the standard smart pointer types using reset() is treated as a
// re-initialization. (We don't test std::weak_ptr<> because it can't be // re-initialization. (We don't test std::weak_ptr<> because it can't be
// dereferenced directly.) // dereferenced directly.)
void standardSmartPointerResetIsReinit() { void standardSmartPointerResetIsReinit() {
{ {
Show All 10 Linesvoid standardSmartPointerResetIsReinit() {
} }
} }
void reinitAnnotation() { void reinitAnnotation() {
{ {
AnnotatedContainer<int> obj; AnnotatedContainer<int> obj;
std::move(obj); std::move(obj);
obj.foo(); obj.foo();
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: 'obj' used after it was // CHECK-NOTES: [[@LINE-1]]:5: warning: 'obj' used after it was
// CHECK-MESSAGES: [[@LINE-3]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:5: note: move occurred here
} }
{ {
AnnotatedContainer<int> obj; AnnotatedContainer<int> obj;
std::move(obj); std::move(obj);
obj.clear(); obj.clear();
obj.foo(); obj.foo();
} }
{ {
// Calling clear() on a different object to the one that was moved is not // Calling clear() on a different object to the one that was moved is not
// considered a reinitialization. // considered a reinitialization.
AnnotatedContainer<int> obj1, obj2; AnnotatedContainer<int> obj1, obj2;
std::move(obj1); std::move(obj1);
obj2.clear(); obj2.clear();
obj1.foo(); obj1.foo();
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: 'obj1' used after it was // CHECK-NOTES: [[@LINE-1]]:5: warning: 'obj1' used after it was
// CHECK-MESSAGES: [[@LINE-4]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-4]]:5: note: move occurred here
} }
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// Tests related to order of evaluation within expressions // Tests related to order of evaluation within expressions
// Relative sequencing of move and use. // Relative sequencing of move and use.
void passByRvalueReference(int i, A &&a); void passByRvalueReference(int i, A &&a);
Show All 16 Linesvoid sequencingOfMoveAndUse() {
// defined, the move may happen before the call to a.getInt(). // defined, the move may happen before the call to a.getInt().
// //
// Check that we warn about a potential use-after move for both orderings of // Check that we warn about a potential use-after move for both orderings of
// a.getInt() and std::move(a), independent of the order in which the // a.getInt() and std::move(a), independent of the order in which the
// arguments happen to get evaluated by the compiler. // arguments happen to get evaluated by the compiler.
{ {
A a; A a;
passByValue(a.getInt(), std::move(a)); passByValue(a.getInt(), std::move(a));
// CHECK-MESSAGES: [[@LINE-1]]:17: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:17: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-2]]:29: note: move occurred here // CHECK-NOTES: [[@LINE-2]]:29: note: move occurred here
// CHECK-MESSAGES: [[@LINE-3]]:17: note: the use and move are unsequenced // CHECK-NOTES: [[@LINE-3]]:17: note: the use and move are unsequenced
} }
{ {
A a; A a;
passByValue(std::move(a), a.getInt()); passByValue(std::move(a), a.getInt());
// CHECK-MESSAGES: [[@LINE-1]]:31: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:31: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-2]]:17: note: move occurred here // CHECK-NOTES: [[@LINE-2]]:17: note: move occurred here
// CHECK-MESSAGES: [[@LINE-3]]:31: note: the use and move are unsequenced // CHECK-NOTES: [[@LINE-3]]:31: note: the use and move are unsequenced
} }
// An even more convoluted example. // An even more convoluted example.
{ {
A a; A a;
g(g(a, std::move(a)), g(a, std::move(a))); g(g(a, std::move(a)), g(a, std::move(a)));
// CHECK-MESSAGES: [[@LINE-1]]:9: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:9: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-2]]:27: note: move occurred here // CHECK-NOTES: [[@LINE-2]]:27: note: move occurred here
// CHECK-MESSAGES: [[@LINE-3]]:9: note: the use and move are unsequenced // CHECK-NOTES: [[@LINE-3]]:9: note: the use and move are unsequenced
// CHECK-MESSAGES: [[@LINE-4]]:29: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-4]]:29: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-5]]:7: note: move occurred here // CHECK-NOTES: [[@LINE-5]]:7: note: move occurred here
// CHECK-MESSAGES: [[@LINE-6]]:29: note: the use and move are unsequenced // CHECK-NOTES: [[@LINE-6]]:29: note: the use and move are unsequenced
} }
// This case is fine because the actual move only happens inside the call to // This case is fine because the actual move only happens inside the call to
// operator=(). a.getInt(), by necessity, is evaluated before that call. // operator=(). a.getInt(), by necessity, is evaluated before that call.
{ {
A a; A a;
A vec[1]; A vec[1];
vec[a.getInt()] = std::move(a); vec[a.getInt()] = std::move(a);
} }
// However, in the following case, the move happens before the assignment, and // However, in the following case, the move happens before the assignment, and
// so the order of evaluation is not guaranteed. // so the order of evaluation is not guaranteed.
{ {
A a; A a;
int v[3]; int v[3];
v[a.getInt()] = intFromA(std::move(a)); v[a.getInt()] = intFromA(std::move(a));
// CHECK-MESSAGES: [[@LINE-1]]:7: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:7: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-2]]:21: note: move occurred here // CHECK-NOTES: [[@LINE-2]]:21: note: move occurred here
// CHECK-MESSAGES: [[@LINE-3]]:7: note: the use and move are unsequenced // CHECK-NOTES: [[@LINE-3]]:7: note: the use and move are unsequenced
} }
{ {
A a; A a;
int v[3]; int v[3];
v[intFromA(std::move(a))] = intFromInt(a.i); v[intFromA(std::move(a))] = intFromInt(a.i);
// CHECK-MESSAGES: [[@LINE-1]]:44: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:44: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-2]]:7: note: move occurred here // CHECK-NOTES: [[@LINE-2]]:7: note: move occurred here
// CHECK-MESSAGES: [[@LINE-3]]:44: note: the use and move are unsequenced // CHECK-NOTES: [[@LINE-3]]:44: note: the use and move are unsequenced
} }
} }
// Relative sequencing of move and reinitialization. If the two are unsequenced, // Relative sequencing of move and reinitialization. If the two are unsequenced,
// we conservatively assume that the move happens after the reinitialization, // we conservatively assume that the move happens after the reinitialization,
// i.e. the that object does not get reinitialized after the move. // i.e. the that object does not get reinitialized after the move.
A MutateA(A a); A MutateA(A a);
void passByValue(A a1, A a2); void passByValue(A a1, A a2);
void sequencingOfMoveAndReinit() { void sequencingOfMoveAndReinit() {
// Move and reinitialization as function arguments (which are indeterminately // Move and reinitialization as function arguments (which are indeterminately
// sequenced). Again, check that we warn for both orderings. // sequenced). Again, check that we warn for both orderings.
{ {
A a; A a;
passByValue(std::move(a), (a = A())); passByValue(std::move(a), (a = A()));
a.foo(); a.foo();
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:5: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:17: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:17: note: move occurred here
} }
{ {
A a; A a;
passByValue((a = A()), std::move(a)); passByValue((a = A()), std::move(a));
a.foo(); a.foo();
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:5: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:28: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:28: note: move occurred here
} }
// Common usage pattern: Move the object to a function that mutates it in some // Common usage pattern: Move the object to a function that mutates it in some
// way, then reassign the result to the object. This pattern is fine. // way, then reassign the result to the object. This pattern is fine.
{ {
A a; A a;
a = MutateA(std::move(a)); a = MutateA(std::move(a));
a.foo(); a.foo();
} }
} }
// Relative sequencing of reinitialization and use. If the two are unsequenced, // Relative sequencing of reinitialization and use. If the two are unsequenced,
// we conservatively assume that the reinitialization happens after the use, // we conservatively assume that the reinitialization happens after the use,
// i.e. that the object is not reinitialized at the point in time when it is // i.e. that the object is not reinitialized at the point in time when it is
// used. // used.
void sequencingOfReinitAndUse() { void sequencingOfReinitAndUse() {
// Reinitialization and use in function arguments. Again, check both possible // Reinitialization and use in function arguments. Again, check both possible
// orderings. // orderings.
{ {
A a; A a;
std::move(a); std::move(a);
passByValue(a.getInt(), (a = A())); passByValue(a.getInt(), (a = A()));
// CHECK-MESSAGES: [[@LINE-1]]:17: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:17: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:5: note: move occurred here
} }
{ {
A a; A a;
std::move(a); std::move(a);
passByValue((a = A()), a.getInt()); passByValue((a = A()), a.getInt());
// CHECK-MESSAGES: [[@LINE-1]]:28: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:28: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:5: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:5: note: move occurred here
} }
} }
// The comma operator sequences its operands. // The comma operator sequences its operands.
void commaOperatorSequences() { void commaOperatorSequences() {
{ {
A a; A a;
A(std::move(a)) A(std::move(a))
, (a = A()); , (a = A());
a.foo(); a.foo();
} }
{ {
A a; A a;
(a = A()), A(std::move(a)); (a = A()), A(std::move(a));
a.foo(); a.foo();
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:5: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-3]]:16: note: move occurred here // CHECK-NOTES: [[@LINE-3]]:16: note: move occurred here
} }
} }
// An initializer list sequences its initialization clauses. // An initializer list sequences its initialization clauses.
void initializerListSequences() { void initializerListSequences() {
{ {
struct S1 { struct S1 {
int i; int i;
A a; A a;
}; };
A a; A a;
S1 s1{a.getInt(), std::move(a)}; S1 s1{a.getInt(), std::move(a)};
} }
{ {
struct S2 { struct S2 {
A a; A a;
int i; int i;
}; };
A a; A a;
S2 s2{std::move(a), a.getInt()}; S2 s2{std::move(a), a.getInt()};
// CHECK-MESSAGES: [[@LINE-1]]:25: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:25: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-2]]:11: note: move occurred here // CHECK-NOTES: [[@LINE-2]]:11: note: move occurred here
} }
} }
// A declaration statement containing multiple declarations sequences the // A declaration statement containing multiple declarations sequences the
// initializer expressions. // initializer expressions.
void declarationSequences() { void declarationSequences() {
{ {
A a; A a;
A a1 = a, a2 = std::move(a); A a1 = a, a2 = std::move(a);
} }
{ {
A a; A a;
A a1 = std::move(a), a2 = a; A a1 = std::move(a), a2 = a;
// CHECK-MESSAGES: [[@LINE-1]]:31: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:31: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-2]]:12: note: move occurred here // CHECK-NOTES: [[@LINE-2]]:12: note: move occurred here
} }
} }
// The logical operators && and || sequence their operands. // The logical operators && and || sequence their operands.
void logicalOperatorsSequence() { void logicalOperatorsSequence() {
{ {
A a; A a;
if (a.getInt() > 0 && A(std::move(a)).getInt() > 0) { if (a.getInt() > 0 && A(std::move(a)).getInt() > 0) {
A().foo(); A().foo();
} }
} }
// A variation: Negate the result of the && (which pushes the && further down // A variation: Negate the result of the && (which pushes the && further down
// into the AST). // into the AST).
{ {
A a; A a;
if (!(a.getInt() > 0 && A(std::move(a)).getInt() > 0)) { if (!(a.getInt() > 0 && A(std::move(a)).getInt() > 0)) {
A().foo(); A().foo();
} }
} }
{ {
A a; A a;
if (A(std::move(a)).getInt() > 0 && a.getInt() > 0) { if (A(std::move(a)).getInt() > 0 && a.getInt() > 0) {
// CHECK-MESSAGES: [[@LINE-1]]:41: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:41: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-2]]:9: note: move occurred here // CHECK-NOTES: [[@LINE-2]]:9: note: move occurred here
A().foo(); A().foo();
} }
} }
{ {
A a; A a;
if (a.getInt() > 0 || A(std::move(a)).getInt() > 0) { if (a.getInt() > 0 || A(std::move(a)).getInt() > 0) {
A().foo(); A().foo();
} }
} }
{ {
A a; A a;
if (A(std::move(a)).getInt() > 0 || a.getInt() > 0) { if (A(std::move(a)).getInt() > 0 || a.getInt() > 0) {
// CHECK-MESSAGES: [[@LINE-1]]:41: warning: 'a' used after it was moved // CHECK-NOTES: [[@LINE-1]]:41: warning: 'a' used after it was moved
// CHECK-MESSAGES: [[@LINE-2]]:9: note: move occurred here // CHECK-NOTES: [[@LINE-2]]:9: note: move occurred here
A().foo(); A().foo();
} }
} }
} }
// A range-based for sequences the loop variable declaration before the body. // A range-based for sequences the loop variable declaration before the body.
void forRangeSequences() { void forRangeSequences() {
A v[2] = {A(), A()}; A v[2] = {A(), A()};
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines