type-traits.cpp revision 08295a592d7e54e6bea00daeb2abe7ac79a3aaba 
1// RUN: %clang_cc1 -fsyntax-only -verify %s
2#define T(b) (b) ? 1 : -1
3#define F(b) (b) ? -1 : 1
4
5struct NonPOD { NonPOD(int); };
6
7// PODs
8enum Enum { EV };
9struct POD { Enum e; int i; float f; NonPOD* p; };
10struct Empty {};
11typedef Empty EmptyAr[10];
12typedef int Int;
13typedef Int IntAr[10];
14typedef Int IntArNB[];
15class Statics { static int priv; static NonPOD np; };
16union EmptyUnion {};
17union Union { int i; float f; };
18struct HasFunc { void f (); };
19struct HasOp { void operator *(); };
20struct HasConv { operator int(); };
21struct HasAssign { void operator =(int); };
22
23// Not PODs
24typedef const void cvoid;
25struct Derives : POD {};
26struct DerivesEmpty : Empty {};
27struct HasCons { HasCons(int); };
28struct HasCopyAssign { HasCopyAssign operator =(const HasCopyAssign&); };
29struct HasDest { ~HasDest(); };
30class  HasPriv { int priv; };
31class  HasProt { protected: int prot; };
32struct HasRef { int i; int& ref; HasRef() : i(0), ref(i) {} };
33struct HasNonPOD { NonPOD np; };
34struct HasVirt { virtual void Virt() {}; };
35typedef Derives NonPODAr[10];
36typedef HasVirt VirtAr[10];
37typedef HasCons NonPODArNB[];
38union NonPODUnion { int i; Derives n; };
39
40struct HasNoThrowCopyAssign {
41  void operator =(const HasNoThrowCopyAssign&) throw();
42};
43struct HasMultipleCopyAssign {
44  void operator =(const HasMultipleCopyAssign&) throw();
45  void operator =(volatile HasMultipleCopyAssign&);
46};
47struct HasMultipleNoThrowCopyAssign {
48  void operator =(const HasMultipleNoThrowCopyAssign&) throw();
49  void operator =(volatile HasMultipleNoThrowCopyAssign&) throw();
50};
51
52struct HasNoThrowConstructor { HasNoThrowConstructor() throw(); };
53struct HasNoThrowConstructorWithArgs {
54  HasNoThrowConstructorWithArgs(HasCons i = HasCons(0)) throw();
55};
56
57struct HasNoThrowCopy { HasNoThrowCopy(const HasNoThrowCopy&) throw(); };
58struct HasMultipleCopy {
59  HasMultipleCopy(const HasMultipleCopy&) throw();
60  HasMultipleCopy(volatile HasMultipleCopy&);
61};
62struct HasMultipleNoThrowCopy {
63  HasMultipleNoThrowCopy(const HasMultipleNoThrowCopy&) throw();
64  HasMultipleNoThrowCopy(volatile HasMultipleNoThrowCopy&) throw();
65};
66
67struct HasVirtDest { virtual ~HasVirtDest(); };
68struct DerivedVirtDest : HasVirtDest {};
69typedef HasVirtDest VirtDestAr[1];
70
71void is_pod()
72{
73  int t01[T(__is_pod(int))];
74  int t02[T(__is_pod(Enum))];
75  int t03[T(__is_pod(POD))];
76  int t04[T(__is_pod(Int))];
77  int t05[T(__is_pod(IntAr))];
78  int t06[T(__is_pod(Statics))];
79  int t07[T(__is_pod(Empty))];
80  int t08[T(__is_pod(EmptyUnion))];
81  int t09[T(__is_pod(Union))];
82  int t10[T(__is_pod(HasFunc))];
83  int t11[T(__is_pod(HasOp))];
84  int t12[T(__is_pod(HasConv))];
85  int t13[T(__is_pod(HasAssign))];
86  int t14[T(__is_pod(IntArNB))];
87
88  int t21[F(__is_pod(Derives))];
89  int t22[F(__is_pod(HasCons))];
90  int t23[F(__is_pod(HasCopyAssign))];
91  int t24[F(__is_pod(HasDest))];
92  int t25[F(__is_pod(HasPriv))];
93  int t26[F(__is_pod(HasProt))];
94  int t27[F(__is_pod(HasRef))];
95  int t28[F(__is_pod(HasNonPOD))];
96  int t29[F(__is_pod(HasVirt))];
97  int t30[F(__is_pod(NonPODAr))];
98  int t31[F(__is_pod(DerivesEmpty))];
99  int t32[F(__is_pod(void))];
100  int t33[F(__is_pod(cvoid))];
101  int t34[F(__is_pod(NonPODArNB))];
102 // int t32[F(__is_pod(NonPODUnion))];
103}
104
105typedef Empty EmptyAr[10];
106struct Bit0 { int : 0; };
107struct Bit0Cons { int : 0; Bit0Cons(); };
108struct BitOnly { int x : 3; };
109//struct DerivesVirt : virtual POD {};
110
111void is_empty()
112{
113  int t01[T(__is_empty(Empty))];
114  int t02[T(__is_empty(DerivesEmpty))];
115  int t03[T(__is_empty(HasCons))];
116  int t04[T(__is_empty(HasCopyAssign))];
117  int t05[T(__is_empty(HasDest))];
118  int t06[T(__is_empty(HasFunc))];
119  int t07[T(__is_empty(HasOp))];
120  int t08[T(__is_empty(HasConv))];
121  int t09[T(__is_empty(HasAssign))];
122  int t10[T(__is_empty(Bit0))];
123  int t11[T(__is_empty(Bit0Cons))];
124
125  int t21[F(__is_empty(Int))];
126  int t22[F(__is_empty(POD))];
127  int t23[F(__is_empty(EmptyUnion))];
128  int t24[F(__is_empty(EmptyAr))];
129  int t25[F(__is_empty(HasRef))];
130  int t26[F(__is_empty(HasVirt))];
131  int t27[F(__is_empty(BitOnly))];
132  int t28[F(__is_empty(void))];
133  int t29[F(__is_empty(IntArNB))];
134//  int t27[F(__is_empty(DerivesVirt))];
135}
136
137typedef Derives ClassType;
138
139void is_class()
140{
141  int t01[T(__is_class(Derives))];
142  int t02[T(__is_class(HasPriv))];
143  int t03[T(__is_class(ClassType))];
144
145  int t11[F(__is_class(int))];
146  int t12[F(__is_class(Enum))];
147  int t13[F(__is_class(Int))];
148  int t14[F(__is_class(IntAr))];
149  int t15[F(__is_class(NonPODAr))];
150  int t16[F(__is_class(Union))];
151  int t17[F(__is_class(cvoid))];
152  int t18[F(__is_class(IntArNB))];
153}
154
155typedef Union UnionAr[10];
156typedef Union UnionType;
157
158void is_union()
159{
160  int t01[T(__is_union(Union))];
161  int t02[T(__is_union(UnionType))];
162
163  int t11[F(__is_union(int))];
164  int t12[F(__is_union(Enum))];
165  int t13[F(__is_union(Int))];
166  int t14[F(__is_union(IntAr))];
167  int t15[F(__is_union(UnionAr))];
168  int t16[F(__is_union(cvoid))];
169  int t17[F(__is_union(IntArNB))];
170}
171
172typedef Enum EnumType;
173
174void is_enum()
175{
176  int t01[T(__is_enum(Enum))];
177  int t02[T(__is_enum(EnumType))];
178
179  int t11[F(__is_enum(int))];
180  int t12[F(__is_enum(Union))];
181  int t13[F(__is_enum(Int))];
182  int t14[F(__is_enum(IntAr))];
183  int t15[F(__is_enum(UnionAr))];
184  int t16[F(__is_enum(Derives))];
185  int t17[F(__is_enum(ClassType))];
186  int t18[F(__is_enum(cvoid))];
187  int t19[F(__is_enum(IntArNB))];
188}
189
190typedef HasVirt Polymorph;
191struct InheritPolymorph : Polymorph {};
192
193void is_polymorphic()
194{
195  int t01[T(__is_polymorphic(Polymorph))];
196  int t02[T(__is_polymorphic(InheritPolymorph))];
197
198  int t11[F(__is_polymorphic(int))];
199  int t12[F(__is_polymorphic(Union))];
200  int t13[F(__is_polymorphic(Int))];
201  int t14[F(__is_polymorphic(IntAr))];
202  int t15[F(__is_polymorphic(UnionAr))];
203  int t16[F(__is_polymorphic(Derives))];
204  int t17[F(__is_polymorphic(ClassType))];
205  int t18[F(__is_polymorphic(Enum))];
206  int t19[F(__is_polymorphic(cvoid))];
207  int t20[F(__is_polymorphic(IntArNB))];
208}
209
210typedef Int& IntRef;
211typedef const IntAr ConstIntAr;
212typedef ConstIntAr ConstIntArAr[4];
213
214struct HasCopy {
215  HasCopy(HasCopy& cp);
216};
217
218struct HasTemplateCons {
219  HasVirt Annoying;
220
221  template <typename T>
222  HasTemplateCons(const T&);
223};
224
225void has_trivial_default_constructor() {
226  int t01[T(__has_trivial_constructor(Int))];
227  int t02[T(__has_trivial_constructor(IntAr))];
228  int t03[T(__has_trivial_constructor(Union))];
229  int t04[T(__has_trivial_constructor(UnionAr))];
230  int t05[T(__has_trivial_constructor(POD))];
231  int t06[T(__has_trivial_constructor(Derives))];
232  int t07[T(__has_trivial_constructor(ConstIntAr))];
233  int t08[T(__has_trivial_constructor(ConstIntArAr))];
234  int t09[T(__has_trivial_constructor(HasDest))];
235  int t10[T(__has_trivial_constructor(HasPriv))];
236  int t11[F(__has_trivial_constructor(HasCons))];
237  int t12[F(__has_trivial_constructor(HasRef))];
238  int t13[F(__has_trivial_constructor(HasCopy))];
239  int t14[F(__has_trivial_constructor(IntRef))];
240  int t15[T(__has_trivial_constructor(HasCopyAssign))];
241  int t16[T(__has_trivial_constructor(const Int))];
242  int t17[T(__has_trivial_constructor(NonPODAr))];
243  int t18[F(__has_trivial_constructor(VirtAr))];
244  int t19[F(__has_trivial_constructor(void))];
245  int t20[F(__has_trivial_constructor(cvoid))];
246  int t21[F(__has_trivial_constructor(HasTemplateCons))];
247}
248
249void has_trivial_copy_constructor() {
250  int t01[T(__has_trivial_copy(Int))];
251  int t02[T(__has_trivial_copy(IntAr))];
252  int t03[T(__has_trivial_copy(Union))];
253  int t04[T(__has_trivial_copy(UnionAr))];
254  int t05[T(__has_trivial_copy(POD))];
255  int t06[T(__has_trivial_copy(Derives))];
256  int t07[T(__has_trivial_copy(ConstIntAr))];
257  int t08[T(__has_trivial_copy(ConstIntArAr))];
258  int t09[T(__has_trivial_copy(HasDest))];
259  int t10[T(__has_trivial_copy(HasPriv))];
260  int t11[T(__has_trivial_copy(HasCons))];
261  int t12[T(__has_trivial_copy(HasRef))];
262  int t13[F(__has_trivial_copy(HasCopy))];
263  int t14[T(__has_trivial_copy(IntRef))];
264  int t15[T(__has_trivial_copy(HasCopyAssign))];
265  int t16[T(__has_trivial_copy(const Int))];
266  int t17[F(__has_trivial_copy(NonPODAr))];
267  int t18[F(__has_trivial_copy(VirtAr))];
268  int t19[F(__has_trivial_copy(void))];
269  int t20[F(__has_trivial_copy(cvoid))];
270  int t21[F(__has_trivial_copy(HasTemplateCons))];
271}
272
273void has_trivial_copy_assignment() {
274  int t01[T(__has_trivial_assign(Int))];
275  int t02[T(__has_trivial_assign(IntAr))];
276  int t03[T(__has_trivial_assign(Union))];
277  int t04[T(__has_trivial_assign(UnionAr))];
278  int t05[T(__has_trivial_assign(POD))];
279  int t06[T(__has_trivial_assign(Derives))];
280  int t07[F(__has_trivial_assign(ConstIntAr))];
281  int t08[F(__has_trivial_assign(ConstIntArAr))];
282  int t09[T(__has_trivial_assign(HasDest))];
283  int t10[T(__has_trivial_assign(HasPriv))];
284  int t11[T(__has_trivial_assign(HasCons))];
285  int t12[T(__has_trivial_assign(HasRef))];
286  int t13[T(__has_trivial_assign(HasCopy))];
287  int t14[F(__has_trivial_assign(IntRef))];
288  int t15[F(__has_trivial_assign(HasCopyAssign))];
289  int t16[F(__has_trivial_assign(const Int))];
290  int t17[F(__has_trivial_assign(NonPODAr))];
291  int t18[F(__has_trivial_assign(VirtAr))];
292  int t19[F(__has_trivial_assign(void))];
293  int t20[F(__has_trivial_assign(cvoid))];
294}
295
296void has_trivial_destructor() {
297  int t01[T(__has_trivial_destructor(Int))];
298  int t02[T(__has_trivial_destructor(IntAr))];
299  int t03[T(__has_trivial_destructor(Union))];
300  int t04[T(__has_trivial_destructor(UnionAr))];
301  int t05[T(__has_trivial_destructor(POD))];
302  int t06[T(__has_trivial_destructor(Derives))];
303  int t07[T(__has_trivial_destructor(ConstIntAr))];
304  int t08[T(__has_trivial_destructor(ConstIntArAr))];
305  int t09[F(__has_trivial_destructor(HasDest))];
306  int t10[T(__has_trivial_destructor(HasPriv))];
307  int t11[T(__has_trivial_destructor(HasCons))];
308  int t12[T(__has_trivial_destructor(HasRef))];
309  int t13[T(__has_trivial_destructor(HasCopy))];
310  int t14[T(__has_trivial_destructor(IntRef))];
311  int t15[T(__has_trivial_destructor(HasCopyAssign))];
312  int t16[T(__has_trivial_destructor(const Int))];
313  int t17[T(__has_trivial_destructor(NonPODAr))];
314  int t18[T(__has_trivial_destructor(VirtAr))];
315  int t19[F(__has_trivial_destructor(void))];
316  int t20[F(__has_trivial_destructor(cvoid))];
317}
318
319struct A { ~A() {} };
320template<typename> struct B : A { };
321
322void f() {
323  int t01[F(__has_trivial_destructor(A))];
324  int t02[F(__has_trivial_destructor(B<int>))];
325}
326
327void has_nothrow_assign() {
328  int t01[T(__has_nothrow_assign(Int))];
329  int t02[T(__has_nothrow_assign(IntAr))];
330  int t03[T(__has_nothrow_assign(Union))];
331  int t04[T(__has_nothrow_assign(UnionAr))];
332  int t05[T(__has_nothrow_assign(POD))];
333  int t06[T(__has_nothrow_assign(Derives))];
334  int t07[F(__has_nothrow_assign(ConstIntAr))];
335  int t08[F(__has_nothrow_assign(ConstIntArAr))];
336  int t09[T(__has_nothrow_assign(HasDest))];
337  int t10[T(__has_nothrow_assign(HasPriv))];
338  int t11[T(__has_nothrow_assign(HasCons))];
339  int t12[T(__has_nothrow_assign(HasRef))];
340  int t13[T(__has_nothrow_assign(HasCopy))];
341  int t14[F(__has_nothrow_assign(IntRef))];
342  int t15[F(__has_nothrow_assign(HasCopyAssign))];
343  int t16[F(__has_nothrow_assign(const Int))];
344  int t17[F(__has_nothrow_assign(NonPODAr))];
345  int t18[F(__has_nothrow_assign(VirtAr))];
346  int t19[T(__has_nothrow_assign(HasNoThrowCopyAssign))];
347  int t20[F(__has_nothrow_assign(HasMultipleCopyAssign))];
348  int t21[T(__has_nothrow_assign(HasMultipleNoThrowCopyAssign))];
349  int t22[F(__has_nothrow_assign(void))];
350  int t23[F(__has_nothrow_assign(cvoid))];
351}
352
353void has_nothrow_copy() {
354  int t01[T(__has_nothrow_copy(Int))];
355  int t02[T(__has_nothrow_copy(IntAr))];
356  int t03[T(__has_nothrow_copy(Union))];
357  int t04[T(__has_nothrow_copy(UnionAr))];
358  int t05[T(__has_nothrow_copy(POD))];
359  int t06[T(__has_nothrow_copy(Derives))];
360  int t07[T(__has_nothrow_copy(ConstIntAr))];
361  int t08[T(__has_nothrow_copy(ConstIntArAr))];
362  int t09[T(__has_nothrow_copy(HasDest))];
363  int t10[T(__has_nothrow_copy(HasPriv))];
364  int t11[T(__has_nothrow_copy(HasCons))];
365  int t12[T(__has_nothrow_copy(HasRef))];
366  int t13[F(__has_nothrow_copy(HasCopy))];
367  int t14[T(__has_nothrow_copy(IntRef))];
368  int t15[T(__has_nothrow_copy(HasCopyAssign))];
369  int t16[T(__has_nothrow_copy(const Int))];
370  int t17[F(__has_nothrow_copy(NonPODAr))];
371  int t18[F(__has_nothrow_copy(VirtAr))];
372
373  int t19[T(__has_nothrow_copy(HasNoThrowCopy))];
374  int t20[F(__has_nothrow_copy(HasMultipleCopy))];
375  int t21[T(__has_nothrow_copy(HasMultipleNoThrowCopy))];
376  int t22[F(__has_nothrow_copy(void))];
377  int t23[F(__has_nothrow_copy(cvoid))];
378  int t24[T(__has_nothrow_copy(HasVirtDest))];
379  int t25[T(__has_nothrow_copy(HasTemplateCons))];
380}
381
382void has_nothrow_constructor() {
383  int t01[T(__has_nothrow_constructor(Int))];
384  int t02[T(__has_nothrow_constructor(IntAr))];
385  int t03[T(__has_nothrow_constructor(Union))];
386  int t04[T(__has_nothrow_constructor(UnionAr))];
387  int t05[T(__has_nothrow_constructor(POD))];
388  int t06[T(__has_nothrow_constructor(Derives))];
389  int t07[T(__has_nothrow_constructor(ConstIntAr))];
390  int t08[T(__has_nothrow_constructor(ConstIntArAr))];
391  int t09[T(__has_nothrow_constructor(HasDest))];
392  int t10[T(__has_nothrow_constructor(HasPriv))];
393  int t11[F(__has_nothrow_constructor(HasCons))];
394  int t12[F(__has_nothrow_constructor(HasRef))];
395  int t13[F(__has_nothrow_constructor(HasCopy))];
396  int t14[F(__has_nothrow_constructor(IntRef))];
397  int t15[T(__has_nothrow_constructor(HasCopyAssign))];
398  int t16[T(__has_nothrow_constructor(const Int))];
399  int t17[T(__has_nothrow_constructor(NonPODAr))];
400  // int t18[T(__has_nothrow_constructor(VirtAr))]; // not implemented
401
402  int t19[T(__has_nothrow_constructor(HasNoThrowConstructor))];
403  int t20[F(__has_nothrow_constructor(HasNoThrowConstructorWithArgs))];
404  int t21[F(__has_nothrow_constructor(void))];
405  int t22[F(__has_nothrow_constructor(cvoid))];
406  int t23[T(__has_nothrow_constructor(HasVirtDest))];
407  int t24[F(__has_nothrow_constructor(HasTemplateCons))];
408}
409
410void has_virtual_destructor() {
411  int t01[F(__has_virtual_destructor(Int))];
412  int t02[F(__has_virtual_destructor(IntAr))];
413  int t03[F(__has_virtual_destructor(Union))];
414  int t04[F(__has_virtual_destructor(UnionAr))];
415  int t05[F(__has_virtual_destructor(POD))];
416  int t06[F(__has_virtual_destructor(Derives))];
417  int t07[F(__has_virtual_destructor(ConstIntAr))];
418  int t08[F(__has_virtual_destructor(ConstIntArAr))];
419  int t09[F(__has_virtual_destructor(HasDest))];
420  int t10[F(__has_virtual_destructor(HasPriv))];
421  int t11[F(__has_virtual_destructor(HasCons))];
422  int t12[F(__has_virtual_destructor(HasRef))];
423  int t13[F(__has_virtual_destructor(HasCopy))];
424  int t14[F(__has_virtual_destructor(IntRef))];
425  int t15[F(__has_virtual_destructor(HasCopyAssign))];
426  int t16[F(__has_virtual_destructor(const Int))];
427  int t17[F(__has_virtual_destructor(NonPODAr))];
428  int t18[F(__has_virtual_destructor(VirtAr))];
429
430  int t19[T(__has_virtual_destructor(HasVirtDest))];
431  int t20[T(__has_virtual_destructor(DerivedVirtDest))];
432  int t21[F(__has_virtual_destructor(VirtDestAr))];
433  int t22[F(__has_virtual_destructor(void))];
434  int t23[F(__has_virtual_destructor(cvoid))];
435}
436