clang/test/Analysis/use-after-move.cpp

// 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 core,cplusplus.SmartPtrModeling,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\
// RUN:  -analyzer-checker core,cplusplus.SmartPtrModeling,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\
// RUN:  -analyzer-checker core,cplusplus.SmartPtrModeling,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\
// RUN:  -analyzer-config cplusplus.Move:WarnOn=KnownsOnly\
// RUN:  -analyzer-checker core,cplusplus.SmartPtrModeling,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\
// RUN:  -analyzer-checker core,cplusplus.SmartPtrModeling,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\
// RUN:  -analyzer-config cplusplus.Move:WarnOn=All\
// RUN:  -analyzer-checker core,cplusplus.SmartPtrModeling,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
// CHECK-MOVE-INVALID-VALUE-SAME: 'cplusplus.Move:WarnOn', that expects either
// CHECK-MOVE-INVALID-VALUE-SAME: "KnownsOnly", "KnownsAndLocals" or "All"
// CHECK-MOVE-INVALID-VALUE-SAME: string value

// Tests checker-messages printing.
// 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\
// RUN:  -analyzer-config cplusplus.Move:WarnOn=All -DAGGRESSIVE_DFS\
// RUN:  -analyzer-checker core,cplusplus.SmartPtrModeling,debug.ExprInspection\
// RUN:  -verify=expected,peaceful,aggressive %s 2>&1 | FileCheck %s

#include "Inputs/system-header-simulator-cxx.h"

void clang_analyzer_warnIfReached();
void clang_analyzer_printState();

class B {
public:
  B() = default;
  B(const B &) = default;
  B(B &&) = default;
  B& operator=(const B &q) = default;
  void operator=(B &&b) {
    return;
  }
  void foo() { return; }
};

class A {
  int i;
  double d;

public:
  B b;
  A(int ii = 42, double dd = 1.0) : d(dd), i(ii), b(B()) {}
  void moveconstruct(A &&other) {
    std::swap(b, other.b);
    std::swap(d, other.d);
    std::swap(i, other.i);
    return;
  }
  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)) { // 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;
    return;
  }
  void operator=(A &&other) {
    moveconstruct(std::move(other));
    return;
  }
  int getI() { return i; }
  int foo() const;
  void bar() const;
  void reset();
  void destroy();
  void clear();
  void resize(std::size_t);
  void assign(const A &);
  bool empty() const;
  bool isEmpty() const;
  operator bool() const;

  void testUpdateField() {
    A a;
    A b = std::move(a);
    a.i = 1;
    a.foo(); // no-warning
  }
  void testUpdateFieldDouble() {
    A a;
    A b = std::move(a);
    a.d = 1.0;
    a.foo(); // no-warning
  }
};

int bignum();

void moveInsideFunctionCall(A a) {
  A b = std::move(a);
}
void leftRefCall(A &a) {
  a.foo();
}
void rightRefCall(A &&a) {
  a.foo();
}
void constCopyOrMoveCall(const A a) {
  a.foo();
}

void copyOrMoveCall(A a) {
  a.foo();
}

void simpleMoveCtorTest() {
  {
    A a;
    A b = std::move(a); // peaceful-note {{Object 'a' is moved}}

#ifdef AGGRESSIVE_DFS
    clang_analyzer_printState();

// CHECK:      "checker_messages": [
// CHECK-NEXT:   { "checker": "cplusplus.Move", "messages": [
// CHECK-NEXT:     "Moved-from objects :",
// CHECK:          "a: moved",
// CHECK:          ""
// CHECK-NEXT:   ]}
// CHECK-NEXT: ]
#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 = 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); // 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); // 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); // 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); // 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)}; // 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) { // 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) { // 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) { // peaceful-note 2 {{'i' is not equal to 1}}
                  // peaceful-note@-1 2 {{Taking false branch}}
      (void)std::move(a);
    }
    if (i == 2) { // peaceful-note 2 {{'i' is not equal to 2}}
                  // peaceful-note@-1 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); // 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); // 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) { // peaceful-note {{'i' is > 5}}
                 // 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'}}
    }
  }
}

