// RUN: %check_clang_tidy %s readability-suspicious-call-argument %t -- -- -std=c++11

void foo_1(int aaaaaa, int bbbbbb) {}

void foo_2(int source, int aaaaaa) {}

void foo_3(int valToRet, int aaaaaa) {}

void foo_4(int pointer, int aaaaaa) {}

void foo_5(int aaaaaa, int bbbbbb, int cccccc, ...) {}

void foo_6(const int dddddd, bool &eeeeee) {}

void foo_7(int aaaaaa, int bbbbbb, int cccccc, int ffffff = 7) {}

void foo_8(int frobble1, int frobble2) {}

// Test functions for convertible argument--parameter types.
void fun(const int &m);
void fun2() {
  int m = 3;
  fun(m);
}

// Test cases for parameters of const reference and value.
void value_const_reference(int llllll, const int &kkkkkk);

void const_ref_value_swapped() {
  const int &kkkkkk = 42;
  const int &llllll = 42;
  value_const_reference(kkkkkk, llllll);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'kkkkkk' (passed to 'llllll') looks like it might be swapped with the 2nd, 'llllll' (passed to 'kkkkkk') [readability-suspicious-call-argument]
  // CHECK-MESSAGES: :[[@LINE-7]]:6: note: in the call to 'value_const_reference', declared here
}

// Const, non const references.
void const_nonconst_parameters(const int &mmmmmm, int &nnnnnn);

void const_nonconst_swap1() {
  const int &nnnnnn = 42;
  int mmmmmm;
  // Do not check, because non-const reference parameter cannot bind to const reference argument.
  const_nonconst_parameters(nnnnnn, mmmmmm);
}

void const_nonconst_swap3() {
  const int nnnnnn = 42;
  int m = 42;
  int &mmmmmm = m;
  // Do not check, const int does not bind to non const reference.
  const_nonconst_parameters(nnnnnn, mmmmmm);
}

void const_nonconst_swap2() {
  int nnnnnn;
  int mmmmmm;
  // Check for swapped arguments. (Both arguments are non-const.)
  const_nonconst_parameters(nnnnnn, mmmmmm);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'nnnnnn' (passed to 'mmmmmm') looks like it might be swapped with the 2nd, 'mmmmmm' (passed to 'nnnnnn')
}

void const_nonconst_pointers(const int *mmmmmm, int *nnnnnn);
void const_nonconst_pointers2(const int *mmmmmm, const int *nnnnnn);

void const_nonconst_pointers_swapped() {
  int *mmmmmm;
  const int *nnnnnn;
  const_nonconst_pointers(nnnnnn, mmmmmm);
}

void const_nonconst_pointers_swapped2() {
  const int *mmmmmm;
  int *nnnnnn;
  const_nonconst_pointers2(nnnnnn, mmmmmm);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'nnnnnn' (passed to 'mmmmmm') looks like it might be swapped with the 2nd, 'mmmmmm' (passed to 'nnnnnn')
}

// Test cases for pointers and arrays.
void pointer_array_parameters(
    int *pppppp, int qqqqqq[4]);

void pointer_array_swap() {
  int qqqqqq[5];
  int *pppppp;
  // Check for swapped arguments. An array implicitly converts to a pointer.
  pointer_array_parameters(qqqqqq, pppppp);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'qqqqqq' (passed to 'pppppp') looks like it might be swapped with the 2nd, 'pppppp' (passed to 'qqqqqq')
}

// Test cases for multilevel pointers.
void multilevel_pointer_parameters(int *const **pppppp,
                                   const int *const *volatile const *qqqqqq);
void multilevel_pointer_parameters2(
    char *****nnnnnn, char *volatile *const *const *const *const &mmmmmm);

typedef float T;
typedef T *S;
typedef S *const volatile R;
typedef R *Q;
typedef Q *P;
typedef P *O;
void multilevel_pointer_parameters3(float **const volatile ***rrrrrr, O &ssssss);

