1// RUN: %clang_cc1 -fsyntax-only -verify %s
2// REQUIRES: LP64
3
4// ------------ not interpreted as C-style cast ------------
5
6struct SimpleValueInit {
7  int i;
8};
9
10struct InitViaConstructor {
11  InitViaConstructor(int i = 7);
12};
13
14struct NoValueInit { // expected-note 2 {{candidate constructor (the implicit copy constructor)}}
15  NoValueInit(int i, int j); // expected-note 2 {{candidate constructor}}
16};
17
18void test_cxx_functional_value_init() {
19  (void)SimpleValueInit();
20  (void)InitViaConstructor();
21  (void)NoValueInit(); // expected-error{{no matching constructor for initialization}}
22}
23
24void 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
33struct A {};
34
35// ----------- const_cast --------------
36
37typedef char c;
38typedef c *cp;
39typedef cp *cpp;
40typedef cpp *cppp;
41typedef cppp &cpppr;
42typedef const cppp &cpppcr;
43typedef const char cc;
44typedef cc *ccp;
45typedef volatile ccp ccvp;
46typedef ccvp *ccvpp;
47typedef const volatile ccvpp ccvpcvp;
48typedef ccvpcvp *ccvpcvpp;
49typedef int iar[100];
50typedef iar &iarr;
51typedef int (*f)(int);
52
53void 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
78struct B : public A {};             // Single public base.
79struct C1 : public virtual B {};    // Single virtual base.
80struct C2 : public virtual B {};
81struct D : public C1, public C2 {}; // Diamond
82struct E : private A {};            // Single private base.
83struct F : public C1 {};            // Single path to B with virtual.
84struct G1 : public B {};
85struct G2 : public B {};
86struct H : public G1, public G2 {}; // Ambiguous path to B.
87
88enum Enum { En1, En2 };
89enum Onom { On1, On2 };
90
91struct Co1 { operator int(); };
92struct Co2 { Co2(int); };
93struct Co3 { };
94struct Co4 { Co4(Co3); operator Co3(); };
95
96// Explicit implicits
97void 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
152void t_529_4()
153{
154  void(1);
155  (void(t_529_4));
156}
157
158// Static downcasts
159void 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
195void 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
207void 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.
217void 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
229enum test { testval = 1 };
230struct structure { int m; };
231typedef void (*fnptr)();
232
233// Test conversion between pointer and integral types, as in p3 and p4.
234void 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
246void 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
260void 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
275void 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
285void 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
295void 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
314void 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