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