void multilevel_pointer_swap() {
  int *const **qqqqqq;
  int *const **pppppp;
  multilevel_pointer_parameters(qqqqqq, pppppp);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'qqqqqq' (passed to 'pppppp') looks like it might be swapped with the 2nd, 'pppppp' (passed to 'qqqqqq')

  char *****mmmmmm;
  char *****nnnnnn;
  multilevel_pointer_parameters2(mmmmmm, nnnnnn);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'mmmmmm' (passed to 'nnnnnn') looks like it might be swapped with the 2nd, 'nnnnnn' (passed to 'mmmmmm')

  float **const volatile ***rrrrrr;
  float **const volatile ***ssssss;
  multilevel_pointer_parameters3(ssssss, rrrrrr);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'ssssss' (passed to 'rrrrrr') looks like it might be swapped with the 2nd, 'rrrrrr' (passed to 'ssssss')
}

void multilevel_pointer_parameters4(char ****pppppp,
                                    char *const volatile **const *qqqqqq);
void multilevel_pointer_parameters5(
    bool *****nnnnnn, bool *volatile *const *const *const *&mmmmmm);
void multilevel_pointer_parameters6(double **llllll, char **&kkkkkk);
void multilevel_pointer_parameters7(const volatile int ***iiiiii,
                                    const int *const *const *jjjjjj);

void multilevel_pointer_swap3() {
  char ****qqqqqq;
  char *const volatile **const *pppppp;
  // Do not check.
  multilevel_pointer_parameters4(qqqqqq, pppppp);

  bool *****mmmmmm;
  bool *volatile *const *const *const *nnnnnn;
  // Do not check.
  multilevel_pointer_parameters5(mmmmmm, nnnnnn);

  double **kkkkkk;
  char **llllll;
  multilevel_pointer_parameters6(kkkkkk, llllll);

  const volatile int ***jjjjjj;
  const int *const *const *iiiiii;
  multilevel_pointer_parameters7(jjjjjj, iiiiii);
}

// Test cases for multidimesional arrays.
void multilevel_array_parameters(int pppppp[2][2][2], const int qqqqqq[][2][2]);

void multilevel_array_parameters2(int (*mmmmmm)[2][2], int nnnnnn[9][2][23]);

void multilevel_array_parameters3(int (*eeeeee)[2][2], int (&ffffff)[1][2][2]);

void multilevel_array_parameters4(int (*llllll)[2][2], int kkkkkk[2][2]);

void multilevel_array_parameters5(int iiiiii[2][2], char jjjjjj[2][2]);

void multilevel_array_parameters6(int (*bbbbbb)[2][2], int cccccc[1][2][2]);

void multilevel_array_swap() {
  int qqqqqq[1][2][2];
  int pppppp[][2][2] = {{{1, 2}, {1, 2}}, {{1, 2}, {1, 2}}}; // int [2][2][2]
  multilevel_array_parameters(qqqqqq, pppppp);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'qqqqqq' (passed to 'pppppp') looks like it might be swapped with the 2nd, 'pppppp' (passed to 'qqqqqq')

  int(*nnnnnn)[2][2];
  int mmmmmm[9][2][23];
  // Do not check, array sizes has to match in every dimension, except the first.
  multilevel_array_parameters2(nnnnnn, mmmmmm);

  int ffffff[][2][2] = {{{1, 2}, {1, 2}}, {{1, 2}, {1, 2}}}; // int [2][2][2]
  int eeeeee[1][2][2] = {{{1, 2}, {1, 2}}};                  // int [1][2][2]
  // Do not check, for array references, size has to match in every dimension.
  multilevel_array_parameters3(ffffff, eeeeee);

  int kkkkkk[2][2][2];
  int(*llllll)[2];
  // Do not check, argument dimensions differ.
  multilevel_array_parameters4(kkkkkk, llllll);

  int jjjjjj[2][2];
  char iiiiii[2][2];
  // Do not check, array element types differ.
  multilevel_array_parameters5(jjjjjj, iiiiii);

  int t[][2][2] = {{{1, 2}, {1, 2}}, {{1, 2}, {1, 2}}}; // int [2][2][2]
  int(*cccccc)[2][2] = t;                               // int (*)[2][2]
  int bbbbbb[][2][2] = {{{1, 2}, {1, 2}}};              // int [1][2][2]
  multilevel_array_parameters6(cccccc, bbbbbb);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'cccccc' (passed to 'bbbbbb') looks like it might be swapped with the 2nd, 'bbbbbb' (passed to 'cccccc')
}

void multilevel_array_swap2() {
  int qqqqqq[2][2][2];
  const int pppppp[][2][2] = {{{1, 2}, {1, 2}}, {{1, 2}, {1, 2}}};
  // Do not check, pppppp is const and cannot bind to an array with nonconst elements.
  multilevel_array_parameters(qqqqqq, pppppp);
}

