forked from OSchip/llvm-project
370 lines
14 KiB
C++
370 lines
14 KiB
C++
// 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
|
|
}
|