1// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 %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
23struct HasAnonymousUnion {
24  union {
25    int i;
26    float f;
27  };
28};
29
30typedef int Vector __attribute__((vector_size(16)));
31typedef int VectorExt __attribute__((ext_vector_type(4)));
32
33// Not PODs
34typedef const void cvoid;
35struct Derives : POD {};
36typedef Derives DerivesAr[10];
37typedef Derives DerivesArNB[];
38struct DerivesEmpty : Empty {};
39struct HasCons { HasCons(int); };
40struct HasCopyAssign { HasCopyAssign operator =(const HasCopyAssign&); };
41struct HasMoveAssign { HasMoveAssign operator =(const HasMoveAssign&&); };
42struct HasDest { ~HasDest(); };
43class  HasPriv { int priv; };
44class  HasProt { protected: int prot; };
45struct HasRef { int i; int& ref; HasRef() : i(0), ref(i) {} };
46struct HasNonPOD { NonPOD np; };
47struct HasVirt { virtual void Virt() {}; };
48typedef NonPOD NonPODAr[10];
49typedef HasVirt VirtAr[10];
50typedef NonPOD NonPODArNB[];
51union NonPODUnion { int i; Derives n; };
52struct DerivesHasCons : HasCons {};
53struct DerivesHasCopyAssign : HasCopyAssign {};
54struct DerivesHasMoveAssign : HasMoveAssign {};
55struct DerivesHasDest : HasDest {};
56struct DerivesHasPriv : HasPriv {};
57struct DerivesHasProt : HasProt {};
58struct DerivesHasRef : HasRef {};
59struct DerivesHasVirt : HasVirt {};
60
61struct HasNoThrowCopyAssign {
62  void operator =(const HasNoThrowCopyAssign&) throw();
63};
64struct HasMultipleCopyAssign {
65  void operator =(const HasMultipleCopyAssign&) throw();
66  void operator =(volatile HasMultipleCopyAssign&);
67};
68struct HasMultipleNoThrowCopyAssign {
69  void operator =(const HasMultipleNoThrowCopyAssign&) throw();
70  void operator =(volatile HasMultipleNoThrowCopyAssign&) throw();
71};
72
73struct HasNoThrowConstructor { HasNoThrowConstructor() throw(); };
74struct HasNoThrowConstructorWithArgs {
75  HasNoThrowConstructorWithArgs(HasCons i = HasCons(0)) throw();
76};
77
78struct HasNoThrowCopy { HasNoThrowCopy(const HasNoThrowCopy&) throw(); };
79struct HasMultipleCopy {
80  HasMultipleCopy(const HasMultipleCopy&) throw();
81  HasMultipleCopy(volatile HasMultipleCopy&);
82};
83struct HasMultipleNoThrowCopy {
84  HasMultipleNoThrowCopy(const HasMultipleNoThrowCopy&) throw();
85  HasMultipleNoThrowCopy(volatile HasMultipleNoThrowCopy&) throw();
86};
87
88struct HasVirtDest { virtual ~HasVirtDest(); };
89struct DerivedVirtDest : HasVirtDest {};
90typedef HasVirtDest VirtDestAr[1];
91
92class AllPrivate {
93  AllPrivate() throw();
94  AllPrivate(const AllPrivate&) throw();
95  AllPrivate &operator=(const AllPrivate &) throw();
96  ~AllPrivate() throw();
97};
98
99void is_pod()
100{
101  { int arr[T(__is_pod(int))]; }
102  { int arr[T(__is_pod(Enum))]; }
103  { int arr[T(__is_pod(POD))]; }
104  { int arr[T(__is_pod(Int))]; }
105  { int arr[T(__is_pod(IntAr))]; }
106  { int arr[T(__is_pod(Statics))]; }
107  { int arr[T(__is_pod(Empty))]; }
108  { int arr[T(__is_pod(EmptyUnion))]; }
109  { int arr[T(__is_pod(Union))]; }
110  { int arr[T(__is_pod(HasFunc))]; }
111  { int arr[T(__is_pod(HasOp))]; }
112  { int arr[T(__is_pod(HasConv))]; }
113  { int arr[T(__is_pod(HasAssign))]; }
114  { int arr[T(__is_pod(IntArNB))]; }
115  { int arr[T(__is_pod(HasAnonymousUnion))]; }
116  { int arr[T(__is_pod(Vector))]; }
117  { int arr[T(__is_pod(VectorExt))]; }
118
119  { int arr[F(__is_pod(Derives))]; }
120  { int arr[F(__is_pod(DerivesAr))]; }
121  { int arr[F(__is_pod(DerivesArNB))]; }
122  { int arr[F(__is_pod(DerivesEmpty))]; }
123  { int arr[F(__is_pod(HasCons))]; }
124  { int arr[F(__is_pod(HasCopyAssign))]; }
125  { int arr[F(__is_pod(HasMoveAssign))]; }
126  { int arr[F(__is_pod(HasDest))]; }
127  { int arr[F(__is_pod(HasPriv))]; }
128  { int arr[F(__is_pod(HasProt))]; }
129  { int arr[F(__is_pod(HasRef))]; }
130  { int arr[F(__is_pod(HasVirt))]; }
131  { int arr[F(__is_pod(DerivesHasCons))]; }
132  { int arr[F(__is_pod(DerivesHasCopyAssign))]; }
133  { int arr[F(__is_pod(DerivesHasMoveAssign))]; }
134  { int arr[F(__is_pod(DerivesHasDest))]; }
135  { int arr[F(__is_pod(DerivesHasPriv))]; }
136  { int arr[F(__is_pod(DerivesHasProt))]; }
137  { int arr[F(__is_pod(DerivesHasRef))]; }
138  { int arr[F(__is_pod(DerivesHasVirt))]; }
139  { int arr[F(__is_pod(NonPOD))]; }
140  { int arr[F(__is_pod(HasNonPOD))]; }
141  { int arr[F(__is_pod(NonPODAr))]; }
142  { int arr[F(__is_pod(NonPODArNB))]; }
143  { int arr[F(__is_pod(void))]; }
144  { int arr[F(__is_pod(cvoid))]; }
145// { int arr[F(__is_pod(NonPODUnion))]; }
146}
147
148typedef Empty EmptyAr[10];
149struct Bit0 { int : 0; };
150struct Bit0Cons { int : 0; Bit0Cons(); };
151struct BitOnly { int x : 3; };
152//struct DerivesVirt : virtual POD {};
153
154void is_empty()
155{
156  { int arr[T(__is_empty(Empty))]; }
157  { int arr[T(__is_empty(DerivesEmpty))]; }
158  { int arr[T(__is_empty(HasCons))]; }
159  { int arr[T(__is_empty(HasCopyAssign))]; }
160  { int arr[T(__is_empty(HasMoveAssign))]; }
161  { int arr[T(__is_empty(HasDest))]; }
162  { int arr[T(__is_empty(HasFunc))]; }
163  { int arr[T(__is_empty(HasOp))]; }
164  { int arr[T(__is_empty(HasConv))]; }
165  { int arr[T(__is_empty(HasAssign))]; }
166  { int arr[T(__is_empty(Bit0))]; }
167  { int arr[T(__is_empty(Bit0Cons))]; }
168
169  { int arr[F(__is_empty(Int))]; }
170  { int arr[F(__is_empty(POD))]; }
171  { int arr[F(__is_empty(EmptyUnion))]; }
172  { int arr[F(__is_empty(EmptyAr))]; }
173  { int arr[F(__is_empty(HasRef))]; }
174  { int arr[F(__is_empty(HasVirt))]; }
175  { int arr[F(__is_empty(BitOnly))]; }
176  { int arr[F(__is_empty(void))]; }
177  { int arr[F(__is_empty(IntArNB))]; }
178  { int arr[F(__is_empty(HasAnonymousUnion))]; }
179//  { int arr[F(__is_empty(DerivesVirt))]; }
180}
181
182typedef Derives ClassType;
183
184void is_class()
185{
186  { int arr[T(__is_class(Derives))]; }
187  { int arr[T(__is_class(HasPriv))]; }
188  { int arr[T(__is_class(ClassType))]; }
189  { int arr[T(__is_class(HasAnonymousUnion))]; }
190
191  { int arr[F(__is_class(int))]; }
192  { int arr[F(__is_class(Enum))]; }
193  { int arr[F(__is_class(Int))]; }
194  { int arr[F(__is_class(IntAr))]; }
195  { int arr[F(__is_class(DerivesAr))]; }
196  { int arr[F(__is_class(Union))]; }
197  { int arr[F(__is_class(cvoid))]; }
198  { int arr[F(__is_class(IntArNB))]; }
199}
200
201typedef Union UnionAr[10];
202typedef Union UnionType;
203
204void is_union()
205{
206  { int arr[T(__is_union(Union))]; }
207  { int arr[T(__is_union(UnionType))]; }
208
209  { int arr[F(__is_union(int))]; }
210  { int arr[F(__is_union(Enum))]; }
211  { int arr[F(__is_union(Int))]; }
212  { int arr[F(__is_union(IntAr))]; }
213  { int arr[F(__is_union(UnionAr))]; }
214  { int arr[F(__is_union(cvoid))]; }
215  { int arr[F(__is_union(IntArNB))]; }
216  { int arr[F(__is_union(HasAnonymousUnion))]; }
217}
218
219typedef Enum EnumType;
220
221void is_enum()
222{
223  { int arr[T(__is_enum(Enum))]; }
224  { int arr[T(__is_enum(EnumType))]; }
225
226  { int arr[F(__is_enum(int))]; }
227  { int arr[F(__is_enum(Union))]; }
228  { int arr[F(__is_enum(Int))]; }
229  { int arr[F(__is_enum(IntAr))]; }
230  { int arr[F(__is_enum(UnionAr))]; }
231  { int arr[F(__is_enum(Derives))]; }
232  { int arr[F(__is_enum(ClassType))]; }
233  { int arr[F(__is_enum(cvoid))]; }
234  { int arr[F(__is_enum(IntArNB))]; }
235  { int arr[F(__is_enum(HasAnonymousUnion))]; }
236}
237
238typedef HasVirt Polymorph;
239struct InheritPolymorph : Polymorph {};
240
241void is_polymorphic()
242{
243  { int arr[T(__is_polymorphic(Polymorph))]; }
244  { int arr[T(__is_polymorphic(InheritPolymorph))]; }
245
246  { int arr[F(__is_polymorphic(int))]; }
247  { int arr[F(__is_polymorphic(Union))]; }
248  { int arr[F(__is_polymorphic(Int))]; }
249  { int arr[F(__is_polymorphic(IntAr))]; }
250  { int arr[F(__is_polymorphic(UnionAr))]; }
251  { int arr[F(__is_polymorphic(Derives))]; }
252  { int arr[F(__is_polymorphic(ClassType))]; }
253  { int arr[F(__is_polymorphic(Enum))]; }
254  { int arr[F(__is_polymorphic(cvoid))]; }
255  { int arr[F(__is_polymorphic(IntArNB))]; }
256}
257
258void is_integral()
259{
260  int t01[T(__is_integral(bool))];
261  int t02[T(__is_integral(char))];
262  int t03[T(__is_integral(signed char))];
263  int t04[T(__is_integral(unsigned char))];
264  //int t05[T(__is_integral(char16_t))];
265  //int t06[T(__is_integral(char32_t))];
266  int t07[T(__is_integral(wchar_t))];
267  int t08[T(__is_integral(short))];
268  int t09[T(__is_integral(unsigned short))];
269  int t10[T(__is_integral(int))];
270  int t11[T(__is_integral(unsigned int))];
271  int t12[T(__is_integral(long))];
272  int t13[T(__is_integral(unsigned long))];
273
274  int t21[F(__is_integral(float))];
275  int t22[F(__is_integral(double))];
276  int t23[F(__is_integral(long double))];
277  int t24[F(__is_integral(Union))];
278  int t25[F(__is_integral(UnionAr))];
279  int t26[F(__is_integral(Derives))];
280  int t27[F(__is_integral(ClassType))];
281  int t28[F(__is_integral(Enum))];
282  int t29[F(__is_integral(void))];
283  int t30[F(__is_integral(cvoid))];
284  int t31[F(__is_integral(IntArNB))];
285}
286
287void is_floating_point()
288{
289  int t01[T(__is_floating_point(float))];
290  int t02[T(__is_floating_point(double))];
291  int t03[T(__is_floating_point(long double))];
292
293  int t11[F(__is_floating_point(bool))];
294  int t12[F(__is_floating_point(char))];
295  int t13[F(__is_floating_point(signed char))];
296  int t14[F(__is_floating_point(unsigned char))];
297  //int t15[F(__is_floating_point(char16_t))];
298  //int t16[F(__is_floating_point(char32_t))];
299  int t17[F(__is_floating_point(wchar_t))];
300  int t18[F(__is_floating_point(short))];
301  int t19[F(__is_floating_point(unsigned short))];
302  int t20[F(__is_floating_point(int))];
303  int t21[F(__is_floating_point(unsigned int))];
304  int t22[F(__is_floating_point(long))];
305  int t23[F(__is_floating_point(unsigned long))];
306  int t24[F(__is_floating_point(Union))];
307  int t25[F(__is_floating_point(UnionAr))];
308  int t26[F(__is_floating_point(Derives))];
309  int t27[F(__is_floating_point(ClassType))];
310  int t28[F(__is_floating_point(Enum))];
311  int t29[F(__is_floating_point(void))];
312  int t30[F(__is_floating_point(cvoid))];
313  int t31[F(__is_floating_point(IntArNB))];
314}
315
316void is_arithmetic()
317{
318  int t01[T(__is_arithmetic(float))];
319  int t02[T(__is_arithmetic(double))];
320  int t03[T(__is_arithmetic(long double))];
321  int t11[T(__is_arithmetic(bool))];
322  int t12[T(__is_arithmetic(char))];
323  int t13[T(__is_arithmetic(signed char))];
324  int t14[T(__is_arithmetic(unsigned char))];
325  //int t15[T(__is_arithmetic(char16_t))];
326  //int t16[T(__is_arithmetic(char32_t))];
327  int t17[T(__is_arithmetic(wchar_t))];
328  int t18[T(__is_arithmetic(short))];
329  int t19[T(__is_arithmetic(unsigned short))];
330  int t20[T(__is_arithmetic(int))];
331  int t21[T(__is_arithmetic(unsigned int))];
332  int t22[T(__is_arithmetic(long))];
333  int t23[T(__is_arithmetic(unsigned long))];
334
335  int t24[F(__is_arithmetic(Union))];
336  int t25[F(__is_arithmetic(UnionAr))];
337  int t26[F(__is_arithmetic(Derives))];
338  int t27[F(__is_arithmetic(ClassType))];
339  int t28[F(__is_arithmetic(Enum))];
340  int t29[F(__is_arithmetic(void))];
341  int t30[F(__is_arithmetic(cvoid))];
342  int t31[F(__is_arithmetic(IntArNB))];
343}
344
345struct ACompleteType {};
346struct AnIncompleteType;
347
348void is_complete_type()
349{
350  int t01[T(__is_complete_type(float))];
351  int t02[T(__is_complete_type(double))];
352  int t03[T(__is_complete_type(long double))];
353  int t11[T(__is_complete_type(bool))];
354  int t12[T(__is_complete_type(char))];
355  int t13[T(__is_complete_type(signed char))];
356  int t14[T(__is_complete_type(unsigned char))];
357  //int t15[T(__is_complete_type(char16_t))];
358  //int t16[T(__is_complete_type(char32_t))];
359  int t17[T(__is_complete_type(wchar_t))];
360  int t18[T(__is_complete_type(short))];
361  int t19[T(__is_complete_type(unsigned short))];
362  int t20[T(__is_complete_type(int))];
363  int t21[T(__is_complete_type(unsigned int))];
364  int t22[T(__is_complete_type(long))];
365  int t23[T(__is_complete_type(unsigned long))];
366  int t24[T(__is_complete_type(ACompleteType))];
367
368  int t30[F(__is_complete_type(AnIncompleteType))];
369}
370
371void is_void()
372{
373  int t01[T(__is_void(void))];
374  int t02[T(__is_void(cvoid))];
375
376  int t10[F(__is_void(float))];
377  int t11[F(__is_void(double))];
378  int t12[F(__is_void(long double))];
379  int t13[F(__is_void(bool))];
380  int t14[F(__is_void(char))];
381  int t15[F(__is_void(signed char))];
382  int t16[F(__is_void(unsigned char))];
383  int t17[F(__is_void(wchar_t))];
384  int t18[F(__is_void(short))];
385  int t19[F(__is_void(unsigned short))];
386  int t20[F(__is_void(int))];
387  int t21[F(__is_void(unsigned int))];
388  int t22[F(__is_void(long))];
389  int t23[F(__is_void(unsigned long))];
390  int t24[F(__is_void(Union))];
391  int t25[F(__is_void(UnionAr))];
392  int t26[F(__is_void(Derives))];
393  int t27[F(__is_void(ClassType))];
394  int t28[F(__is_void(Enum))];
395  int t29[F(__is_void(IntArNB))];
396  int t30[F(__is_void(void*))];
397  int t31[F(__is_void(cvoid*))];
398}
399
400void is_array()
401{
402  int t01[T(__is_array(IntAr))];
403  int t02[T(__is_array(IntArNB))];
404  int t03[T(__is_array(UnionAr))];
405
406  int t10[F(__is_array(void))];
407  int t11[F(__is_array(cvoid))];
408  int t12[F(__is_array(float))];
409  int t13[F(__is_array(double))];
410  int t14[F(__is_array(long double))];
411  int t15[F(__is_array(bool))];
412  int t16[F(__is_array(char))];
413  int t17[F(__is_array(signed char))];
414  int t18[F(__is_array(unsigned char))];
415  int t19[F(__is_array(wchar_t))];
416  int t20[F(__is_array(short))];
417  int t21[F(__is_array(unsigned short))];
418  int t22[F(__is_array(int))];
419  int t23[F(__is_array(unsigned int))];
420  int t24[F(__is_array(long))];
421  int t25[F(__is_array(unsigned long))];
422  int t26[F(__is_array(Union))];
423  int t27[F(__is_array(Derives))];
424  int t28[F(__is_array(ClassType))];
425  int t29[F(__is_array(Enum))];
426  int t30[F(__is_array(void*))];
427  int t31[F(__is_array(cvoid*))];
428}
429
430template <typename T> void tmpl_func(T&) {}
431
432template <typename T> struct type_wrapper {
433  typedef T type;
434  typedef T* ptrtype;
435  typedef T& reftype;
436};
437
438void is_function()
439{
440  int t01[T(__is_function(type_wrapper<void(void)>::type))];
441  int t02[T(__is_function(typeof(tmpl_func<int>)))];
442
443  typedef void (*ptr_to_func_type)(void);
444
445  int t10[F(__is_function(void))];
446  int t11[F(__is_function(cvoid))];
447  int t12[F(__is_function(float))];
448  int t13[F(__is_function(double))];
449  int t14[F(__is_function(long double))];
450  int t15[F(__is_function(bool))];
451  int t16[F(__is_function(char))];
452  int t17[F(__is_function(signed char))];
453  int t18[F(__is_function(unsigned char))];
454  int t19[F(__is_function(wchar_t))];
455  int t20[F(__is_function(short))];
456  int t21[F(__is_function(unsigned short))];
457  int t22[F(__is_function(int))];
458  int t23[F(__is_function(unsigned int))];
459  int t24[F(__is_function(long))];
460  int t25[F(__is_function(unsigned long))];
461  int t26[F(__is_function(Union))];
462  int t27[F(__is_function(Derives))];
463  int t28[F(__is_function(ClassType))];
464  int t29[F(__is_function(Enum))];
465  int t30[F(__is_function(void*))];
466  int t31[F(__is_function(cvoid*))];
467  int t32[F(__is_function(void(*)()))];
468  int t33[F(__is_function(ptr_to_func_type))];
469  int t34[F(__is_function(type_wrapper<void(void)>::ptrtype))];
470  int t35[F(__is_function(type_wrapper<void(void)>::reftype))];
471}
472
473void is_reference()
474{
475  int t01[T(__is_reference(int&))];
476  int t02[T(__is_reference(const int&))];
477  int t03[T(__is_reference(void *&))];
478
479  int t10[F(__is_reference(int))];
480  int t11[F(__is_reference(const int))];
481  int t12[F(__is_reference(void *))];
482}
483
484void is_lvalue_reference()
485{
486  int t01[T(__is_lvalue_reference(int&))];
487  int t02[T(__is_lvalue_reference(void *&))];
488  int t03[T(__is_lvalue_reference(const int&))];
489  int t04[T(__is_lvalue_reference(void * const &))];
490
491  int t10[F(__is_lvalue_reference(int))];
492  int t11[F(__is_lvalue_reference(const int))];
493  int t12[F(__is_lvalue_reference(void *))];
494}
495
496#if __has_feature(cxx_rvalue_references)
497
498void is_rvalue_reference()
499{
500  int t01[T(__is_rvalue_reference(const int&&))];
501  int t02[T(__is_rvalue_reference(void * const &&))];
502
503  int t10[F(__is_rvalue_reference(int&))];
504  int t11[F(__is_rvalue_reference(void *&))];
505  int t12[F(__is_rvalue_reference(const int&))];
506  int t13[F(__is_rvalue_reference(void * const &))];
507  int t14[F(__is_rvalue_reference(int))];
508  int t15[F(__is_rvalue_reference(const int))];
509  int t16[F(__is_rvalue_reference(void *))];
510}
511
512#endif
513
514void is_fundamental()
515{
516  int t01[T(__is_fundamental(float))];
517  int t02[T(__is_fundamental(double))];
518  int t03[T(__is_fundamental(long double))];
519  int t11[T(__is_fundamental(bool))];
520  int t12[T(__is_fundamental(char))];
521  int t13[T(__is_fundamental(signed char))];
522  int t14[T(__is_fundamental(unsigned char))];
523  //int t15[T(__is_fundamental(char16_t))];
524  //int t16[T(__is_fundamental(char32_t))];
525  int t17[T(__is_fundamental(wchar_t))];
526  int t18[T(__is_fundamental(short))];
527  int t19[T(__is_fundamental(unsigned short))];
528  int t20[T(__is_fundamental(int))];
529  int t21[T(__is_fundamental(unsigned int))];
530  int t22[T(__is_fundamental(long))];
531  int t23[T(__is_fundamental(unsigned long))];
532  int t24[T(__is_fundamental(void))];
533  int t25[T(__is_fundamental(cvoid))];
534
535  int t30[F(__is_fundamental(Union))];
536  int t31[F(__is_fundamental(UnionAr))];
537  int t32[F(__is_fundamental(Derives))];
538  int t33[F(__is_fundamental(ClassType))];
539  int t34[F(__is_fundamental(Enum))];
540  int t35[F(__is_fundamental(IntArNB))];
541}
542
543void is_object()
544{
545  int t01[T(__is_object(int))];
546  int t02[T(__is_object(int *))];
547  int t03[T(__is_object(void *))];
548  int t04[T(__is_object(Union))];
549  int t05[T(__is_object(UnionAr))];
550  int t06[T(__is_object(ClassType))];
551  int t07[T(__is_object(Enum))];
552
553  int t10[F(__is_object(type_wrapper<void(void)>::type))];
554  int t11[F(__is_object(int&))];
555  int t12[F(__is_object(void))];
556}
557
558void is_scalar()
559{
560  int t01[T(__is_scalar(float))];
561  int t02[T(__is_scalar(double))];
562  int t03[T(__is_scalar(long double))];
563  int t04[T(__is_scalar(bool))];
564  int t05[T(__is_scalar(char))];
565  int t06[T(__is_scalar(signed char))];
566  int t07[T(__is_scalar(unsigned char))];
567  int t08[T(__is_scalar(wchar_t))];
568  int t09[T(__is_scalar(short))];
569  int t10[T(__is_scalar(unsigned short))];
570  int t11[T(__is_scalar(int))];
571  int t12[T(__is_scalar(unsigned int))];
572  int t13[T(__is_scalar(long))];
573  int t14[T(__is_scalar(unsigned long))];
574  int t15[T(__is_scalar(Enum))];
575  int t16[T(__is_scalar(void*))];
576  int t17[T(__is_scalar(cvoid*))];
577
578  int t20[F(__is_scalar(void))];
579  int t21[F(__is_scalar(cvoid))];
580  int t22[F(__is_scalar(Union))];
581  int t23[F(__is_scalar(UnionAr))];
582  int t24[F(__is_scalar(Derives))];
583  int t25[F(__is_scalar(ClassType))];
584  int t26[F(__is_scalar(IntArNB))];
585}
586
587struct StructWithMembers {
588  int member;
589  void method() {}
590};
591
592void is_compound()
593{
594  int t01[T(__is_compound(void*))];
595  int t02[T(__is_compound(cvoid*))];
596  int t03[T(__is_compound(void (*)()))];
597  int t04[T(__is_compound(int StructWithMembers::*))];
598  int t05[T(__is_compound(void (StructWithMembers::*)()))];
599  int t06[T(__is_compound(int&))];
600  int t07[T(__is_compound(Union))];
601  int t08[T(__is_compound(UnionAr))];
602  int t09[T(__is_compound(Derives))];
603  int t10[T(__is_compound(ClassType))];
604  int t11[T(__is_compound(IntArNB))];
605  int t12[T(__is_compound(Enum))];
606
607  int t20[F(__is_compound(float))];
608  int t21[F(__is_compound(double))];
609  int t22[F(__is_compound(long double))];
610  int t23[F(__is_compound(bool))];
611  int t24[F(__is_compound(char))];
612  int t25[F(__is_compound(signed char))];
613  int t26[F(__is_compound(unsigned char))];
614  int t27[F(__is_compound(wchar_t))];
615  int t28[F(__is_compound(short))];
616  int t29[F(__is_compound(unsigned short))];
617  int t30[F(__is_compound(int))];
618  int t31[F(__is_compound(unsigned int))];
619  int t32[F(__is_compound(long))];
620  int t33[F(__is_compound(unsigned long))];
621  int t34[F(__is_compound(void))];
622  int t35[F(__is_compound(cvoid))];
623}
624
625void is_pointer()
626{
627  StructWithMembers x;
628
629  int t01[T(__is_pointer(void*))];
630  int t02[T(__is_pointer(cvoid*))];
631  int t03[T(__is_pointer(cvoid*))];
632  int t04[T(__is_pointer(char*))];
633  int t05[T(__is_pointer(int*))];
634  int t06[T(__is_pointer(int**))];
635  int t07[T(__is_pointer(ClassType*))];
636  int t08[T(__is_pointer(Derives*))];
637  int t09[T(__is_pointer(Enum*))];
638  int t10[T(__is_pointer(IntArNB*))];
639  int t11[T(__is_pointer(Union*))];
640  int t12[T(__is_pointer(UnionAr*))];
641  int t13[T(__is_pointer(StructWithMembers*))];
642  int t14[T(__is_pointer(void (*)()))];
643
644  int t20[F(__is_pointer(void))];
645  int t21[F(__is_pointer(cvoid))];
646  int t22[F(__is_pointer(cvoid))];
647  int t23[F(__is_pointer(char))];
648  int t24[F(__is_pointer(int))];
649  int t25[F(__is_pointer(int))];
650  int t26[F(__is_pointer(ClassType))];
651  int t27[F(__is_pointer(Derives))];
652  int t28[F(__is_pointer(Enum))];
653  int t29[F(__is_pointer(IntArNB))];
654  int t30[F(__is_pointer(Union))];
655  int t31[F(__is_pointer(UnionAr))];
656  int t32[F(__is_pointer(StructWithMembers))];
657  int t33[F(__is_pointer(int StructWithMembers::*))];
658  int t34[F(__is_pointer(void (StructWithMembers::*) ()))];
659}
660
661void is_member_object_pointer()
662{
663  StructWithMembers x;
664
665  int t01[T(__is_member_object_pointer(int StructWithMembers::*))];
666
667  int t10[F(__is_member_object_pointer(void (StructWithMembers::*) ()))];
668  int t11[F(__is_member_object_pointer(void*))];
669  int t12[F(__is_member_object_pointer(cvoid*))];
670  int t13[F(__is_member_object_pointer(cvoid*))];
671  int t14[F(__is_member_object_pointer(char*))];
672  int t15[F(__is_member_object_pointer(int*))];
673  int t16[F(__is_member_object_pointer(int**))];
674  int t17[F(__is_member_object_pointer(ClassType*))];
675  int t18[F(__is_member_object_pointer(Derives*))];
676  int t19[F(__is_member_object_pointer(Enum*))];
677  int t20[F(__is_member_object_pointer(IntArNB*))];
678  int t21[F(__is_member_object_pointer(Union*))];
679  int t22[F(__is_member_object_pointer(UnionAr*))];
680  int t23[F(__is_member_object_pointer(StructWithMembers*))];
681  int t24[F(__is_member_object_pointer(void))];
682  int t25[F(__is_member_object_pointer(cvoid))];
683  int t26[F(__is_member_object_pointer(cvoid))];
684  int t27[F(__is_member_object_pointer(char))];
685  int t28[F(__is_member_object_pointer(int))];
686  int t29[F(__is_member_object_pointer(int))];
687  int t30[F(__is_member_object_pointer(ClassType))];
688  int t31[F(__is_member_object_pointer(Derives))];
689  int t32[F(__is_member_object_pointer(Enum))];
690  int t33[F(__is_member_object_pointer(IntArNB))];
691  int t34[F(__is_member_object_pointer(Union))];
692  int t35[F(__is_member_object_pointer(UnionAr))];
693  int t36[F(__is_member_object_pointer(StructWithMembers))];
694  int t37[F(__is_member_object_pointer(void (*)()))];
695}
696
697void is_member_function_pointer()
698{
699  StructWithMembers x;
700
701  int t01[T(__is_member_function_pointer(void (StructWithMembers::*) ()))];
702
703  int t10[F(__is_member_function_pointer(int StructWithMembers::*))];
704  int t11[F(__is_member_function_pointer(void*))];
705  int t12[F(__is_member_function_pointer(cvoid*))];
706  int t13[F(__is_member_function_pointer(cvoid*))];
707  int t14[F(__is_member_function_pointer(char*))];
708  int t15[F(__is_member_function_pointer(int*))];
709  int t16[F(__is_member_function_pointer(int**))];
710  int t17[F(__is_member_function_pointer(ClassType*))];
711  int t18[F(__is_member_function_pointer(Derives*))];
712  int t19[F(__is_member_function_pointer(Enum*))];
713  int t20[F(__is_member_function_pointer(IntArNB*))];
714  int t21[F(__is_member_function_pointer(Union*))];
715  int t22[F(__is_member_function_pointer(UnionAr*))];
716  int t23[F(__is_member_function_pointer(StructWithMembers*))];
717  int t24[F(__is_member_function_pointer(void))];
718  int t25[F(__is_member_function_pointer(cvoid))];
719  int t26[F(__is_member_function_pointer(cvoid))];
720  int t27[F(__is_member_function_pointer(char))];
721  int t28[F(__is_member_function_pointer(int))];
722  int t29[F(__is_member_function_pointer(int))];
723  int t30[F(__is_member_function_pointer(ClassType))];
724  int t31[F(__is_member_function_pointer(Derives))];
725  int t32[F(__is_member_function_pointer(Enum))];
726  int t33[F(__is_member_function_pointer(IntArNB))];
727  int t34[F(__is_member_function_pointer(Union))];
728  int t35[F(__is_member_function_pointer(UnionAr))];
729  int t36[F(__is_member_function_pointer(StructWithMembers))];
730  int t37[F(__is_member_function_pointer(void (*)()))];
731}
732
733void is_member_pointer()
734{
735  StructWithMembers x;
736
737  int t01[T(__is_member_pointer(int StructWithMembers::*))];
738  int t02[T(__is_member_pointer(void (StructWithMembers::*) ()))];
739
740  int t10[F(__is_member_pointer(void*))];
741  int t11[F(__is_member_pointer(cvoid*))];
742  int t12[F(__is_member_pointer(cvoid*))];
743  int t13[F(__is_member_pointer(char*))];
744  int t14[F(__is_member_pointer(int*))];
745  int t15[F(__is_member_pointer(int**))];
746  int t16[F(__is_member_pointer(ClassType*))];
747  int t17[F(__is_member_pointer(Derives*))];
748  int t18[F(__is_member_pointer(Enum*))];
749  int t19[F(__is_member_pointer(IntArNB*))];
750  int t20[F(__is_member_pointer(Union*))];
751  int t21[F(__is_member_pointer(UnionAr*))];
752  int t22[F(__is_member_pointer(StructWithMembers*))];
753  int t23[F(__is_member_pointer(void))];
754  int t24[F(__is_member_pointer(cvoid))];
755  int t25[F(__is_member_pointer(cvoid))];
756  int t26[F(__is_member_pointer(char))];
757  int t27[F(__is_member_pointer(int))];
758  int t28[F(__is_member_pointer(int))];
759  int t29[F(__is_member_pointer(ClassType))];
760  int t30[F(__is_member_pointer(Derives))];
761  int t31[F(__is_member_pointer(Enum))];
762  int t32[F(__is_member_pointer(IntArNB))];
763  int t33[F(__is_member_pointer(Union))];
764  int t34[F(__is_member_pointer(UnionAr))];
765  int t35[F(__is_member_pointer(StructWithMembers))];
766  int t36[F(__is_member_pointer(void (*)()))];
767}
768
769void is_const()
770{
771  int t01[T(__is_const(cvoid))];
772  int t02[T(__is_const(const char))];
773  int t03[T(__is_const(const int))];
774  int t04[T(__is_const(const long))];
775  int t05[T(__is_const(const short))];
776  int t06[T(__is_const(const signed char))];
777  int t07[T(__is_const(const wchar_t))];
778  int t08[T(__is_const(const bool))];
779  int t09[T(__is_const(const float))];
780  int t10[T(__is_const(const double))];
781  int t11[T(__is_const(const long double))];
782  int t12[T(__is_const(const unsigned char))];
783  int t13[T(__is_const(const unsigned int))];
784  int t14[T(__is_const(const unsigned long long))];
785  int t15[T(__is_const(const unsigned long))];
786  int t16[T(__is_const(const unsigned short))];
787  int t17[T(__is_const(const void))];
788  int t18[T(__is_const(const ClassType))];
789  int t19[T(__is_const(const Derives))];
790  int t20[T(__is_const(const Enum))];
791  int t21[T(__is_const(const IntArNB))];
792  int t22[T(__is_const(const Union))];
793  int t23[T(__is_const(const UnionAr))];
794
795  int t30[F(__is_const(char))];
796  int t31[F(__is_const(int))];
797  int t32[F(__is_const(long))];
798  int t33[F(__is_const(short))];
799  int t34[F(__is_const(signed char))];
800  int t35[F(__is_const(wchar_t))];
801  int t36[F(__is_const(bool))];
802  int t37[F(__is_const(float))];
803  int t38[F(__is_const(double))];
804  int t39[F(__is_const(long double))];
805  int t40[F(__is_const(unsigned char))];
806  int t41[F(__is_const(unsigned int))];
807  int t42[F(__is_const(unsigned long long))];
808  int t43[F(__is_const(unsigned long))];
809  int t44[F(__is_const(unsigned short))];
810  int t45[F(__is_const(void))];
811  int t46[F(__is_const(ClassType))];
812  int t47[F(__is_const(Derives))];
813  int t48[F(__is_const(Enum))];
814  int t49[F(__is_const(IntArNB))];
815  int t50[F(__is_const(Union))];
816  int t51[F(__is_const(UnionAr))];
817}
818
819void is_volatile()
820{
821  int t02[T(__is_volatile(volatile char))];
822  int t03[T(__is_volatile(volatile int))];
823  int t04[T(__is_volatile(volatile long))];
824  int t05[T(__is_volatile(volatile short))];
825  int t06[T(__is_volatile(volatile signed char))];
826  int t07[T(__is_volatile(volatile wchar_t))];
827  int t08[T(__is_volatile(volatile bool))];
828  int t09[T(__is_volatile(volatile float))];
829  int t10[T(__is_volatile(volatile double))];
830  int t11[T(__is_volatile(volatile long double))];
831  int t12[T(__is_volatile(volatile unsigned char))];
832  int t13[T(__is_volatile(volatile unsigned int))];
833  int t14[T(__is_volatile(volatile unsigned long long))];
834  int t15[T(__is_volatile(volatile unsigned long))];
835  int t16[T(__is_volatile(volatile unsigned short))];
836  int t17[T(__is_volatile(volatile void))];
837  int t18[T(__is_volatile(volatile ClassType))];
838  int t19[T(__is_volatile(volatile Derives))];
839  int t20[T(__is_volatile(volatile Enum))];
840  int t21[T(__is_volatile(volatile IntArNB))];
841  int t22[T(__is_volatile(volatile Union))];
842  int t23[T(__is_volatile(volatile UnionAr))];
843
844  int t30[F(__is_volatile(char))];
845  int t31[F(__is_volatile(int))];
846  int t32[F(__is_volatile(long))];
847  int t33[F(__is_volatile(short))];
848  int t34[F(__is_volatile(signed char))];
849  int t35[F(__is_volatile(wchar_t))];
850  int t36[F(__is_volatile(bool))];
851  int t37[F(__is_volatile(float))];
852  int t38[F(__is_volatile(double))];
853  int t39[F(__is_volatile(long double))];
854  int t40[F(__is_volatile(unsigned char))];
855  int t41[F(__is_volatile(unsigned int))];
856  int t42[F(__is_volatile(unsigned long long))];
857  int t43[F(__is_volatile(unsigned long))];
858  int t44[F(__is_volatile(unsigned short))];
859  int t45[F(__is_volatile(void))];
860  int t46[F(__is_volatile(ClassType))];
861  int t47[F(__is_volatile(Derives))];
862  int t48[F(__is_volatile(Enum))];
863  int t49[F(__is_volatile(IntArNB))];
864  int t50[F(__is_volatile(Union))];
865  int t51[F(__is_volatile(UnionAr))];
866}
867
868struct TrivialStruct {
869  int member;
870};
871
872struct NonTrivialStruct {
873  int member;
874  NonTrivialStruct() {
875    member = 0;
876  }
877};
878
879struct SuperNonTrivialStruct {
880  SuperNonTrivialStruct() { }
881  ~SuperNonTrivialStruct() { }
882};
883
884struct NonTCStruct {
885  NonTCStruct(const NonTCStruct&) {}
886};
887
888void is_trivial2()
889{
890  int t01[T(__is_trivial(char))];
891  int t02[T(__is_trivial(int))];
892  int t03[T(__is_trivial(long))];
893  int t04[T(__is_trivial(short))];
894  int t05[T(__is_trivial(signed char))];
895  int t06[T(__is_trivial(wchar_t))];
896  int t07[T(__is_trivial(bool))];
897  int t08[T(__is_trivial(float))];
898  int t09[T(__is_trivial(double))];
899  int t10[T(__is_trivial(long double))];
900  int t11[T(__is_trivial(unsigned char))];
901  int t12[T(__is_trivial(unsigned int))];
902  int t13[T(__is_trivial(unsigned long long))];
903  int t14[T(__is_trivial(unsigned long))];
904  int t15[T(__is_trivial(unsigned short))];
905  int t16[T(__is_trivial(ClassType))];
906  int t17[T(__is_trivial(Derives))];
907  int t18[T(__is_trivial(Enum))];
908  int t19[T(__is_trivial(IntAr))];
909  int t20[T(__is_trivial(Union))];
910  int t21[T(__is_trivial(UnionAr))];
911  int t22[T(__is_trivial(TrivialStruct))];
912
913  int t30[F(__is_trivial(void))];
914  int t31[F(__is_trivial(NonTrivialStruct))];
915  int t32[F(__is_trivial(SuperNonTrivialStruct))];
916  int t33[F(__is_trivial(NonTCStruct))];
917}
918
919void is_trivially_copyable2()
920{
921  int t01[T(__is_trivially_copyable(char))];
922  int t02[T(__is_trivially_copyable(int))];
923  int t03[T(__is_trivially_copyable(long))];
924  int t04[T(__is_trivially_copyable(short))];
925  int t05[T(__is_trivially_copyable(signed char))];
926  int t06[T(__is_trivially_copyable(wchar_t))];
927  int t07[T(__is_trivially_copyable(bool))];
928  int t08[T(__is_trivially_copyable(float))];
929  int t09[T(__is_trivially_copyable(double))];
930  int t10[T(__is_trivially_copyable(long double))];
931  int t11[T(__is_trivially_copyable(unsigned char))];
932  int t12[T(__is_trivially_copyable(unsigned int))];
933  int t13[T(__is_trivially_copyable(unsigned long long))];
934  int t14[T(__is_trivially_copyable(unsigned long))];
935  int t15[T(__is_trivially_copyable(unsigned short))];
936  int t16[T(__is_trivially_copyable(ClassType))];
937  int t17[T(__is_trivially_copyable(Derives))];
938  int t18[T(__is_trivially_copyable(Enum))];
939  int t19[T(__is_trivially_copyable(IntAr))];
940  int t20[T(__is_trivially_copyable(Union))];
941  int t21[T(__is_trivially_copyable(UnionAr))];
942  int t22[T(__is_trivially_copyable(TrivialStruct))];
943  int t23[T(__is_trivially_copyable(NonTrivialStruct))];
944
945  int t30[F(__is_trivially_copyable(void))];
946  int t32[F(__is_trivially_copyable(SuperNonTrivialStruct))];
947  int t31[F(__is_trivially_copyable(NonTCStruct))];
948}
949
950struct CStruct {
951  int one;
952  int two;
953};
954
955struct CEmptyStruct {};
956
957struct CppEmptyStruct : CStruct {};
958struct CppStructStandard : CEmptyStruct {
959  int three;
960  int four;
961};
962struct CppStructNonStandardByBase : CStruct {
963  int three;
964  int four;
965};
966struct CppStructNonStandardByVirt : CStruct {
967  virtual void method() {}
968};
969struct CppStructNonStandardByMemb : CStruct {
970  CppStructNonStandardByVirt member;
971};
972struct CppStructNonStandardByProt : CStruct {
973  int five;
974protected:
975  int six;
976};
977struct CppStructNonStandardByVirtBase : virtual CStruct {
978};
979struct CppStructNonStandardBySameBase : CEmptyStruct {
980  CEmptyStruct member;
981};
982struct CppStructNonStandardBy2ndVirtBase : CEmptyStruct {
983  CEmptyStruct member;
984};
985
986void is_standard_layout()
987{
988  typedef const int ConstInt;
989  typedef ConstInt ConstIntAr[4];
990  typedef CppStructStandard CppStructStandardAr[4];
991
992  int t01[T(__is_standard_layout(int))];
993  int t02[T(__is_standard_layout(ConstInt))];
994  int t03[T(__is_standard_layout(ConstIntAr))];
995  int t04[T(__is_standard_layout(CStruct))];
996  int t05[T(__is_standard_layout(CppStructStandard))];
997  int t06[T(__is_standard_layout(CppStructStandardAr))];
998  int t07[T(__is_standard_layout(Vector))];
999  int t08[T(__is_standard_layout(VectorExt))];
1000
1001  typedef CppStructNonStandardByBase CppStructNonStandardByBaseAr[4];
1002
1003  int t10[F(__is_standard_layout(CppStructNonStandardByVirt))];
1004  int t11[F(__is_standard_layout(CppStructNonStandardByMemb))];
1005  int t12[F(__is_standard_layout(CppStructNonStandardByProt))];
1006  int t13[F(__is_standard_layout(CppStructNonStandardByVirtBase))];
1007  int t14[F(__is_standard_layout(CppStructNonStandardByBase))];
1008  int t15[F(__is_standard_layout(CppStructNonStandardByBaseAr))];
1009  int t16[F(__is_standard_layout(CppStructNonStandardBySameBase))];
1010  int t17[F(__is_standard_layout(CppStructNonStandardBy2ndVirtBase))];
1011}
1012
1013void is_signed()
1014{
1015  //int t01[T(__is_signed(char))];
1016  int t02[T(__is_signed(int))];
1017  int t03[T(__is_signed(long))];
1018  int t04[T(__is_signed(short))];
1019  int t05[T(__is_signed(signed char))];
1020  int t06[T(__is_signed(wchar_t))];
1021
1022  int t10[F(__is_signed(bool))];
1023  int t11[F(__is_signed(cvoid))];
1024  int t12[F(__is_signed(float))];
1025  int t13[F(__is_signed(double))];
1026  int t14[F(__is_signed(long double))];
1027  int t15[F(__is_signed(unsigned char))];
1028  int t16[F(__is_signed(unsigned int))];
1029  int t17[F(__is_signed(unsigned long long))];
1030  int t18[F(__is_signed(unsigned long))];
1031  int t19[F(__is_signed(unsigned short))];
1032  int t20[F(__is_signed(void))];
1033  int t21[F(__is_signed(ClassType))];
1034  int t22[F(__is_signed(Derives))];
1035  int t23[F(__is_signed(Enum))];
1036  int t24[F(__is_signed(IntArNB))];
1037  int t25[F(__is_signed(Union))];
1038  int t26[F(__is_signed(UnionAr))];
1039}
1040
1041void is_unsigned()
1042{
1043  int t01[T(__is_unsigned(bool))];
1044  int t02[T(__is_unsigned(unsigned char))];
1045  int t03[T(__is_unsigned(unsigned short))];
1046  int t04[T(__is_unsigned(unsigned int))];
1047  int t05[T(__is_unsigned(unsigned long))];
1048  int t06[T(__is_unsigned(unsigned long long))];
1049  int t07[T(__is_unsigned(Enum))];
1050
1051  int t10[F(__is_unsigned(void))];
1052  int t11[F(__is_unsigned(cvoid))];
1053  int t12[F(__is_unsigned(float))];
1054  int t13[F(__is_unsigned(double))];
1055  int t14[F(__is_unsigned(long double))];
1056  int t16[F(__is_unsigned(char))];
1057  int t17[F(__is_unsigned(signed char))];
1058  int t18[F(__is_unsigned(wchar_t))];
1059  int t19[F(__is_unsigned(short))];
1060  int t20[F(__is_unsigned(int))];
1061  int t21[F(__is_unsigned(long))];
1062  int t22[F(__is_unsigned(Union))];
1063  int t23[F(__is_unsigned(UnionAr))];
1064  int t24[F(__is_unsigned(Derives))];
1065  int t25[F(__is_unsigned(ClassType))];
1066  int t26[F(__is_unsigned(IntArNB))];
1067}
1068
1069typedef Int& IntRef;
1070typedef const IntAr ConstIntAr;
1071typedef ConstIntAr ConstIntArAr[4];
1072
1073struct HasCopy {
1074  HasCopy(HasCopy& cp);
1075};
1076
1077struct HasMove {
1078  HasMove(HasMove&& cp);
1079};
1080
1081struct HasTemplateCons {
1082  HasVirt Annoying;
1083
1084  template <typename T>
1085  HasTemplateCons(const T&);
1086};
1087
1088void has_trivial_default_constructor() {
1089  { int arr[T(__has_trivial_constructor(Int))]; }
1090  { int arr[T(__has_trivial_constructor(IntAr))]; }
1091  { int arr[T(__has_trivial_constructor(Union))]; }
1092  { int arr[T(__has_trivial_constructor(UnionAr))]; }
1093  { int arr[T(__has_trivial_constructor(POD))]; }
1094  { int arr[T(__has_trivial_constructor(Derives))]; }
1095  { int arr[T(__has_trivial_constructor(DerivesAr))]; }
1096  { int arr[T(__has_trivial_constructor(ConstIntAr))]; }
1097  { int arr[T(__has_trivial_constructor(ConstIntArAr))]; }
1098  { int arr[T(__has_trivial_constructor(HasDest))]; }
1099  { int arr[T(__has_trivial_constructor(HasPriv))]; }
1100  { int arr[T(__has_trivial_constructor(HasCopyAssign))]; }
1101  { int arr[T(__has_trivial_constructor(HasMoveAssign))]; }
1102  { int arr[T(__has_trivial_constructor(const Int))]; }
1103
1104  { int arr[F(__has_trivial_constructor(HasCons))]; }
1105  { int arr[F(__has_trivial_constructor(HasRef))]; }
1106  { int arr[F(__has_trivial_constructor(HasCopy))]; }
1107  { int arr[F(__has_trivial_constructor(IntRef))]; }
1108  { int arr[F(__has_trivial_constructor(VirtAr))]; }
1109  { int arr[F(__has_trivial_constructor(void))]; }
1110  { int arr[F(__has_trivial_constructor(cvoid))]; }
1111  { int arr[F(__has_trivial_constructor(HasTemplateCons))]; }
1112  { int arr[F(__has_trivial_constructor(AllPrivate))]; }
1113}
1114
1115void has_trivial_copy_constructor() {
1116  { int arr[T(__has_trivial_copy(Int))]; }
1117  { int arr[T(__has_trivial_copy(IntAr))]; }
1118  { int arr[T(__has_trivial_copy(Union))]; }
1119  { int arr[T(__has_trivial_copy(UnionAr))]; }
1120  { int arr[T(__has_trivial_copy(POD))]; }
1121  { int arr[T(__has_trivial_copy(Derives))]; }
1122  { int arr[T(__has_trivial_copy(ConstIntAr))]; }
1123  { int arr[T(__has_trivial_copy(ConstIntArAr))]; }
1124  { int arr[T(__has_trivial_copy(HasDest))]; }
1125  { int arr[T(__has_trivial_copy(HasPriv))]; }
1126  { int arr[T(__has_trivial_copy(HasCons))]; }
1127  { int arr[T(__has_trivial_copy(HasRef))]; }
1128  { int arr[T(__has_trivial_copy(HasMove))]; }
1129  { int arr[T(__has_trivial_copy(IntRef))]; }
1130  { int arr[T(__has_trivial_copy(HasCopyAssign))]; }
1131  { int arr[T(__has_trivial_copy(HasMoveAssign))]; }
1132  { int arr[T(__has_trivial_copy(const Int))]; }
1133
1134  { int arr[F(__has_trivial_copy(HasCopy))]; }
1135  { int arr[F(__has_trivial_copy(HasTemplateCons))]; }
1136  { int arr[F(__has_trivial_copy(DerivesAr))]; }
1137  { int arr[F(__has_trivial_copy(VirtAr))]; }
1138  { int arr[F(__has_trivial_copy(void))]; }
1139  { int arr[F(__has_trivial_copy(cvoid))]; }
1140  { int arr[F(__has_trivial_copy(AllPrivate))]; }
1141}
1142
1143void has_trivial_copy_assignment() {
1144  { int arr[T(__has_trivial_assign(Int))]; }
1145  { int arr[T(__has_trivial_assign(IntAr))]; }
1146  { int arr[T(__has_trivial_assign(Union))]; }
1147  { int arr[T(__has_trivial_assign(UnionAr))]; }
1148  { int arr[T(__has_trivial_assign(POD))]; }
1149  { int arr[T(__has_trivial_assign(Derives))]; }
1150  { int arr[T(__has_trivial_assign(HasDest))]; }
1151  { int arr[T(__has_trivial_assign(HasPriv))]; }
1152  { int arr[T(__has_trivial_assign(HasCons))]; }
1153  { int arr[T(__has_trivial_assign(HasRef))]; }
1154  { int arr[T(__has_trivial_assign(HasCopy))]; }
1155  { int arr[T(__has_trivial_assign(HasMove))]; }
1156  { int arr[T(__has_trivial_assign(HasMoveAssign))]; }
1157
1158  { int arr[F(__has_trivial_assign(IntRef))]; }
1159  { int arr[F(__has_trivial_assign(HasCopyAssign))]; }
1160  { int arr[F(__has_trivial_assign(const Int))]; }
1161  { int arr[F(__has_trivial_assign(ConstIntAr))]; }
1162  { int arr[F(__has_trivial_assign(ConstIntArAr))]; }
1163  { int arr[F(__has_trivial_assign(DerivesAr))]; }
1164  { int arr[F(__has_trivial_assign(VirtAr))]; }
1165  { int arr[F(__has_trivial_assign(void))]; }
1166  { int arr[F(__has_trivial_assign(cvoid))]; }
1167  { int arr[F(__has_trivial_assign(AllPrivate))]; }
1168}
1169
1170void has_trivial_destructor() {
1171  { int arr[T(__has_trivial_destructor(Int))]; }
1172  { int arr[T(__has_trivial_destructor(IntAr))]; }
1173  { int arr[T(__has_trivial_destructor(Union))]; }
1174  { int arr[T(__has_trivial_destructor(UnionAr))]; }
1175  { int arr[T(__has_trivial_destructor(POD))]; }
1176  { int arr[T(__has_trivial_destructor(Derives))]; }
1177  { int arr[T(__has_trivial_destructor(ConstIntAr))]; }
1178  { int arr[T(__has_trivial_destructor(ConstIntArAr))]; }
1179  { int arr[T(__has_trivial_destructor(HasPriv))]; }
1180  { int arr[T(__has_trivial_destructor(HasCons))]; }
1181  { int arr[T(__has_trivial_destructor(HasRef))]; }
1182  { int arr[T(__has_trivial_destructor(HasCopy))]; }
1183  { int arr[T(__has_trivial_destructor(HasMove))]; }
1184  { int arr[T(__has_trivial_destructor(IntRef))]; }
1185  { int arr[T(__has_trivial_destructor(HasCopyAssign))]; }
1186  { int arr[T(__has_trivial_destructor(HasMoveAssign))]; }
1187  { int arr[T(__has_trivial_destructor(const Int))]; }
1188  { int arr[T(__has_trivial_destructor(DerivesAr))]; }
1189  { int arr[T(__has_trivial_destructor(VirtAr))]; }
1190
1191  { int arr[F(__has_trivial_destructor(HasDest))]; }
1192  { int arr[F(__has_trivial_destructor(void))]; }
1193  { int arr[F(__has_trivial_destructor(cvoid))]; }
1194  { int arr[F(__has_trivial_destructor(AllPrivate))]; }
1195}
1196
1197struct A { ~A() {} };
1198template<typename> struct B : A { };
1199
1200void f() {
1201  { int arr[F(__has_trivial_destructor(A))]; }
1202  { int arr[F(__has_trivial_destructor(B<int>))]; }
1203}
1204
1205class PR11110 {
1206  template <int> int operator=( int );
1207  int operator=(PR11110);
1208};
1209
1210class UsingAssign;
1211
1212class UsingAssignBase {
1213protected:
1214  UsingAssign &operator=(const UsingAssign&) throw();
1215};
1216
1217class UsingAssign : public UsingAssignBase {
1218public:
1219  using UsingAssignBase::operator=;
1220};
1221
1222void has_nothrow_assign() {
1223  { int arr[T(__has_nothrow_assign(Int))]; }
1224  { int arr[T(__has_nothrow_assign(IntAr))]; }
1225  { int arr[T(__has_nothrow_assign(Union))]; }
1226  { int arr[T(__has_nothrow_assign(UnionAr))]; }
1227  { int arr[T(__has_nothrow_assign(POD))]; }
1228  { int arr[T(__has_nothrow_assign(Derives))]; }
1229  { int arr[T(__has_nothrow_assign(HasDest))]; }
1230  { int arr[T(__has_nothrow_assign(HasPriv))]; }
1231  { int arr[T(__has_nothrow_assign(HasCons))]; }
1232  { int arr[T(__has_nothrow_assign(HasRef))]; }
1233  { int arr[T(__has_nothrow_assign(HasCopy))]; }
1234  { int arr[T(__has_nothrow_assign(HasMove))]; }
1235  { int arr[T(__has_nothrow_assign(HasMoveAssign))]; }
1236  { int arr[T(__has_nothrow_assign(HasNoThrowCopyAssign))]; }
1237  { int arr[T(__has_nothrow_assign(HasMultipleNoThrowCopyAssign))]; }
1238  { int arr[T(__has_nothrow_assign(HasVirtDest))]; }
1239  { int arr[T(__has_nothrow_assign(AllPrivate))]; }
1240  { int arr[T(__has_nothrow_assign(UsingAssign))]; }
1241
1242  { int arr[F(__has_nothrow_assign(IntRef))]; }
1243  { int arr[F(__has_nothrow_assign(HasCopyAssign))]; }
1244  { int arr[F(__has_nothrow_assign(HasMultipleCopyAssign))]; }
1245  { int arr[F(__has_nothrow_assign(const Int))]; }
1246  { int arr[F(__has_nothrow_assign(ConstIntAr))]; }
1247  { int arr[F(__has_nothrow_assign(ConstIntArAr))]; }
1248  { int arr[F(__has_nothrow_assign(DerivesAr))]; }
1249  { int arr[F(__has_nothrow_assign(VirtAr))]; }
1250  { int arr[F(__has_nothrow_assign(void))]; }
1251  { int arr[F(__has_nothrow_assign(cvoid))]; }
1252  { int arr[F(__has_nothrow_assign(PR11110))]; }
1253}
1254
1255void has_nothrow_copy() {
1256  { int arr[T(__has_nothrow_copy(Int))]; }
1257  { int arr[T(__has_nothrow_copy(IntAr))]; }
1258  { int arr[T(__has_nothrow_copy(Union))]; }
1259  { int arr[T(__has_nothrow_copy(UnionAr))]; }
1260  { int arr[T(__has_nothrow_copy(POD))]; }
1261  { int arr[T(__has_nothrow_copy(const Int))]; }
1262  { int arr[T(__has_nothrow_copy(ConstIntAr))]; }
1263  { int arr[T(__has_nothrow_copy(ConstIntArAr))]; }
1264  { int arr[T(__has_nothrow_copy(Derives))]; }
1265  { int arr[T(__has_nothrow_copy(IntRef))]; }
1266  { int arr[T(__has_nothrow_copy(HasDest))]; }
1267  { int arr[T(__has_nothrow_copy(HasPriv))]; }
1268  { int arr[T(__has_nothrow_copy(HasCons))]; }
1269  { int arr[T(__has_nothrow_copy(HasRef))]; }
1270  { int arr[T(__has_nothrow_copy(HasMove))]; }
1271  { int arr[T(__has_nothrow_copy(HasCopyAssign))]; }
1272  { int arr[T(__has_nothrow_copy(HasMoveAssign))]; }
1273  { int arr[T(__has_nothrow_copy(HasNoThrowCopy))]; }
1274  { int arr[T(__has_nothrow_copy(HasMultipleNoThrowCopy))]; }
1275  { int arr[T(__has_nothrow_copy(HasVirtDest))]; }
1276  { int arr[T(__has_nothrow_copy(HasTemplateCons))]; }
1277  { int arr[T(__has_nothrow_copy(AllPrivate))]; }
1278
1279  { int arr[F(__has_nothrow_copy(HasCopy))]; }
1280  { int arr[F(__has_nothrow_copy(HasMultipleCopy))]; }
1281  { int arr[F(__has_nothrow_copy(DerivesAr))]; }
1282  { int arr[F(__has_nothrow_copy(VirtAr))]; }
1283  { int arr[F(__has_nothrow_copy(void))]; }
1284  { int arr[F(__has_nothrow_copy(cvoid))]; }
1285}
1286
1287template<bool b> struct assert_expr;
1288template<> struct assert_expr<true> {};
1289
1290void has_nothrow_constructor() {
1291  { int arr[T(__has_nothrow_constructor(Int))]; }
1292  { int arr[T(__has_nothrow_constructor(IntAr))]; }
1293  { int arr[T(__has_nothrow_constructor(Union))]; }
1294  { int arr[T(__has_nothrow_constructor(UnionAr))]; }
1295  { int arr[T(__has_nothrow_constructor(POD))]; }
1296  { int arr[T(__has_nothrow_constructor(Derives))]; }
1297  { int arr[T(__has_nothrow_constructor(DerivesAr))]; }
1298  { int arr[T(__has_nothrow_constructor(ConstIntAr))]; }
1299  { int arr[T(__has_nothrow_constructor(ConstIntArAr))]; }
1300  { int arr[T(__has_nothrow_constructor(HasDest))]; }
1301  { int arr[T(__has_nothrow_constructor(HasPriv))]; }
1302  { int arr[T(__has_nothrow_constructor(HasCopyAssign))]; }
1303  { int arr[T(__has_nothrow_constructor(const Int))]; }
1304  { int arr[T(__has_nothrow_constructor(HasNoThrowConstructor))]; }
1305  { int arr[T(__has_nothrow_constructor(HasVirtDest))]; }
1306  // { int arr[T(__has_nothrow_constructor(VirtAr))]; } // not implemented
1307  { int arr[T(__has_nothrow_constructor(AllPrivate))]; }
1308
1309  { int arr[F(__has_nothrow_constructor(HasCons))]; }
1310  { int arr[F(__has_nothrow_constructor(HasRef))]; }
1311  { int arr[F(__has_nothrow_constructor(HasCopy))]; }
1312  { int arr[F(__has_nothrow_constructor(HasMove))]; }
1313  { int arr[F(__has_nothrow_constructor(HasNoThrowConstructorWithArgs))]; }
1314  { int arr[F(__has_nothrow_constructor(IntRef))]; }
1315  { int arr[F(__has_nothrow_constructor(void))]; }
1316  { int arr[F(__has_nothrow_constructor(cvoid))]; }
1317  { int arr[F(__has_nothrow_constructor(HasTemplateCons))]; }
1318
1319  // While parsing an in-class initializer, the constructor is not known to be
1320  // non-throwing yet.
1321  struct HasInClassInit { int n = (assert_expr<!__has_nothrow_constructor(HasInClassInit)>(), 0); };
1322  { int arr[T(__has_nothrow_constructor(HasInClassInit))]; }
1323}
1324
1325void has_virtual_destructor() {
1326  { int arr[F(__has_virtual_destructor(Int))]; }
1327  { int arr[F(__has_virtual_destructor(IntAr))]; }
1328  { int arr[F(__has_virtual_destructor(Union))]; }
1329  { int arr[F(__has_virtual_destructor(UnionAr))]; }
1330  { int arr[F(__has_virtual_destructor(POD))]; }
1331  { int arr[F(__has_virtual_destructor(Derives))]; }
1332  { int arr[F(__has_virtual_destructor(DerivesAr))]; }
1333  { int arr[F(__has_virtual_destructor(const Int))]; }
1334  { int arr[F(__has_virtual_destructor(ConstIntAr))]; }
1335  { int arr[F(__has_virtual_destructor(ConstIntArAr))]; }
1336  { int arr[F(__has_virtual_destructor(HasDest))]; }
1337  { int arr[F(__has_virtual_destructor(HasPriv))]; }
1338  { int arr[F(__has_virtual_destructor(HasCons))]; }
1339  { int arr[F(__has_virtual_destructor(HasRef))]; }
1340  { int arr[F(__has_virtual_destructor(HasCopy))]; }
1341  { int arr[F(__has_virtual_destructor(HasMove))]; }
1342  { int arr[F(__has_virtual_destructor(HasCopyAssign))]; }
1343  { int arr[F(__has_virtual_destructor(HasMoveAssign))]; }
1344  { int arr[F(__has_virtual_destructor(IntRef))]; }
1345  { int arr[F(__has_virtual_destructor(VirtAr))]; }
1346
1347  { int arr[T(__has_virtual_destructor(HasVirtDest))]; }
1348  { int arr[T(__has_virtual_destructor(DerivedVirtDest))]; }
1349  { int arr[F(__has_virtual_destructor(VirtDestAr))]; }
1350  { int arr[F(__has_virtual_destructor(void))]; }
1351  { int arr[F(__has_virtual_destructor(cvoid))]; }
1352  { int arr[F(__has_virtual_destructor(AllPrivate))]; }
1353}
1354
1355
1356class Base {};
1357class Derived : Base {};
1358class Derived2a : Derived {};
1359class Derived2b : Derived {};
1360class Derived3 : virtual Derived2a, virtual Derived2b {};
1361template<typename T> struct BaseA { T a;  };
1362template<typename T> struct DerivedB : BaseA<T> { };
1363template<typename T> struct CrazyDerived : T { };
1364
1365
1366class class_forward; // expected-note {{forward declaration of 'class_forward'}}
1367
1368template <typename Base, typename Derived>
1369void isBaseOfT() {
1370  int t[T(__is_base_of(Base, Derived))];
1371};
1372template <typename Base, typename Derived>
1373void isBaseOfF() {
1374  int t[F(__is_base_of(Base, Derived))];
1375};
1376
1377template <class T> class DerivedTemp : Base {};
1378template <class T> class NonderivedTemp {};
1379template <class T> class UndefinedTemp; // expected-note {{declared here}}
1380
1381void is_base_of() {
1382  { int arr[T(__is_base_of(Base, Derived))]; }
1383  { int arr[T(__is_base_of(const Base, Derived))]; }
1384  { int arr[F(__is_base_of(Derived, Base))]; }
1385  { int arr[F(__is_base_of(Derived, int))]; }
1386  { int arr[T(__is_base_of(Base, Base))]; }
1387  { int arr[T(__is_base_of(Base, Derived3))]; }
1388  { int arr[T(__is_base_of(Derived, Derived3))]; }
1389  { int arr[T(__is_base_of(Derived2b, Derived3))]; }
1390  { int arr[T(__is_base_of(Derived2a, Derived3))]; }
1391  { int arr[T(__is_base_of(BaseA<int>, DerivedB<int>))]; }
1392  { int arr[F(__is_base_of(DerivedB<int>, BaseA<int>))]; }
1393  { int arr[T(__is_base_of(Base, CrazyDerived<Base>))]; }
1394  { int arr[F(__is_base_of(Union, Union))]; }
1395  { int arr[T(__is_base_of(Empty, Empty))]; }
1396  { int arr[T(__is_base_of(class_forward, class_forward))]; }
1397  { int arr[F(__is_base_of(Empty, class_forward))]; } // expected-error {{incomplete type 'class_forward' used in type trait expression}}
1398  { int arr[F(__is_base_of(Base&, Derived&))]; }
1399  int t18[F(__is_base_of(Base[10], Derived[10]))];
1400  { int arr[F(__is_base_of(int, int))]; }
1401  { int arr[F(__is_base_of(long, int))]; }
1402  { int arr[T(__is_base_of(Base, DerivedTemp<int>))]; }
1403  { int arr[F(__is_base_of(Base, NonderivedTemp<int>))]; }
1404  { int arr[F(__is_base_of(Base, UndefinedTemp<int>))]; } // expected-error {{implicit instantiation of undefined template 'UndefinedTemp<int>'}}
1405
1406  isBaseOfT<Base, Derived>();
1407  isBaseOfF<Derived, Base>();
1408
1409  isBaseOfT<Base, CrazyDerived<Base> >();
1410  isBaseOfF<CrazyDerived<Base>, Base>();
1411
1412  isBaseOfT<BaseA<int>, DerivedB<int> >();
1413  isBaseOfF<DerivedB<int>, BaseA<int> >();
1414}
1415
1416#if 0
1417template<class T, class U>
1418class TemplateClass {};
1419
1420template<class T>
1421using TemplateAlias = TemplateClass<T, int>;
1422#endif
1423
1424typedef class Base BaseTypedef;
1425
1426void is_same()
1427{
1428  int t01[T(__is_same(Base, Base))];
1429  int t02[T(__is_same(Base, BaseTypedef))];
1430#if 0
1431  int t03[T(__is_same(TemplateClass<int, int>, TemplateAlias<int>))];
1432#endif
1433
1434  int t10[F(__is_same(Base, const Base))];
1435  int t11[F(__is_same(Base, Base&))];
1436  int t12[F(__is_same(Base, Derived))];
1437}
1438
1439struct IntWrapper
1440{
1441  int value;
1442  IntWrapper(int _value) : value(_value) {}
1443  operator int() const {
1444    return value;
1445  }
1446};
1447
1448struct FloatWrapper
1449{
1450  float value;
1451  FloatWrapper(float _value) : value(_value) {}
1452  FloatWrapper(const IntWrapper& obj)
1453    : value(static_cast<float>(obj.value)) {}
1454  operator float() const {
1455    return value;
1456  }
1457  operator IntWrapper() const {
1458    return IntWrapper(static_cast<int>(value));
1459  }
1460};
1461
1462void is_convertible()
1463{
1464  int t01[T(__is_convertible(IntWrapper, IntWrapper))];
1465  int t02[T(__is_convertible(IntWrapper, const IntWrapper))];
1466  int t03[T(__is_convertible(IntWrapper, int))];
1467  int t04[T(__is_convertible(int, IntWrapper))];
1468  int t05[T(__is_convertible(IntWrapper, FloatWrapper))];
1469  int t06[T(__is_convertible(FloatWrapper, IntWrapper))];
1470  int t07[T(__is_convertible(FloatWrapper, float))];
1471  int t08[T(__is_convertible(float, FloatWrapper))];
1472}
1473
1474struct FromInt { FromInt(int); };
1475struct ToInt { operator int(); };
1476typedef void Function();
1477
1478void is_convertible_to();
1479class PrivateCopy {
1480  PrivateCopy(const PrivateCopy&);
1481  friend void is_convertible_to();
1482};
1483
1484template<typename T>
1485struct X0 {
1486  template<typename U> X0(const X0<U>&);
1487};
1488
1489void is_convertible_to() {
1490  { int arr[T(__is_convertible_to(Int, Int))]; }
1491  { int arr[F(__is_convertible_to(Int, IntAr))]; }
1492  { int arr[F(__is_convertible_to(IntAr, IntAr))]; }
1493  { int arr[T(__is_convertible_to(void, void))]; }
1494  { int arr[T(__is_convertible_to(cvoid, void))]; }
1495  { int arr[T(__is_convertible_to(void, cvoid))]; }
1496  { int arr[T(__is_convertible_to(cvoid, cvoid))]; }
1497  { int arr[T(__is_convertible_to(int, FromInt))]; }
1498  { int arr[T(__is_convertible_to(long, FromInt))]; }
1499  { int arr[T(__is_convertible_to(double, FromInt))]; }
1500  { int arr[T(__is_convertible_to(const int, FromInt))]; }
1501  { int arr[T(__is_convertible_to(const int&, FromInt))]; }
1502  { int arr[T(__is_convertible_to(ToInt, int))]; }
1503  { int arr[T(__is_convertible_to(ToInt, const int&))]; }
1504  { int arr[T(__is_convertible_to(ToInt, long))]; }
1505  { int arr[F(__is_convertible_to(ToInt, int&))]; }
1506  { int arr[F(__is_convertible_to(ToInt, FromInt))]; }
1507  { int arr[T(__is_convertible_to(IntAr&, IntAr&))]; }
1508  { int arr[T(__is_convertible_to(IntAr&, const IntAr&))]; }
1509  { int arr[F(__is_convertible_to(const IntAr&, IntAr&))]; }
1510  { int arr[F(__is_convertible_to(Function, Function))]; }
1511  { int arr[F(__is_convertible_to(PrivateCopy, PrivateCopy))]; }
1512  { int arr[T(__is_convertible_to(X0<int>, X0<float>))]; }
1513}
1514
1515void is_trivial()
1516{
1517  { int arr[T(__is_trivial(int))]; }
1518  { int arr[T(__is_trivial(Enum))]; }
1519  { int arr[T(__is_trivial(POD))]; }
1520  { int arr[T(__is_trivial(Int))]; }
1521  { int arr[T(__is_trivial(IntAr))]; }
1522  { int arr[T(__is_trivial(IntArNB))]; }
1523  { int arr[T(__is_trivial(Statics))]; }
1524  { int arr[T(__is_trivial(Empty))]; }
1525  { int arr[T(__is_trivial(EmptyUnion))]; }
1526  { int arr[T(__is_trivial(Union))]; }
1527  { int arr[T(__is_trivial(Derives))]; }
1528  { int arr[T(__is_trivial(DerivesAr))]; }
1529  { int arr[T(__is_trivial(DerivesArNB))]; }
1530  { int arr[T(__is_trivial(DerivesEmpty))]; }
1531  { int arr[T(__is_trivial(HasFunc))]; }
1532  { int arr[T(__is_trivial(HasOp))]; }
1533  { int arr[T(__is_trivial(HasConv))]; }
1534  { int arr[T(__is_trivial(HasAssign))]; }
1535  { int arr[T(__is_trivial(HasAnonymousUnion))]; }
1536  { int arr[T(__is_trivial(HasPriv))]; }
1537  { int arr[T(__is_trivial(HasProt))]; }
1538  { int arr[T(__is_trivial(DerivesHasPriv))]; }
1539  { int arr[T(__is_trivial(DerivesHasProt))]; }
1540  { int arr[T(__is_trivial(Vector))]; }
1541  { int arr[T(__is_trivial(VectorExt))]; }
1542
1543  { int arr[F(__is_trivial(HasCons))]; }
1544  { int arr[F(__is_trivial(HasCopyAssign))]; }
1545  { int arr[F(__is_trivial(HasMoveAssign))]; }
1546  { int arr[F(__is_trivial(HasDest))]; }
1547  { int arr[F(__is_trivial(HasRef))]; }
1548  { int arr[F(__is_trivial(HasNonPOD))]; }
1549  { int arr[F(__is_trivial(HasVirt))]; }
1550  { int arr[F(__is_trivial(DerivesHasCons))]; }
1551  { int arr[F(__is_trivial(DerivesHasCopyAssign))]; }
1552  { int arr[F(__is_trivial(DerivesHasMoveAssign))]; }
1553  { int arr[F(__is_trivial(DerivesHasDest))]; }
1554  { int arr[F(__is_trivial(DerivesHasRef))]; }
1555  { int arr[F(__is_trivial(DerivesHasVirt))]; }
1556  { int arr[F(__is_trivial(void))]; }
1557  { int arr[F(__is_trivial(cvoid))]; }
1558}
1559
1560void is_trivially_copyable()
1561{
1562  { int arr[T(__is_trivially_copyable(int))]; }
1563  { int arr[T(__is_trivially_copyable(Enum))]; }
1564  { int arr[T(__is_trivially_copyable(POD))]; }
1565  { int arr[T(__is_trivially_copyable(Int))]; }
1566  { int arr[T(__is_trivially_copyable(IntAr))]; }
1567  { int arr[T(__is_trivially_copyable(IntArNB))]; }
1568  { int arr[T(__is_trivially_copyable(Statics))]; }
1569  { int arr[T(__is_trivially_copyable(Empty))]; }
1570  { int arr[T(__is_trivially_copyable(EmptyUnion))]; }
1571  { int arr[T(__is_trivially_copyable(Union))]; }
1572  { int arr[T(__is_trivially_copyable(Derives))]; }
1573  { int arr[T(__is_trivially_copyable(DerivesAr))]; }
1574  { int arr[T(__is_trivially_copyable(DerivesArNB))]; }
1575  { int arr[T(__is_trivially_copyable(DerivesEmpty))]; }
1576  { int arr[T(__is_trivially_copyable(HasFunc))]; }
1577  { int arr[T(__is_trivially_copyable(HasOp))]; }
1578  { int arr[T(__is_trivially_copyable(HasConv))]; }
1579  { int arr[T(__is_trivially_copyable(HasAssign))]; }
1580  { int arr[T(__is_trivially_copyable(HasAnonymousUnion))]; }
1581  { int arr[T(__is_trivially_copyable(HasPriv))]; }
1582  { int arr[T(__is_trivially_copyable(HasProt))]; }
1583  { int arr[T(__is_trivially_copyable(DerivesHasPriv))]; }
1584  { int arr[T(__is_trivially_copyable(DerivesHasProt))]; }
1585  { int arr[T(__is_trivially_copyable(Vector))]; }
1586  { int arr[T(__is_trivially_copyable(VectorExt))]; }
1587  { int arr[T(__is_trivially_copyable(HasCons))]; }
1588  { int arr[T(__is_trivially_copyable(HasRef))]; }
1589  { int arr[T(__is_trivially_copyable(HasNonPOD))]; }
1590  { int arr[T(__is_trivially_copyable(DerivesHasCons))]; }
1591  { int arr[T(__is_trivially_copyable(DerivesHasRef))]; }
1592
1593  { int arr[F(__is_trivially_copyable(HasCopyAssign))]; }
1594  { int arr[F(__is_trivially_copyable(HasMoveAssign))]; }
1595  { int arr[F(__is_trivially_copyable(HasDest))]; }
1596  { int arr[F(__is_trivially_copyable(HasVirt))]; }
1597  { int arr[F(__is_trivially_copyable(DerivesHasCopyAssign))]; }
1598  { int arr[F(__is_trivially_copyable(DerivesHasMoveAssign))]; }
1599  { int arr[F(__is_trivially_copyable(DerivesHasDest))]; }
1600  { int arr[F(__is_trivially_copyable(DerivesHasVirt))]; }
1601  { int arr[F(__is_trivially_copyable(void))]; }
1602  { int arr[F(__is_trivially_copyable(cvoid))]; }
1603}
1604
1605void array_rank() {
1606  int t01[T(__array_rank(IntAr) == 1)];
1607  int t02[T(__array_rank(ConstIntArAr) == 2)];
1608}
1609
1610void array_extent() {
1611  int t01[T(__array_extent(IntAr, 0) == 10)];
1612  int t02[T(__array_extent(ConstIntArAr, 0) == 4)];
1613  int t03[T(__array_extent(ConstIntArAr, 1) == 10)];
1614}
1615