// Complex test case.
void multilevel_pointer_array_parameters(const int(*const (*volatile const (*const (*const (*const &aaaaaa)[1])[32])[4])[3][2][2]), const int(*const (*volatile const (*const (*const (*&bbbbbb)[1])[32])[4])[3][2][2]));

void multilevel_pointer_array_swap() {
  const int(
          *const(*volatile const(*const(*const(*aaaaaa)[1])[32])[4])[3][2][2]);
  const int(
          *const(*volatile const(*const(*const(*bbbbbb)[1])[32])[4])[3][2][2]);
  multilevel_pointer_array_parameters(bbbbbb, aaaaaa);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'bbbbbb' (passed to 'aaaaaa') looks like it might be swapped with the 2nd, 'aaaaaa' (passed to 'bbbbbb')
}

enum class numbers_scoped { one,
                            two };

// Test cases for arithmetic types.
void arithmetic_type_parameters(float vvvvvv, int wwwwww);
void arithmetic_type_parameters2(numbers_scoped vvvvvv, int wwwwww);

void arithmetic_types_swap1() {
  bool wwwwww;
  float vvvvvv;
  arithmetic_type_parameters(wwwwww, vvvvvv);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'wwwwww' (passed to 'vvvvvv') looks like it might be swapped with the 2nd, 'vvvvvv' (passed to 'wwwwww')
}

void arithmetic_types_swap3() {
  char wwwwww;
  unsigned long long int vvvvvv;
  arithmetic_type_parameters(wwwwww, vvvvvv);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'wwwwww' (passed to 'vvvvvv') looks like it might be swapped with the 2nd, 'vvvvvv' (passed to 'wwwwww')
}

void arithmetic_types_swap4() {
  enum numbers { one,
                 two };
  numbers wwwwww = numbers::one;
  int vvvvvv;
  arithmetic_type_parameters(wwwwww, vvvvvv);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'wwwwww' (passed to 'vvvvvv') looks like it might be swapped with the 2nd, 'vvvvvv' (passed to 'wwwwww')
}

void arithmetic_types_swap5() {
  wchar_t vvvvvv;
  float wwwwww;
  arithmetic_type_parameters(wwwwww, vvvvvv);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'wwwwww' (passed to 'vvvvvv') looks like it might be swapped with the 2nd, 'vvvvvv' (passed to 'wwwwww')
}

void arithmetic_types_swap6() {
  wchar_t vvvvvv;
  numbers_scoped wwwwww = numbers_scoped::one;
  // Do not check, numers is a scoped enum type.
  arithmetic_type_parameters2(wwwwww, vvvvvv);
}

// Base, derived
class TestClass {
public:
  void thisFunction(int integerParam, int thisIsPARAM) {}
};

class DerivedTestClass : public TestClass {};

void base_derived_pointer_parameters(TestClass *aaaaaa,
                                     DerivedTestClass *bbbbbb);

void base_derived_swap1() {
  TestClass *bbbbbb;
  DerivedTestClass *aaaaaa;
  // Do not check, because TestClass does not convert implicitly to DerivedTestClass.
  base_derived_pointer_parameters(bbbbbb, aaaaaa);
}

void base_derived_swap2() {
  DerivedTestClass *bbbbbb, *aaaaaa;
  // Check for swapped arguments, DerivedTestClass converts to TestClass implicitly.
  base_derived_pointer_parameters(bbbbbb, aaaaaa);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'bbbbbb' (passed to 'aaaaaa') looks like it might be swapped with the 2nd, 'aaaaaa' (passed to 'bbbbbb')
}

class PrivateDerivedClass : private TestClass {};

void private_derived_pointer_parameters(TestClass *aaaaaa, PrivateDerivedClass *bbbbbb);

void private_base_swap1() {
  TestClass *bbbbbb;
  PrivateDerivedClass *aaaaaa;
  private_derived_pointer_parameters(bbbbbb, aaaaaa);
}

// Multilevel inheritance
class DerivedOfDerivedTestClass : public DerivedTestClass {};