// 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;
    // 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++) { // 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++) { // 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++) { // 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++) { // 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++) { // 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++) { // 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++) { // 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++) { // 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++) { // 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++) { // 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); // peaceful-note {{Object 'a' is moved}}

  if (cond) { // peaceful-note {{Assuming 'cond' is true}}
              // 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); // 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); // 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(); // 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
    // Test if resets the state of subregions as well.
    a.b.foo(); // no-warning
  }
  {
    A a;
    A b = std::move(a);
    a.destroy(); // no-warning
    a.foo();     // no-warning
  }
  {
    A a;
    A b = std::move(a);
    a.clear(); // no-warning
    a.foo();   // no-warning
    a.b.foo(); // no-warning
  }
  {
    A a;
    A b = std::move(a);
    a.resize(0); // no-warning
    a.foo();   // no-warning
    a.b.foo(); // no-warning
  }
  {
    A a;
    A b = std::move(a);
    a.assign(A()); // no-warning
    a.foo();   // no-warning
    a.b.foo(); // no-warning
  }
}

// Moves or uses that occur as part of template arguments.
template <int>
class ClassTemplate {
public:
  void foo(A a);
};

template <int>
void functionTemplate(A a);

void templateArgIsNotUseTest() {
  {
    // A pattern like this occurs in the EXPECT_EQ and ASSERT_EQ macros in
    // Google Test.
    A a;
    ClassTemplate<sizeof(A(std::move(a)))>().foo(std::move(a)); // no-warning
  }
  {
    A a;
    functionTemplate<sizeof(A(std::move(a)))>(std::move(a)); // no-warning
  }
}

// Moves of global variables are not reported.
A global_a;
void globalVariablesTest() {
  (void)std::move(global_a);
  global_a.foo(); // no-warning
}

// Moves of member variables.
class memberVariablesTest {
  A a;
  static A static_a;

  void f() {
    A b;
    b = std::move(a); // aggressive-note {{Object 'a' is moved}}

    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); // 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]); // 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) { // 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
    // peaceful-note@-1 {{'i' is > 0}}
    // peaceful-note@-2 {{'?' condition is true}}
  }
  // A variation on the theme above.
  {
    A a;
    a.foo() > 0 ? a.foo() : A(std::move(a)).foo();
    // peaceful-note@-1 {{Assuming the condition is true}}
    // peaceful-note@-2 {{'?' condition is true}}
  }
  // Same thing, but with a switch statement.
  {
    A a, b;
    switch (i) { // peaceful-note {{Control jumps to 'case 1:'}}
    case 1:
      b = std::move(a); // no-warning
      // 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) { // peaceful-note {{Control jumps to 'case 1:'}}
    case 1:
      b = std::move(a); // peaceful-note {{Object 'a' is moved}}
    case 2:
      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 lifeTimeExtendTest() {
  A&& a = A{};
  A b = std::move(a); // peaceful-note {{Object is moved}}

  a.foo(); // peaceful-warning {{Method called on moved-from object}}
           // peaceful-note@-1 {{Method called on moved-from object}}
}

void interFunTest1(A &a) {
  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); // 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()); // 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); // peaceful-note{{Object 'a' is moved}}
    not_known_pass_by_const_ref(a);
    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); // peaceful-note {{Object 'a' is moved}}
    not_known_pass_by_const_ptr(&a);
    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; // 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) { // 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:
                                                    // peaceful-note@-4 {{Assuming the condition is false}}
                                                    // peaceful-note@-5 {{Left side of '&&' is false}}
                                                    // peaceful-note@-6 {{Taking false branch}}
      A().bar();
    }
  }
  // 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)) { // 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:
                                                       // 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) { // 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:
                                                    // 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) { // 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) { // 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()};
  for (A &a : v) {
    A b;
    b = std::move(a); // no-warning
  }
}

