1 // RUN: %clang_cc1 -fsyntax-only -verify %s
2 // REQUIRES: LP64
3
4 // ------------ not interpreted as C-style cast ------------
5
6 struct SimpleValueInit {
7 int i;
8 };
9
10 struct InitViaConstructor {
11 InitViaConstructor(int i = 7);
12 };
13
14 struct NoValueInit { // expected-note 2 {{candidate constructor (the implicit copy constructor)}}
15 NoValueInit(int i, int j); // expected-note 2 {{candidate constructor}}
16 };
17
test_cxx_functional_value_init()18 void test_cxx_functional_value_init() {
19 (void)SimpleValueInit();
20 (void)InitViaConstructor();
21 (void)NoValueInit(); // expected-error{{no matching constructor for initialization}}
22 }
23
test_cxx_function_cast_multi()24 void test_cxx_function_cast_multi() {
25 (void)NoValueInit(0, 0);
26 (void)NoValueInit(0, 0, 0); // expected-error{{no matching constructor for initialization}}
27 (void)int(1, 2); // expected-error{{excess elements in scalar initializer}}
28 }
29
30
31 // ------------------ everything else --------------------
32
33 struct A {};
34
35 // ----------- const_cast --------------
36
37 typedef char c;
38 typedef c *cp;
39 typedef cp *cpp;
40 typedef cpp *cppp;
41 typedef cppp &cpppr;
42 typedef const cppp &cpppcr;
43 typedef const char cc;
44 typedef cc *ccp;
45 typedef volatile ccp ccvp;
46 typedef ccvp *ccvpp;
47 typedef const volatile ccvpp ccvpcvp;
48 typedef ccvpcvp *ccvpcvpp;
49 typedef int iar[100];
50 typedef iar &iarr;
51 typedef int (*f)(int);
52
t_cc()53 void t_cc()
54 {
55 ccvpcvpp var = 0;
56 // Cast away deep consts and volatiles.
57 char ***var2 = cppp(var);
58 char ***const &var3 = var2;
59 // Const reference to reference.
60 char ***&var4 = cpppr(var3);
61 // Drop reference. Intentionally without qualifier change.
62 char *** var5 = cppp(var4);
63 const int ar[100] = {0};
64 // Array decay. Intentionally without qualifier change.
65 typedef int *intp;
66 int *pi = intp(ar);
67 f fp = 0;
68 // Don't misidentify fn** as a function pointer.
69 typedef f *fp_t;
70 f *fpp = fp_t(&fp);
71 int const A::* const A::*icapcap = 0;
72 typedef int A::* A::*iapap_t;
73 iapap_t iapap = iapap_t(icapcap);
74 }
75
76 // ----------- static_cast -------------
77
78 struct B : public A {}; // Single public base.
79 struct C1 : public virtual B {}; // Single virtual base.
80 struct C2 : public virtual B {};
81 struct D : public C1, public C2 {}; // Diamond
82 struct E : private A {}; // Single private base.
83 struct F : public C1 {}; // Single path to B with virtual.
84 struct G1 : public B {};
85 struct G2 : public B {};
86 struct H : public G1, public G2 {}; // Ambiguous path to B.
87
88 enum Enum { En1, En2 };
89 enum Onom { On1, On2 };
90
91 struct Co1 { operator int(); };
92 struct Co2 { Co2(int); };
93 struct Co3 { };
94 struct Co4 { Co4(Co3); operator Co3(); };
95
96 // Explicit implicits
t_529_2()97 void t_529_2()
98 {
99 int i = 1;
100 (void)float(i);
101 double d = 1.0;
102 (void)float(d);
103 (void)int(d);
104 (void)char(i);
105 typedef unsigned long ulong;
106 (void)ulong(i);
107 (void)int(En1);
108 (void)double(En1);
109 typedef int &intr;
110 (void)intr(i);
111 typedef const int &cintr;
112 (void)cintr(i);
113
114 int ar[1];
115 typedef const int *cintp;
116 (void)cintp(ar);
117 typedef void (*pfvv)();
118 (void)pfvv(t_529_2);
119
120 typedef void *voidp;
121 (void)voidp(0);
122 (void)voidp((int*)0);
123 typedef volatile const void *vcvoidp;
124 (void)vcvoidp((const int*)0);
125 typedef A *Ap;
126 (void)Ap((B*)0);
127 typedef A &Ar;
128 (void)Ar(*((B*)0));
129 typedef const B *cBp;
130 (void)cBp((C1*)0);
131 typedef B &Br;
132 (void)Br(*((C1*)0));
133 (void)Ap((D*)0);
134 typedef const A &cAr;
135 (void)cAr(*((D*)0));
136 typedef int B::*Bmp;
137 (void)Bmp((int A::*)0);
138 typedef void (B::*Bmfp)();
139 (void)Bmfp((void (A::*)())0);
140 (void)Ap((E*)0); // functional-style cast ignores access control
141 (void)voidp((const int*)0); // const_cast appended
142
143 (void)int(Co1());
144 (void)Co2(1);
145 (void)Co3((Co4)(Co3()));
146
147 // Bad code below
148 //(void)(A*)((H*)0); // {{static_cast from 'struct H *' to 'struct A *' is not allowed}}
149 }
150
151 // Anything to void
t_529_4()152 void t_529_4()
153 {
154 void(1);
155 (void(t_529_4));
156 }
157
158 // Static downcasts
t_529_5_8()159 void t_529_5_8()
160 {
161 typedef B *Bp;
162 (void)Bp((A*)0);
163 typedef B &Br;
164 (void)Br(*((A*)0));
165 typedef const G1 *cG1p;
166 (void)cG1p((A*)0);
167 typedef const G1 &cG1r;
168 (void)cG1r(*((A*)0));
169 (void)Bp((const A*)0); // const_cast appended
170 (void)Br(*((const A*)0)); // const_cast appended
171 typedef E *Ep;
172 (void)Ep((A*)0); // access control ignored
173 typedef E &Er;
174 (void)Er(*((A*)0)); // access control ignored
175
176 // Bad code below
177
178 typedef C1 *C1p;
179 (void)C1p((A*)0); // expected-error {{cannot cast 'A *' to 'C1p' (aka 'C1 *') via virtual base 'B'}}
180 typedef C1 &C1r;
181 (void)C1r(*((A*)0)); // expected-error {{cannot cast 'A' to 'C1r' (aka 'C1 &') via virtual base 'B'}}
182 typedef D *Dp;
183 (void)Dp((A*)0); // expected-error {{cannot cast 'A *' to 'Dp' (aka 'D *') via virtual base 'B'}}
184 typedef D &Dr;
185 (void)Dr(*((A*)0)); // expected-error {{cannot cast 'A' to 'Dr' (aka 'D &') via virtual base 'B'}}
186 typedef H *Hp;
187 (void)Hp((A*)0); // expected-error {{ambiguous cast from base 'A' to derived 'H':\n struct A -> struct B -> struct G1 -> struct H\n struct A -> struct B -> struct G2 -> struct H}}
188 typedef H &Hr;
189 (void)Hr(*((A*)0)); // expected-error {{ambiguous cast from base 'A' to derived 'H':\n struct A -> struct B -> struct G1 -> struct H\n struct A -> struct B -> struct G2 -> struct H}}
190
191 // TODO: Test DR427. This requires user-defined conversions, though.
192 }
193
194 // Enum conversions
t_529_7()195 void t_529_7()
196 {
197 (void)Enum(1);
198 (void)Enum(1.0);
199 (void)Onom(En1);
200
201 // Bad code below
202
203 (void)Enum((int*)0); // expected-error {{functional-style cast from 'int *' to 'Enum' is not allowed}}
204 }
205
206 // Void pointer to object pointer
t_529_10()207 void t_529_10()
208 {
209 typedef int *intp;
210 (void)intp((void*)0);
211 typedef const A *cAp;
212 (void)cAp((void*)0);
213 (void)intp((const void*)0); // const_cast appended
214 }
215
216 // Member pointer upcast.
t_529_9()217 void t_529_9()
218 {
219 typedef int A::*Amp;
220 (void)Amp((int B::*)0);
221
222 // Bad code below
223 (void)Amp((int H::*)0); // expected-error {{ambiguous conversion from pointer to member of derived class 'H' to pointer to member of base class 'A':}}
224 (void)Amp((int F::*)0); // expected-error {{conversion from pointer to member of class 'F' to pointer to member of class 'A' via virtual base 'B' is not allowed}}
225 }
226
227 // -------- reinterpret_cast -----------
228
229 enum test { testval = 1 };
230 struct structure { int m; };
231 typedef void (*fnptr)();
232
233 // Test conversion between pointer and integral types, as in p3 and p4.
integral_conversion()234 void integral_conversion()
235 {
236 typedef void *voidp;
237 void *vp = voidp(testval);
238 long l = long(vp);
239 typedef float *floatp;
240 (void)floatp(l);
241 fnptr fnp = fnptr(l);
242 (void)char(fnp); // expected-error {{cast from pointer to smaller type 'char' loses information}}
243 (void)long(fnp);
244 }
245
pointer_conversion()246 void pointer_conversion()
247 {
248 int *p1 = 0;
249 typedef float *floatp;
250 float *p2 = floatp(p1);
251 typedef structure *structurep;
252 structure *p3 = structurep(p2);
253 typedef int **ppint;
254 typedef ppint *pppint;
255 ppint *deep = pppint(p3);
256 typedef fnptr fnptrp;
257 (void)fnptrp(deep);
258 }
259
constness()260 void constness()
261 {
262 int ***const ipppc = 0;
263 typedef int const *icp_t;
264 int const *icp = icp_t(ipppc);
265 typedef int *intp;
266 (void)intp(icp); // const_cast appended
267 typedef int const *const ** intcpcpp;
268 intcpcpp icpcpp = intcpcpp(ipppc); // const_cast appended
269 int *ip = intp(icpcpp);
270 (void)icp_t(ip);
271 typedef int const *const *const *intcpcpcp;
272 (void)intcpcpcp(ipppc);
273 }
274
fnptrs()275 void fnptrs()
276 {
277 typedef int (*fnptr2)(int);
278 fnptr fp = 0;
279 (void)fnptr2(fp);
280 typedef void *voidp;
281 void *vp = voidp(fp);
282 (void)fnptr(vp);
283 }
284
refs()285 void refs()
286 {
287 long l = 0;
288 typedef char &charr;
289 char &c = charr(l);
290 // Bad: from rvalue
291 typedef int &intr;
292 (void)intr(&c); // expected-error {{functional-style cast from rvalue to reference type 'intr' (aka 'int &')}}
293 }
294
memptrs()295 void memptrs()
296 {
297 const int structure::*psi = 0;
298 typedef const float structure::*structurecfmp;
299 (void)structurecfmp(psi);
300 typedef int structure::*structureimp;
301 (void)structureimp(psi); // const_cast appended
302
303 void (structure::*psf)() = 0;
304 typedef int (structure::*structureimfp)();
305 (void)structureimfp(psf);
306
307 typedef void (structure::*structurevmfp)();
308 (void)structurevmfp(psi); // expected-error-re {{functional-style cast from 'const int structure::*' to 'structurevmfp' (aka 'void (structure::*)(){{( __attribute__\(\(thiscall\)\))?}}') is not allowed}}
309 (void)structureimp(psf); // expected-error-re {{functional-style cast from 'void (structure::*)(){{( __attribute__\(\(thiscall\)\))?}}' to 'structureimp' (aka 'int structure::*') is not allowed}}
310 }
311
312 // ---------------- misc ------------------
313
crash_on_invalid_1()314 void crash_on_invalid_1()
315 {
316 typedef itn Typo; // expected-error {{unknown type name 'itn'}}
317 (void)Typo(1); // used to crash
318
319 typedef int &int_ref;
320 (void)int_ref(); // expected-error {{reference to type 'int' requires an initializer}}
321 }
322