void multi_level_inheritance_swap() {
  DerivedOfDerivedTestClass *aaaaaa, *bbbbbb;
  // Check for swapped arguments. Derived classes implicitly convert to their base.
  base_derived_pointer_parameters(
      bbbbbb, aaaaaa);
  // CHECK-MESSAGES: :[[@LINE-2]]:3: warning: 1st argument 'bbbbbb' (passed to 'aaaaaa') looks like it might be swapped with the 2nd, 'aaaaaa' (passed to 'bbbbbb')
}

// Tests for function pointer swaps
void funct_ptr_params(double (*ffffff)(int, int), double (*gggggg)(int, int));
void funct_ptr_params(double (*ffffff)(int, int), int (*gggggg)(int, int));

double ffffff(int a, int b) { return 0; }
double gggggg(int a, int b) { return 0; }

void funtionc_ptr_params_swap() {
  funct_ptr_params(gggggg, ffffff);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'gggggg' (passed to 'ffffff') looks like it might be swapped with the 2nd, 'ffffff' (passed to 'gggggg')
}

int fffff(int a, int b) { return 0; }

void function_ptr_swap2() {
  // Do not check, because the function `ffffff` cannot convert to a function
  // with prototype: double(int,int).
  funct_ptr_params(gggggg, fffff);
}

// Paraphrased example from Z3 (src/qe/qe_arrays.cpp) which originally produced
// a false positive. Operator() calls should ignore the called object
// "argument".
struct type1;
struct type2;
struct type3;

struct callable1 {
  void operator()(type1 &mdl, type2 &arr_vars, type3 &fml, type2 &aux_vars) const {}
};

struct callable2 {
  void operator()(type1 &mdl, type2 &arr_vars, type3 &fml, type2 &aux_vars,
                  bool reduce_all_selects) const {
    (void)reduce_all_selects;
    callable1 pe;
    pe(mdl, arr_vars, fml, aux_vars);
    // NO-WARN: Argument and parameter names match perfectly, "pe" should be
    // ignored!
  }
};

struct binop_t {};

binop_t operator+(const binop_t &lhs, const binop_t &rhs) { return lhs; }
bool operator<(const binop_t &lhs, const binop_t &rhs) { return true; }
bool operator>(const binop_t &aaaaaa, const binop_t &bbbbbb) { return false; }

void binop_test() {
  // NO-WARN: Binary operators are ignored.
  binop_t lhs, rhs;
  if (lhs + rhs < rhs)
    return;

  if (operator<(rhs, lhs))
    return;

  binop_t aaaaaa, cccccc;
  if (operator>(cccccc, aaaaaa))
    return;
}

int recursion(int aaaa, int bbbb) {
  if (aaaa)
    return 0;

  int cccc = 0;
  return recursion(bbbb, cccc);
  // NO-WARN: Recursive calls usually shuffle with arguments and we ignore those.
}

void pass_by_copy(binop_t xxxx, binop_t yyyy) {}

// Paraphrased example from LLVM's code (lib/Analysis/InstructionSimplify.cpp)
// that generated a false positive.
struct value;
enum opcode { Foo,
              Bar };
static value *SimplifyRightShift(
    opcode Opcode, value *Op0, value *Op1, bool isExact,
    const type1 &Q, unsigned MaxRecurse) { return nullptr; }
static value *SimplifyLShrInst(value *Op0, value *Op1, bool isExact,
                               const type1 &Q, unsigned MaxRecurse) {
  if (value *V = SimplifyRightShift(Foo, Op0, Op1, isExact, Q, MaxRecurse))
    return V;
  // NO-WARN: Argument names perfectly match parameter names, sans the enum.

  return nullptr;
}

void has_unnamed(int aaaaaa, int) {}