// If a variable is declared in an if statement, the declaration of the variable
// (which is treated like a reinitialization by the check) is sequenced before
// the evaluation of the condition (which constitutes a use).
void ifStmtSequencesDeclAndConditionTest() {
  for (int i = 0; i < 3; ++i) {
    if (A a = A()) {
      A b;
      b = std::move(a); // no-warning
    }
  }
}

struct C : public A {
  [[clang::reinitializes]] void reinit();
};

void subRegionMoveTest() {
  {
    A a;
    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); // 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); // 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); // 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); // 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.
  Empty e{};
  return e; // no-warning
}

void checkInlinedCallZombies() {
  while (true)
    inlinedCall();
}

void checkLoopZombies() {
  while (true) {
    Empty e{};
    Empty f = std::move(e); // no-warning
  }
}

void checkMoreLoopZombies1(bool flag) {
  while (flag) {
    Empty e{};
    if (true)
      e; // expected-warning {{expression result unused}}
    Empty f = std::move(e); // no-warning
  }
}

bool coin();

void checkMoreLoopZombies2(bool flag) {
  while (flag) {
    Empty e{};
    while (coin())
      e; // expected-warning {{expression result unused}}
    Empty f = std::move(e); // no-warning
  }
}

void checkMoreLoopZombies3(bool flag) {
  while (flag) {
    Empty e{};
    do
      e; // expected-warning {{expression result unused}}
    while (coin());
    Empty f = std::move(e); // no-warning
  }
}

void checkMoreLoopZombies4(bool flag) {
  while (flag) {
    Empty e{};
    for (; coin();)
      e; // expected-warning {{expression result unused}}
    Empty f = std::move(e); // no-warning
  }
}

void checkExplicitDestructorCalls() {
  // The below code segments invoke the destructor twice (explicit and 
  // implicit). While this is not a desired code behavior, it is 
  // not the use-after-move checker's responsibility to issue such a warning.
  {
     B* b = new B;
     B a = std::move(*b);
     b->~B(); // no-warning 
     delete b;
  }
  {
    B a, b;
    new (&a) B(reinterpret_cast<B &&>(b));
    (&b)->~B(); // no-warning
  }
  {
    B b;
    B a  = std::move(b);
    b.~B(); // no-warning 
  }
}

struct MoveOnlyWithDestructor {
  MoveOnlyWithDestructor();
  ~MoveOnlyWithDestructor();
  MoveOnlyWithDestructor(const MoveOnlyWithDestructor &m) = delete;
  MoveOnlyWithDestructor(MoveOnlyWithDestructor &&m);
};

MoveOnlyWithDestructor foo() {
  MoveOnlyWithDestructor m;
  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::unique_ptr<int> P;
  void testUniquePtr() {
    // unique_ptr remains in a well-defined state after move.
    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; // 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); // 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); // 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'}}
}

void getAfterMove(std::unique_ptr<A> P) {
  std::unique_ptr<A> Q = std::move(P); // peaceful-note {{Object 'P' is moved}}

  // TODO: Explain why (bool)P is false.
  if (P) // peaceful-note{{Taking false branch}}
    clang_analyzer_warnIfReached(); // no-warning

  A *a = P.get(); // peaceful-warning {{Method called on moved-from object 'P'}}
                  // peaceful-note@-1 {{Method called on moved-from object 'P'}}

  // TODO: Warn on a null dereference here.
  a->foo();
}

struct OtherMoveSafeClasses {
  std::packaged_task<int(void)> Task;

  void test() {
    // Test the suppression caused by use-after-move semantics of
    // std::package_task being different from other standard classes.
    // Only warn in aggressive mode. Don't say that the object
    // is left in unspecified state after move.
    std::packaged_task<int(void)> Task2 = std::move(Task);
    // aggressive-note@-1   {{Object 'Task' is moved}}
    std::packaged_task<int(void)> Task3 = std::move(Task);
    // aggressive-warning@-1{{Moved-from object 'Task' is moved}}
    // aggressive-note@-2   {{Moved-from object 'Task' is moved}}
  }
};