1 // RUN: %check_clang_tidy -std=c++11-or-later %s google-readability-casting %t
2 // FIXME: Fix the checker to work in C++17 mode.
3 
g()4 bool g() { return false; }
5 
6 enum Enum { Enum1 };
7 struct X {};
8 struct Y : public X {};
9 
f(int a,double b,const char * cpc,const void * cpv,X * pX)10 void f(int a, double b, const char *cpc, const void *cpv, X *pX) {
11   const char *cpc2 = (const char*)cpc;
12   // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: redundant cast to the same type [google-readability-casting]
13   // CHECK-FIXES: const char *cpc2 = cpc;
14 
15   typedef const char *Typedef1;
16   typedef const char *Typedef2;
17   Typedef1 t1;
18   (Typedef2)t1;
19   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: C-style casts are discouraged; use static_cast (if needed, the cast may be redundant) [google-readability-casting]
20   // CHECK-FIXES: {{^}}  static_cast<Typedef2>(t1);
21   (const char*)t1;
22   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: {{.*}}; use static_cast (if needed
23   // CHECK-FIXES: {{^}}  static_cast<const char*>(t1);
24   (Typedef1)cpc;
25   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: {{.*}}; use static_cast (if needed
26   // CHECK-FIXES: {{^}}  static_cast<Typedef1>(cpc);
27   (Typedef1)t1;
28   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: redundant cast to the same type
29   // CHECK-FIXES: {{^}}  t1;
30 
31   char *pc = (char*)cpc;
32   // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: C-style casts are discouraged; use const_cast [google-readability-casting]
33   // CHECK-FIXES: char *pc = const_cast<char*>(cpc);
34   typedef char Char;
35   Char *pChar = (Char*)pc;
36   // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: {{.*}}; use static_cast (if needed
37   // CHECK-FIXES: {{^}}  Char *pChar = static_cast<Char*>(pc);
38 
39   (Char)*cpc;
40   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: {{.*}}; use static_cast (if needed
41   // CHECK-FIXES: {{^}}  static_cast<Char>(*cpc);
42 
43   (char)*pChar;
44   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: {{.*}}; use static_cast (if needed
45   // CHECK-FIXES: {{^}}  static_cast<char>(*pChar);
46 
47   (const char*)cpv;
48   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: {{.*}}; use static_cast [
49   // CHECK-FIXES: static_cast<const char*>(cpv);
50 
51   char *pc2 = (char*)(cpc + 33);
52   // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: {{.*}}; use const_cast [
53   // CHECK-FIXES: char *pc2 = const_cast<char*>(cpc + 33);
54 
55   const char &crc = *cpc;
56   char &rc = (char&)crc;
57   // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: {{.*}}; use const_cast [
58   // CHECK-FIXES: char &rc = const_cast<char&>(crc);
59 
60   char &rc2 = (char&)*cpc;
61   // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: {{.*}}; use const_cast [
62   // CHECK-FIXES: char &rc2 = const_cast<char&>(*cpc);
63 
64   char ** const* const* ppcpcpc;
65   char ****ppppc = (char****)ppcpcpc;
66   // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: {{.*}}; use const_cast [
67   // CHECK-FIXES: char ****ppppc = const_cast<char****>(ppcpcpc);
68 
69   char ***pppc = (char***)*(ppcpcpc);
70   // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: {{.*}}; use const_cast [
71   // CHECK-FIXES: char ***pppc = const_cast<char***>(*(ppcpcpc));
72 
73   char ***pppc2 = (char***)(*ppcpcpc);
74   // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: {{.*}}; use const_cast [
75   // CHECK-FIXES: char ***pppc2 = const_cast<char***>(*ppcpcpc);
76 
77   char *pc5 = (char*)(const char*)(cpv);
78   // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: {{.*}}; use const_cast [
79   // CHECK-MESSAGES: :[[@LINE-2]]:22: warning: {{.*}}; use static_cast [
80   // CHECK-FIXES: char *pc5 = const_cast<char*>(static_cast<const char*>(cpv));
81 
82   int b1 = (int)b;
83   // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: {{.*}}; use static_cast [
84   // CHECK-FIXES: int b1 = static_cast<int>(b);
85   b1 = (const int&)b;
86   // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: {{.*}}; use static_cast/const_cast/reinterpret_cast [
87   // CHECK-FIXES: b1 = (const int&)b;
88 
89   b1 = (int) b;
90   // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: {{.*}}; use static_cast {{.*}}
91   // CHECK-FIXES: b1 = static_cast<int>(b);
92 
93   b1 = (int)         b;
94   // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: {{.*}}; use static_cast {{.*}}
95   // CHECK-FIXES: b1 = static_cast<int>(b);
96 
97   b1 = (int) (b);
98   // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: {{.*}}; use static_cast {{.*}}
99   // CHECK-FIXES: b1 = static_cast<int>(b);
100 
101   b1 = (int)         (b);
102   // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: {{.*}}; use static_cast {{.*}}
103   // CHECK-FIXES: b1 = static_cast<int>(b);
104 
105   Y *pB = (Y*)pX;
106   // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: {{.*}}; use static_cast/const_cast/reinterpret_cast [
107   Y &rB = (Y&)*pX;
108   // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: {{.*}}; use static_cast/const_cast/reinterpret_cast [
109 
110   const char *pc3 = (const char*)cpv;
111   // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: {{.*}}; use static_cast [
112   // CHECK-FIXES: const char *pc3 = static_cast<const char*>(cpv);
113 
114   char *pc4 = (char*)cpv;
115   // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: {{.*}}; use static_cast/const_cast/reinterpret_cast [
116   // CHECK-FIXES: char *pc4 = (char*)cpv;
117 
118   b1 = (int)Enum1;
119   // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: {{.*}}; use static_cast [
120   // CHECK-FIXES: b1 = static_cast<int>(Enum1);
121 
122   Enum e = (Enum)b1;
123   // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: {{.*}}; use static_cast [
124   // CHECK-FIXES: Enum e = static_cast<Enum>(b1);
125 
126   e = (Enum)Enum1;
127   // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: redundant cast to the same type
128   // CHECK-FIXES: {{^}}  e = Enum1;
129 
130   e = (Enum)e;
131   // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: redundant cast to the same type
132   // CHECK-FIXES: {{^}}  e = e;
133 
134   e = (Enum)           e;
135   // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: redundant cast to the same type
136   // CHECK-FIXES: {{^}}  e = e;
137 
138   e = (Enum)           (e);
139   // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: redundant cast to the same type
140   // CHECK-FIXES: {{^}}  e = (e);
141 
142   static const int kZero = 0;
143   (int)kZero;
144   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: redundant cast to the same type
145   // CHECK-FIXES: {{^}}  kZero;
146 
147   int b2 = int(b);
148   int b3 = static_cast<double>(b);
149   int b4 = b;
150   double aa = a;
151   (void)b2;
152   return (void)g();
153 }
154 
155 template <typename T>
template_function(T t,int n)156 void template_function(T t, int n) {
157   int i = (int)t;
158   // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: {{.*}}; use static_cast/const_cast/reinterpret_cast [
159   // CHECK-FIXES: int i = (int)t;
160   int j = (int)n;
161   // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant cast to the same type
162   // CHECK-FIXES: int j = n;
163 }
164 
165 template <typename T>
166 struct TemplateStruct {
fTemplateStruct167   void f(T t, int n) {
168     int k = (int)t;
169     // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: {{.*}}; use static_cast/const_cast/reinterpret_cast
170     // CHECK-FIXES: int k = (int)t;
171     int l = (int)n;
172     // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: redundant cast to the same type
173     // CHECK-FIXES: int l = n;
174   }
175 };
176 
test_templates()177 void test_templates() {
178   template_function(1, 42);
179   template_function(1.0, 42);
180   TemplateStruct<int>().f(1, 42);
181   TemplateStruct<double>().f(1.0, 42);
182 }
183 
184 extern "C" {
extern_c_code(const char * cpc)185 void extern_c_code(const char *cpc) {
186   const char *cpc2 = (const char*)cpc;
187   // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: redundant cast to the same type
188   // CHECK-FIXES: const char *cpc2 = cpc;
189   char *pc = (char*)cpc;
190 }
191 }
192 
193 #define CAST(type, value) (type)(value)
macros(double d)194 void macros(double d) {
195   int i = CAST(int, d);
196 }
197 
198 enum E { E1 = 1 };
199 template <E e>
200 struct A {
201   // Usage of template argument e = E1 is represented as (E)1 in the AST for
202   // some reason. We have a special treatment of this case to avoid warnings
203   // here.
204   static const E ee = e;
205 };
206 struct B : public A<E1> {};
207 
208 
209 void overloaded_function();
210 void overloaded_function(int);
211 
212 template<typename Fn>
g(Fn fn)213 void g(Fn fn) {
214   fn();
215 }
216 
function_casts()217 void function_casts() {
218   typedef void (*FnPtrVoid)();
219   typedef void (&FnRefVoid)();
220   typedef void (&FnRefInt)(int);
221 
222   g((void (*)())overloaded_function);
223   // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: C-style casts are discouraged; use static_cast [
224   // CHECK-FIXES: g(static_cast<void (*)()>(overloaded_function));
225   g((void (*)())&overloaded_function);
226   // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: C-style casts are discouraged; use static_cast [
227   // CHECK-FIXES: g(static_cast<void (*)()>(&overloaded_function));
228   g((void (&)())overloaded_function);
229   // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: C-style casts are discouraged; use static_cast [
230   // CHECK-FIXES: g(static_cast<void (&)()>(overloaded_function));
231 
232   g((FnPtrVoid)overloaded_function);
233   // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: C-style casts are discouraged; use static_cast [
234   // CHECK-FIXES: g(static_cast<FnPtrVoid>(overloaded_function));
235   g((FnPtrVoid)&overloaded_function);
236   // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: C-style casts are discouraged; use static_cast [
237   // CHECK-FIXES: g(static_cast<FnPtrVoid>(&overloaded_function));
238   g((FnRefVoid)overloaded_function);
239   // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: C-style casts are discouraged; use static_cast [
240   // CHECK-FIXES: g(static_cast<FnRefVoid>(overloaded_function));
241 
242   FnPtrVoid fn0 = (void (*)())&overloaded_function;
243   // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: C-style casts are discouraged; use static_cast [
244   // CHECK-FIXES: FnPtrVoid fn0 = static_cast<void (*)()>(&overloaded_function);
245   FnPtrVoid fn1 = (void (*)())overloaded_function;
246   // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: C-style casts are discouraged; use static_cast [
247   // CHECK-FIXES: FnPtrVoid fn1 = static_cast<void (*)()>(overloaded_function);
248   FnPtrVoid fn1a = (FnPtrVoid)overloaded_function;
249   // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: C-style casts are discouraged; use static_cast [
250   // CHECK-FIXES: FnPtrVoid fn1a = static_cast<FnPtrVoid>(overloaded_function);
251   FnRefInt fn2 = (void (&)(int))overloaded_function;
252   // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: C-style casts are discouraged; use static_cast [
253   // CHECK-FIXES: FnRefInt fn2 = static_cast<void (&)(int)>(overloaded_function);
254   auto fn3 = (void (*)())&overloaded_function;
255   // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: C-style casts are discouraged; use static_cast [
256   // CHECK-FIXES: auto fn3 = static_cast<void (*)()>(&overloaded_function);
257   auto fn4 = (void (*)())overloaded_function;
258   // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: C-style casts are discouraged; use static_cast [
259   // CHECK-FIXES: auto fn4 = static_cast<void (*)()>(overloaded_function);
260   auto fn5 = (void (&)(int))overloaded_function;
261   // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: C-style casts are discouraged; use static_cast [
262   // CHECK-FIXES: auto fn5 = static_cast<void (&)(int)>(overloaded_function);
263 
264   void (*fn6)() = (void (*)())&overloaded_function;
265   // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: C-style casts are discouraged; use static_cast [
266   // CHECK-FIXES: void (*fn6)() = static_cast<void (*)()>(&overloaded_function);
267   void (*fn7)() = (void (*)())overloaded_function;
268   // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: C-style casts are discouraged; use static_cast [
269   // CHECK-FIXES: void (*fn7)() = static_cast<void (*)()>(overloaded_function);
270   void (*fn8)() = (FnPtrVoid)overloaded_function;
271   // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: C-style casts are discouraged; use static_cast [
272   // CHECK-FIXES: void (*fn8)() = static_cast<FnPtrVoid>(overloaded_function);
273   void (&fn9)(int) = (void (&)(int))overloaded_function;
274   // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: C-style casts are discouraged; use static_cast [
275   // CHECK-FIXES: void (&fn9)(int) = static_cast<void (&)(int)>(overloaded_function);
276 
277   void (*correct1)() = static_cast<void (*)()>(overloaded_function);
278   FnPtrVoid correct2 = static_cast<void (*)()>(&overloaded_function);
279   FnRefInt correct3 = static_cast<void (&)(int)>(overloaded_function);
280 }
281 
282 struct S {
283     S(const char *);
284 };
285 struct ConvertibleToS {
286   operator S() const;
287 };
288 struct ConvertibleToSRef {
289   operator const S&() const;
290 };
291 
conversions()292 void conversions() {
293   //auto s1 = (const S&)"";
294   // C HECK-MESSAGES: :[[@LINE-1]]:10: warning: C-style casts are discouraged; use static_cast [
295   // C HECK-FIXES: S s1 = static_cast<const S&>("");
296   auto s2 = (S)"";
297   // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: C-style casts are discouraged; use constructor call syntax [
298   // CHECK-FIXES: auto s2 = S("");
299   auto s2a = (struct S)"";
300   // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: C-style casts are discouraged; use static_cast [
301   // CHECK-FIXES: auto s2a = static_cast<struct S>("");
302   auto s2b = (const S)"";
303   // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: C-style casts are discouraged; use static_cast [
304   // FIXME: This should be constructor call syntax: S("").
305   // CHECK-FIXES: auto s2b = static_cast<const S>("");
306   ConvertibleToS c;
307   auto s3 = (const S&)c;
308   // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: C-style casts are discouraged; use static_cast/const_cast/reinterpret_cast [
309   // CHECK-FIXES: auto s3 = (const S&)c;
310   // FIXME: This should be a static_cast.
311   // C HECK-FIXES: auto s3 = static_cast<const S&>(c);
312   auto s4 = (S)c;
313   // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: C-style casts are discouraged; use constructor call syntax [
314   // CHECK-FIXES: auto s4 = S(c);
315   ConvertibleToSRef cr;
316   auto s5 = (const S&)cr;
317   // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: C-style casts are discouraged; use static_cast/const_cast/reinterpret_cast [
318   // CHECK-FIXES: auto s5 = (const S&)cr;
319   // FIXME: This should be a static_cast.
320   // C HECK-FIXES: auto s5 = static_cast<const S&>(cr);
321   auto s6 = (S)cr;
322   // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: C-style casts are discouraged; use constructor call syntax [
323   // CHECK-FIXES: auto s6 = S(cr);
324 }
325