int main() {
  // Equality test.
  int aaaaaa, cccccc = 0;
  foo_1(cccccc, aaaaaa);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'cccccc' (passed to 'aaaaaa') looks like it might be swapped with the 2nd, 'aaaaaa' (passed to 'bbbbbb')

  binop_t xxxx, yyyy;
  pass_by_copy(yyyy, xxxx);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'yyyy' (passed to 'xxxx') looks like it might be swapped with the 2nd, 'xxxx' (passed to 'yyyy')

  // Abbreviation test.
  int src = 0;
  foo_2(aaaaaa, src);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'aaaaaa' (passed to 'source') looks like it might be swapped with the 2nd, 'src' (passed to 'aaaaaa')

  // Levenshtein test.
  int aaaabb = 0;
  foo_1(cccccc, aaaabb);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'cccccc' (passed to 'aaaaaa') looks like it might be swapped with the 2nd, 'aaaabb' (passed to 'bbbbbb')

  // Prefix test.
  int aaaa = 0;
  foo_1(cccccc, aaaa);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'cccccc' (passed to 'aaaaaa') looks like it might be swapped with the 2nd, 'aaaa' (passed to 'bbbbbb')

  // Suffix test.
  int urce = 0;
  foo_2(cccccc, urce);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'cccccc' (passed to 'source') looks like it might be swapped with the 2nd, 'urce' (passed to 'aaaaaa')

  // Substring test.
  int ourc = 0;
  foo_2(cccccc, ourc);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'cccccc' (passed to 'source') looks like it might be swapped with the 2nd, 'ourc' (passed to 'aaaaaa')

  // Jaro-Winkler test.
  int iPonter = 0;
  foo_4(cccccc, iPonter);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'cccccc' (passed to 'pointer') looks like it might be swapped with the 2nd, 'iPonter' (passed to 'aaaaaa')

  // Dice test.
  int aaabaa = 0;
  foo_1(cccccc, aaabaa);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'cccccc' (passed to 'aaaaaa') looks like it might be swapped with the 2nd, 'aaabaa' (passed to 'bbbbbb')

  // Variadic function test.
  int bbbbbb = 0;
  foo_5(src, bbbbbb, cccccc, aaaaaa); // Should pass.
  foo_5(cccccc, bbbbbb, aaaaaa, src);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'cccccc' (passed to 'aaaaaa') looks like it might be swapped with the 3rd, 'aaaaaa' (passed to 'cccccc')

  // Test function with default argument.
  foo_7(src, bbbbbb, cccccc, aaaaaa);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'src' (passed to 'aaaaaa') looks like it might be swapped with the 4th, 'aaaaaa' (passed to 'ffffff')

  foo_7(cccccc, bbbbbb, aaaaaa, src);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'cccccc' (passed to 'aaaaaa') looks like it might be swapped with the 3rd, 'aaaaaa' (passed to 'cccccc')

  int ffffff = 0;
  foo_7(ffffff, bbbbbb, cccccc); // NO-WARN: Even though 'ffffff' is passed to 'aaaaaa' and there is a 4th parameter 'ffffff', there isn't a **swap** here.

  int frobble1 = 1, frobble2 = 2;
  foo_8(frobble2, frobble1);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'frobble2' (passed to 'frobble1') looks like it might be swapped with the 2nd, 'frobble1' (passed to 'frobble2')

  int bar1 = 1, bar2 = 2;
  foo_8(bar2, bar1); // NO-WARN.

  // Type match
  bool dddddd = false;
  int eeeeee = 0;
  auto szam = 0;
  foo_6(eeeeee, dddddd);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'eeeeee' (passed to 'dddddd') looks like it might be swapped with the 2nd, 'dddddd' (passed to 'eeeeee')
  foo_1(szam, aaaaaa);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'szam' (passed to 'aaaaaa') looks like it might be swapped with the 2nd, 'aaaaaa' (passed to 'bbbbbb')

  // Test lambda.
  auto testMethod = [&](int method, int randomParam) { return 0; };
  int method = 0;
  testMethod(method, 0); // Should pass.

  // Member function test.
  TestClass test;
  int integ, thisIsAnArg = 0;
  test.thisFunction(integ, thisIsAnArg); // Should pass.

  has_unnamed(1, bbbbbb);

  return 0;
}

namespace Issue_54074 {

class T {};
using OperatorTy = int(const T &, const T &);
int operator-(const T &, const T &);

template <typename U>
struct Wrap {
  Wrap(U);
};

template <typename V>
void wrapTaker(V, Wrap<OperatorTy>);

template <typename V>
void wrapTaker(V aaaaa, V bbbbb, Wrap<OperatorTy>);

void test() {
  wrapTaker(0, operator-);
  // NO-WARN. No crash!

  int aaaaa = 4, bbbbb = 8;
  wrapTaker(bbbbb, aaaaa, operator-);
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'bbbbb' (passed to 'aaaaa') looks like it might be swapped with the 2nd, 'aaaaa' (passed to 'bbbbb')
  // CHECK-MESSAGES: :[[@LINE-9]]:6: note: in the call to 'wrapTaker<int>', declared here
}

} // namespace Issue_54074
