// RUN: %check_clang_tidy -std=c++11-or-later %s google-readability-casting %t

bool g() { return false; }

enum Enum { Enum1 };
struct X {};
struct Y : public X {};

void f(int a, double b, const char *cpc, const void *cpv, X *pX) {
  const char *cpc2 = (const char*)cpc;
  // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: redundant cast to the same type [google-readability-casting]
  // CHECK-FIXES: const char *cpc2 = cpc;

  typedef const char *Typedef1;
  typedef const char *Typedef2;
  Typedef1 t1;
  (Typedef2)t1;
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: C-style casts are discouraged; use static_cast (if needed, the cast may be redundant) [google-readability-casting]
  // CHECK-FIXES: {{^}}  static_cast<Typedef2>(t1);
  (const char*)t1;
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: {{.*}}; use static_cast (if needed
  // CHECK-FIXES: {{^}}  static_cast<const char*>(t1);
  (Typedef1)cpc;
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: {{.*}}; use static_cast (if needed
  // CHECK-FIXES: {{^}}  static_cast<Typedef1>(cpc);
  (Typedef1)t1;
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: redundant cast to the same type
  // CHECK-FIXES: {{^}}  t1;

  char *pc = (char*)cpc;
  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: C-style casts are discouraged; use const_cast [google-readability-casting]
  // CHECK-FIXES: char *pc = const_cast<char*>(cpc);
  typedef char Char;
  Char *pChar = (Char*)pc;
  // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: {{.*}}; use static_cast (if needed
  // CHECK-FIXES: {{^}}  Char *pChar = static_cast<Char*>(pc);

  (Char)*cpc;
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: {{.*}}; use static_cast (if needed
  // CHECK-FIXES: {{^}}  static_cast<Char>(*cpc);

  (char)*pChar;
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: {{.*}}; use static_cast (if needed
  // CHECK-FIXES: {{^}}  static_cast<char>(*pChar);

  (const char*)cpv;
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: {{.*}}; use static_cast [
  // CHECK-FIXES: static_cast<const char*>(cpv);

  char *pc2 = (char*)(cpc + 33);
  // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: {{.*}}; use const_cast [
  // CHECK-FIXES: char *pc2 = const_cast<char*>(cpc + 33);

  const char &crc = *cpc;
  char &rc = (char&)crc;
  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: {{.*}}; use const_cast [
  // CHECK-FIXES: char &rc = const_cast<char&>(crc);

  char &rc2 = (char&)*cpc;
  // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: {{.*}}; use const_cast [
  // CHECK-FIXES: char &rc2 = const_cast<char&>(*cpc);

  char ** const* const* ppcpcpc;
  char ****ppppc = (char****)ppcpcpc;
  // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: {{.*}}; use const_cast [
  // CHECK-FIXES: char ****ppppc = const_cast<char****>(ppcpcpc);

  char ***pppc = (char***)*(ppcpcpc);
  // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: {{.*}}; use const_cast [
  // CHECK-FIXES: char ***pppc = const_cast<char***>(*(ppcpcpc));

  char ***pppc2 = (char***)(*ppcpcpc);
  // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: {{.*}}; use const_cast [
  // CHECK-FIXES: char ***pppc2 = const_cast<char***>(*ppcpcpc);

  char *pc5 = (char*)(const char*)(cpv);
  // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: {{.*}}; use const_cast [
  // CHECK-MESSAGES: :[[@LINE-2]]:22: warning: {{.*}}; use static_cast [
  // CHECK-FIXES: char *pc5 = const_cast<char*>(static_cast<const char*>(cpv));

  int b1 = (int)b;
  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: {{.*}}; use static_cast [
  // CHECK-FIXES: int b1 = static_cast<int>(b);
  b1 = (const int&)b;
  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: {{.*}}; use static_cast/const_cast/reinterpret_cast [
  // CHECK-FIXES: b1 = (const int&)b;

  b1 = (int) b;
  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: {{.*}}; use static_cast {{.*}}
  // CHECK-FIXES: b1 = static_cast<int>(b);

  b1 = (int)         b;
  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: {{.*}}; use static_cast {{.*}}
  // CHECK-FIXES: b1 = static_cast<int>(b);

  b1 = (int) (b);
  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: {{.*}}; use static_cast {{.*}}
  // CHECK-FIXES: b1 = static_cast<int>(b);

  b1 = (int)         (b);
  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: {{.*}}; use static_cast {{.*}}
  // CHECK-FIXES: b1 = static_cast<int>(b);

  Y *pB = (Y*)pX;
  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: {{.*}}; use static_cast/const_cast/reinterpret_cast [
  Y &rB = (Y&)*pX;
  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: {{.*}}; use static_cast/const_cast/reinterpret_cast [

  const char *pc3 = (const char*)cpv;
  // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: {{.*}}; use static_cast [
  // CHECK-FIXES: const char *pc3 = static_cast<const char*>(cpv);

  char *pc4 = (char*)cpv;
  // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: {{.*}}; use static_cast/const_cast/reinterpret_cast [
  // CHECK-FIXES: char *pc4 = (char*)cpv;

  b1 = (int)Enum1;
  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: {{.*}}; use static_cast [
  // CHECK-FIXES: b1 = static_cast<int>(Enum1);

  Enum e = (Enum)b1;
  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: {{.*}}; use static_cast [
  // CHECK-FIXES: Enum e = static_cast<Enum>(b1);

  e = (Enum)Enum1;
  // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: redundant cast to the same type
  // CHECK-FIXES: {{^}}  e = Enum1;

  e = (Enum)e;
  // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: redundant cast to the same type
  // CHECK-FIXES: {{^}}  e = e;

  e = (Enum)           e;
  // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: redundant cast to the same type
  // CHECK-FIXES: {{^}}  e = e;

  e = (Enum)           (e);
  // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: redundant cast to the same type
  // CHECK-FIXES: {{^}}  e = (e);

  static const int kZero = 0;
  (int)kZero;
  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: redundant cast to the same type
  // CHECK-FIXES: {{^}}  kZero;

  int b2 = static_cast<double>(b);
  int b3 = b;
  double aa = a;
  (void)aa;
  return (void)g();
}

template <typename T>
void template_function(T t, int n) {
  int i = (int)t;
  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: {{.*}}; use static_cast/const_cast/reinterpret_cast [
  // CHECK-FIXES: int i = (int)t;
  int j = (int)n;
  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant cast to the same type
  // CHECK-FIXES: int j = n;
}

template <typename T>
struct TemplateStruct {
  void f(T t, int n) {
    int k = (int)t;
    // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: {{.*}}; use static_cast/const_cast/reinterpret_cast
    // CHECK-FIXES: int k = (int)t;
    int l = (int)n;
    // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: redundant cast to the same type
    // CHECK-FIXES: int l = n;
  }
};

void test_templates() {
  template_function(1, 42);
  template_function(1.0, 42);
  TemplateStruct<int>().f(1, 42);
  TemplateStruct<double>().f(1.0, 42);
}

extern "C" {
void extern_c_code(const char *cpc) {
  const char *cpc2 = (const char*)cpc;
  // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: redundant cast to the same type
  // CHECK-FIXES: const char *cpc2 = cpc;
  char *pc = (char*)cpc;
}
}

#define CAST(type, value) (type)(value)
void macros(double d) {
  int i = CAST(int, d);
}

enum E { E1 = 1 };
template <E e>
struct A {
  // Usage of template argument e = E1 is represented as (E)1 in the AST for
  // some reason. We have a special treatment of this case to avoid warnings
  // here.
  static const E ee = e;
};
struct B : public A<E1> {};


void overloaded_function();
void overloaded_function(int);

template<typename Fn>
void g(Fn fn) {
  fn();
}

void function_casts() {
  typedef void (*FnPtrVoid)();
  typedef void (&FnRefVoid)();
  typedef void (&FnRefInt)(int);

  g((void (*)())overloaded_function);
  // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: C-style casts are discouraged; use static_cast [
  // CHECK-FIXES: g(static_cast<void (*)()>(overloaded_function));
  g((void (*)())&overloaded_function);
  // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: C-style casts are discouraged; use static_cast [
  // CHECK-FIXES: g(static_cast<void (*)()>(&overloaded_function));
  g((void (&)())overloaded_function);
  // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: C-style casts are discouraged; use static_cast [
  // CHECK-FIXES: g(static_cast<void (&)()>(overloaded_function));

  g((FnPtrVoid)overloaded_function);
  // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: C-style casts are discouraged; use static_cast [
  // CHECK-FIXES: g(static_cast<FnPtrVoid>(overloaded_function));
  g((FnPtrVoid)&overloaded_function);
  // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: C-style casts are discouraged; use static_cast [
  // CHECK-FIXES: g(static_cast<FnPtrVoid>(&overloaded_function));
  g((FnRefVoid)overloaded_function);
  // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: C-style casts are discouraged; use static_cast [
  // CHECK-FIXES: g(static_cast<FnRefVoid>(overloaded_function));

  FnPtrVoid fn0 = (void (*)())&overloaded_function;
  // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: C-style casts are discouraged; use static_cast [
  // CHECK-FIXES: FnPtrVoid fn0 = static_cast<void (*)()>(&overloaded_function);
  FnPtrVoid fn1 = (void (*)())overloaded_function;
  // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: C-style casts are discouraged; use static_cast [
  // CHECK-FIXES: FnPtrVoid fn1 = static_cast<void (*)()>(overloaded_function);
  FnPtrVoid fn1a = (FnPtrVoid)overloaded_function;
  // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: C-style casts are discouraged; use static_cast [
  // CHECK-FIXES: FnPtrVoid fn1a = static_cast<FnPtrVoid>(overloaded_function);
  FnRefInt fn2 = (void (&)(int))overloaded_function;
  // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: C-style casts are discouraged; use static_cast [
  // CHECK-FIXES: FnRefInt fn2 = static_cast<void (&)(int)>(overloaded_function);
  auto fn3 = (void (*)())&overloaded_function;
  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: C-style casts are discouraged; use static_cast [
  // CHECK-FIXES: auto fn3 = static_cast<void (*)()>(&overloaded_function);
  auto fn4 = (void (*)())overloaded_function;
  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: C-style casts are discouraged; use static_cast [
  // CHECK-FIXES: auto fn4 = static_cast<void (*)()>(overloaded_function);
  auto fn5 = (void (&)(int))overloaded_function;
  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: C-style casts are discouraged; use static_cast [
  // CHECK-FIXES: auto fn5 = static_cast<void (&)(int)>(overloaded_function);

  void (*fn6)() = (void (*)())&overloaded_function;
  // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: C-style casts are discouraged; use static_cast [
  // CHECK-FIXES: void (*fn6)() = static_cast<void (*)()>(&overloaded_function);
  void (*fn7)() = (void (*)())overloaded_function;
  // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: C-style casts are discouraged; use static_cast [
  // CHECK-FIXES: void (*fn7)() = static_cast<void (*)()>(overloaded_function);
  void (*fn8)() = (FnPtrVoid)overloaded_function;
  // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: C-style casts are discouraged; use static_cast [
  // CHECK-FIXES: void (*fn8)() = static_cast<FnPtrVoid>(overloaded_function);
  void (&fn9)(int) = (void (&)(int))overloaded_function;
  // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: C-style casts are discouraged; use static_cast [
  // CHECK-FIXES: void (&fn9)(int) = static_cast<void (&)(int)>(overloaded_function);

  void (*correct1)() = static_cast<void (*)()>(overloaded_function);
  FnPtrVoid correct2 = static_cast<void (*)()>(&overloaded_function);
  FnRefInt correct3 = static_cast<void (&)(int)>(overloaded_function);
}

struct S {
    S(const char *);
};
struct ConvertibleToS {
  operator S() const;
};
struct ConvertibleToSRef {
  operator const S&() const;
};

void conversions() {
  //auto s1 = (const S&)"";
  // C HECK-MESSAGES: :[[@LINE-1]]:10: warning: C-style casts are discouraged; use static_cast [
  // C HECK-FIXES: S s1 = static_cast<const S&>("");
  auto s2 = (S)"";
  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: C-style casts are discouraged; use constructor call syntax [
  // CHECK-FIXES: auto s2 = S("");
  auto s2a = (struct S)"";
  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: C-style casts are discouraged; use static_cast [
  // CHECK-FIXES: auto s2a = static_cast<struct S>("");
  auto s2b = (const S)"";
  // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: C-style casts are discouraged; use static_cast [
  // FIXME: This should be constructor call syntax: S("").
  // CHECK-FIXES: auto s2b = static_cast<const S>("");
  ConvertibleToS c;
  auto s3 = (const S&)c;
  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: C-style casts are discouraged; use static_cast/const_cast/reinterpret_cast [
  // CHECK-FIXES: auto s3 = (const S&)c;
  // FIXME: This should be a static_cast.
  // C HECK-FIXES: auto s3 = static_cast<const S&>(c);
  auto s4 = (S)c;
  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: C-style casts are discouraged; use constructor call syntax [
  // CHECK-FIXES: auto s4 = S(c);
  ConvertibleToSRef cr;
  auto s5 = (const S&)cr;
  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: C-style casts are discouraged; use static_cast/const_cast/reinterpret_cast [
  // CHECK-FIXES: auto s5 = (const S&)cr;
  // FIXME: This should be a static_cast.
  // C HECK-FIXES: auto s5 = static_cast<const S&>(cr);
  auto s6 = (S)cr;
  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: C-style casts are discouraged; use constructor call syntax [
  // CHECK-FIXES: auto s6 = S(cr);
}

template <class T>
T functional_cast_template_used_by_class(float i) {
  return T(i);
}

template <class T>
T functional_cast_template_used_by_int(float i) {
  return T(i);
  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: C-style casts are discouraged; use static_cast
  // CHECK-FIXES: return static_cast<T>(i);
}

struct S2 {
  S2(float);
};
using T = S2;
using U = S2 &;

void functional_casts() {
  float x = 1.5F;
  auto y = int(x);
  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: C-style casts are discouraged; use static_cast
  // CHECK-FIXES: auto y = static_cast<int>(x);

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wc++11-narrowing"
  // This if fine, compiler will warn about implicit conversions with brace initialization
  auto z = int{x};
#pragma clang diagnostic pop

  // Functional casts are allowed if S is of class type
  const char *str = "foo";
  auto s = S(str);

  // Functional casts in template functions
  functional_cast_template_used_by_class<S2>(x);
  functional_cast_template_used_by_int<int>(x);

  // New expressions are not functional casts
  auto w = new int(x);

  // Typedefs
  S2 t = T(x); // OK, constructor call
  S2 u = U(x); // NOK, it's a reinterpret_cast in disguise
  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: C-style casts are discouraged; use static_cast/const_cast/reinterpret_cast
}