1 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 -fms-extensions -Wno-microsoft %s
2 #define T(b) (b) ? 1 : -1
3 #define F(b) (b) ? -1 : 1
4 
5 struct NonPOD { NonPOD(int); };
6 
7 // PODs
8 enum Enum { EV };
9 struct POD { Enum e; int i; float f; NonPOD* p; };
10 struct Empty {};
11 typedef Empty EmptyAr[10];
12 typedef int Int;
13 typedef Int IntAr[10];
14 typedef Int IntArNB[];
15 class Statics { static int priv; static NonPOD np; };
16 union EmptyUnion {};
17 union Union { int i; float f; };
18 struct HasFunc { void f (); };
19 struct HasOp { void operator *(); };
20 struct HasConv { operator int(); };
21 struct HasAssign { void operator =(int); };
22 
23 struct HasAnonymousUnion {
24   union {
25     int i;
26     float f;
27   };
28 };
29 
30 typedef int Vector __attribute__((vector_size(16)));
31 typedef int VectorExt __attribute__((ext_vector_type(4)));
32 
33 // Not PODs
34 typedef const void cvoid;
35 struct Derives : POD {};
36 typedef Derives DerivesAr[10];
37 typedef Derives DerivesArNB[];
38 struct DerivesEmpty : Empty {};
39 struct HasCons { HasCons(int); };
40 struct HasCopyAssign { HasCopyAssign operator =(const HasCopyAssign&); };
41 struct HasMoveAssign { HasMoveAssign operator =(const HasMoveAssign&&); };
42 struct HasNoThrowMoveAssign {
43   HasNoThrowMoveAssign& operator=(
44     const HasNoThrowMoveAssign&&) throw(); };
45 struct HasNoExceptNoThrowMoveAssign {
46   HasNoExceptNoThrowMoveAssign& operator=(
47     const HasNoExceptNoThrowMoveAssign&&) noexcept;
48 };
49 struct HasThrowMoveAssign {
50   HasThrowMoveAssign& operator=(
51     const HasThrowMoveAssign&&) throw(POD); };
52 struct HasNoExceptFalseMoveAssign {
53   HasNoExceptFalseMoveAssign& operator=(
54     const HasNoExceptFalseMoveAssign&&) noexcept(false); };
55 struct HasMoveCtor { HasMoveCtor(const HasMoveCtor&&); };
56 struct HasMemberMoveCtor { HasMoveCtor member; };
57 struct HasMemberMoveAssign { HasMoveAssign member; };
58 struct HasStaticMemberMoveCtor { static HasMoveCtor member; };
59 struct HasStaticMemberMoveAssign { static HasMoveAssign member; };
60 struct HasMemberThrowMoveAssign { HasThrowMoveAssign member; };
61 struct HasMemberNoExceptFalseMoveAssign {
62   HasNoExceptFalseMoveAssign member; };
63 struct HasMemberNoThrowMoveAssign { HasNoThrowMoveAssign member; };
64 struct HasMemberNoExceptNoThrowMoveAssign {
65   HasNoExceptNoThrowMoveAssign member; };
66 
67 struct HasDefaultTrivialCopyAssign {
68   HasDefaultTrivialCopyAssign &operator=(
69     const HasDefaultTrivialCopyAssign&) = default;
70 };
71 struct TrivialMoveButNotCopy {
72   TrivialMoveButNotCopy &operator=(TrivialMoveButNotCopy&&) = default;
73   TrivialMoveButNotCopy &operator=(const TrivialMoveButNotCopy&);
74 };
75 struct NonTrivialDefault {
76   NonTrivialDefault();
77 };
78 
79 struct HasDest { ~HasDest(); };
80 class  HasPriv { int priv; };
81 class  HasProt { protected: int prot; };
82 struct HasRef { int i; int& ref; HasRef() : i(0), ref(i) {} };
83 struct HasNonPOD { NonPOD np; };
84 struct HasVirt { virtual void Virt() {}; };
85 typedef NonPOD NonPODAr[10];
86 typedef HasVirt VirtAr[10];
87 typedef NonPOD NonPODArNB[];
88 union NonPODUnion { int i; Derives n; };
89 struct DerivesHasCons : HasCons {};
90 struct DerivesHasCopyAssign : HasCopyAssign {};
91 struct DerivesHasMoveAssign : HasMoveAssign {};
92 struct DerivesHasDest : HasDest {};
93 struct DerivesHasPriv : HasPriv {};
94 struct DerivesHasProt : HasProt {};
95 struct DerivesHasRef : HasRef {};
96 struct DerivesHasVirt : HasVirt {};
97 struct DerivesHasMoveCtor : HasMoveCtor {};
98 
99 struct HasNoThrowCopyAssign {
100   void operator =(const HasNoThrowCopyAssign&) throw();
101 };
102 struct HasMultipleCopyAssign {
103   void operator =(const HasMultipleCopyAssign&) throw();
104   void operator =(volatile HasMultipleCopyAssign&);
105 };
106 struct HasMultipleNoThrowCopyAssign {
107   void operator =(const HasMultipleNoThrowCopyAssign&) throw();
108   void operator =(volatile HasMultipleNoThrowCopyAssign&) throw();
109 };
110 
111 struct HasNoThrowConstructor { HasNoThrowConstructor() throw(); };
112 struct HasNoThrowConstructorWithArgs {
113   HasNoThrowConstructorWithArgs(HasCons i = HasCons(0)) throw();
114 };
115 
116 struct HasNoThrowCopy { HasNoThrowCopy(const HasNoThrowCopy&) throw(); };
117 struct HasMultipleCopy {
118   HasMultipleCopy(const HasMultipleCopy&) throw();
119   HasMultipleCopy(volatile HasMultipleCopy&);
120 };
121 struct HasMultipleNoThrowCopy {
122   HasMultipleNoThrowCopy(const HasMultipleNoThrowCopy&) throw();
123   HasMultipleNoThrowCopy(volatile HasMultipleNoThrowCopy&) throw();
124 };
125 
126 struct HasVirtDest { virtual ~HasVirtDest(); };
127 struct DerivedVirtDest : HasVirtDest {};
128 typedef HasVirtDest VirtDestAr[1];
129 
130 class AllPrivate {
131   AllPrivate() throw();
132   AllPrivate(const AllPrivate&) throw();
133   AllPrivate &operator=(const AllPrivate &) throw();
134   ~AllPrivate() throw();
135 };
136 
137 struct ThreeArgCtor {
138   ThreeArgCtor(int*, char*, int);
139 };
140 
141 void is_pod()
142 {
143   { int arr[T(__is_pod(int))]; }
144   { int arr[T(__is_pod(Enum))]; }
145   { int arr[T(__is_pod(POD))]; }
146   { int arr[T(__is_pod(Int))]; }
147   { int arr[T(__is_pod(IntAr))]; }
148   { int arr[T(__is_pod(Statics))]; }
149   { int arr[T(__is_pod(Empty))]; }
150   { int arr[T(__is_pod(EmptyUnion))]; }
151   { int arr[T(__is_pod(Union))]; }
152   { int arr[T(__is_pod(HasFunc))]; }
153   { int arr[T(__is_pod(HasOp))]; }
154   { int arr[T(__is_pod(HasConv))]; }
155   { int arr[T(__is_pod(HasAssign))]; }
156   { int arr[T(__is_pod(IntArNB))]; }
157   { int arr[T(__is_pod(HasAnonymousUnion))]; }
158   { int arr[T(__is_pod(Vector))]; }
159   { int arr[T(__is_pod(VectorExt))]; }
160   { int arr[T(__is_pod(Derives))]; }
161   { int arr[T(__is_pod(DerivesAr))]; }
162   { int arr[T(__is_pod(DerivesArNB))]; }
163   { int arr[T(__is_pod(DerivesEmpty))]; }
164   { int arr[T(__is_pod(HasPriv))]; }
165   { int arr[T(__is_pod(HasProt))]; }
166   { int arr[T(__is_pod(DerivesHasPriv))]; }
167   { int arr[T(__is_pod(DerivesHasProt))]; }
168 
169   { int arr[F(__is_pod(HasCons))]; }
170   { int arr[F(__is_pod(HasCopyAssign))]; }
171   { int arr[F(__is_pod(HasMoveAssign))]; }
172   { int arr[F(__is_pod(HasDest))]; }
173   { int arr[F(__is_pod(HasRef))]; }
174   { int arr[F(__is_pod(HasVirt))]; }
175   { int arr[F(__is_pod(DerivesHasCons))]; }
176   { int arr[F(__is_pod(DerivesHasCopyAssign))]; }
177   { int arr[F(__is_pod(DerivesHasMoveAssign))]; }
178   { int arr[F(__is_pod(DerivesHasDest))]; }
179   { int arr[F(__is_pod(DerivesHasRef))]; }
180   { int arr[F(__is_pod(DerivesHasVirt))]; }
181   { int arr[F(__is_pod(NonPOD))]; }
182   { int arr[F(__is_pod(HasNonPOD))]; }
183   { int arr[F(__is_pod(NonPODAr))]; }
184   { int arr[F(__is_pod(NonPODArNB))]; }
185   { int arr[F(__is_pod(void))]; }
186   { int arr[F(__is_pod(cvoid))]; }
187 // { int arr[F(__is_pod(NonPODUnion))]; }
188 }
189 
190 typedef Empty EmptyAr[10];
191 struct Bit0 { int : 0; };
192 struct Bit0Cons { int : 0; Bit0Cons(); };
193 struct BitOnly { int x : 3; };
194 struct DerivesVirt : virtual POD {};
195 
196 void is_empty()
197 {
198   { int arr[T(__is_empty(Empty))]; }
199   { int arr[T(__is_empty(DerivesEmpty))]; }
200   { int arr[T(__is_empty(HasCons))]; }
201   { int arr[T(__is_empty(HasCopyAssign))]; }
202   { int arr[T(__is_empty(HasMoveAssign))]; }
203   { int arr[T(__is_empty(HasDest))]; }
204   { int arr[T(__is_empty(HasFunc))]; }
205   { int arr[T(__is_empty(HasOp))]; }
206   { int arr[T(__is_empty(HasConv))]; }
207   { int arr[T(__is_empty(HasAssign))]; }
208   { int arr[T(__is_empty(Bit0))]; }
209   { int arr[T(__is_empty(Bit0Cons))]; }
210 
211   { int arr[F(__is_empty(Int))]; }
212   { int arr[F(__is_empty(POD))]; }
213   { int arr[F(__is_empty(EmptyUnion))]; }
214   { int arr[F(__is_empty(EmptyAr))]; }
215   { int arr[F(__is_empty(HasRef))]; }
216   { int arr[F(__is_empty(HasVirt))]; }
217   { int arr[F(__is_empty(BitOnly))]; }
218   { int arr[F(__is_empty(void))]; }
219   { int arr[F(__is_empty(IntArNB))]; }
220   { int arr[F(__is_empty(HasAnonymousUnion))]; }
221 //  { int arr[F(__is_empty(DerivesVirt))]; }
222 }
223 
224 typedef Derives ClassType;
225 
226 void is_class()
227 {
228   { int arr[T(__is_class(Derives))]; }
229   { int arr[T(__is_class(HasPriv))]; }
230   { int arr[T(__is_class(ClassType))]; }
231   { int arr[T(__is_class(HasAnonymousUnion))]; }
232 
233   { int arr[F(__is_class(int))]; }
234   { int arr[F(__is_class(Enum))]; }
235   { int arr[F(__is_class(Int))]; }
236   { int arr[F(__is_class(IntAr))]; }
237   { int arr[F(__is_class(DerivesAr))]; }
238   { int arr[F(__is_class(Union))]; }
239   { int arr[F(__is_class(cvoid))]; }
240   { int arr[F(__is_class(IntArNB))]; }
241 }
242 
243 typedef Union UnionAr[10];
244 typedef Union UnionType;
245 
246 void is_union()
247 {
248   { int arr[T(__is_union(Union))]; }
249   { int arr[T(__is_union(UnionType))]; }
250 
251   { int arr[F(__is_union(int))]; }
252   { int arr[F(__is_union(Enum))]; }
253   { int arr[F(__is_union(Int))]; }
254   { int arr[F(__is_union(IntAr))]; }
255   { int arr[F(__is_union(UnionAr))]; }
256   { int arr[F(__is_union(cvoid))]; }
257   { int arr[F(__is_union(IntArNB))]; }
258   { int arr[F(__is_union(HasAnonymousUnion))]; }
259 }
260 
261 typedef Enum EnumType;
262 
263 void is_enum()
264 {
265   { int arr[T(__is_enum(Enum))]; }
266   { int arr[T(__is_enum(EnumType))]; }
267 
268   { int arr[F(__is_enum(int))]; }
269   { int arr[F(__is_enum(Union))]; }
270   { int arr[F(__is_enum(Int))]; }
271   { int arr[F(__is_enum(IntAr))]; }
272   { int arr[F(__is_enum(UnionAr))]; }
273   { int arr[F(__is_enum(Derives))]; }
274   { int arr[F(__is_enum(ClassType))]; }
275   { int arr[F(__is_enum(cvoid))]; }
276   { int arr[F(__is_enum(IntArNB))]; }
277   { int arr[F(__is_enum(HasAnonymousUnion))]; }
278 }
279 
280 struct FinalClass final {
281 };
282 
283 template<typename T>
284 struct PotentiallyFinal { };
285 
286 template<typename T>
287 struct PotentiallyFinal<T*> final { };
288 
289 template<>
290 struct PotentiallyFinal<int> final { };
291 
292 void is_final()
293 {
294 	{ int arr[T(__is_final(FinalClass))]; }
295 	{ int arr[T(__is_final(PotentiallyFinal<float*>))]; }
296 	{ int arr[T(__is_final(PotentiallyFinal<int>))]; }
297 
298 	{ int arr[F(__is_final(int))]; }
299 	{ int arr[F(__is_final(Union))]; }
300 	{ int arr[F(__is_final(Int))]; }
301 	{ int arr[F(__is_final(IntAr))]; }
302 	{ int arr[F(__is_final(UnionAr))]; }
303 	{ int arr[F(__is_final(Derives))]; }
304 	{ int arr[F(__is_final(ClassType))]; }
305 	{ int arr[F(__is_final(cvoid))]; }
306 	{ int arr[F(__is_final(IntArNB))]; }
307 	{ int arr[F(__is_final(HasAnonymousUnion))]; }
308 	{ int arr[F(__is_final(PotentiallyFinal<float>))]; }
309 }
310 
311 struct SealedClass sealed {
312 };
313 
314 template<typename T>
315 struct PotentiallySealed { };
316 
317 template<typename T>
318 struct PotentiallySealed<T*> sealed { };
319 
320 template<>
321 struct PotentiallySealed<int> sealed { };
322 
323 void is_sealed()
324 {
325 	{ int arr[T(__is_sealed(SealedClass))]; }
326 	{ int arr[T(__is_sealed(PotentiallySealed<float*>))]; }
327 	{ int arr[T(__is_sealed(PotentiallySealed<int>))]; }
328 
329 	{ int arr[F(__is_sealed(int))]; }
330 	{ int arr[F(__is_sealed(Union))]; }
331 	{ int arr[F(__is_sealed(Int))]; }
332 	{ int arr[F(__is_sealed(IntAr))]; }
333 	{ int arr[F(__is_sealed(UnionAr))]; }
334 	{ int arr[F(__is_sealed(Derives))]; }
335 	{ int arr[F(__is_sealed(ClassType))]; }
336 	{ int arr[F(__is_sealed(cvoid))]; }
337 	{ int arr[F(__is_sealed(IntArNB))]; }
338 	{ int arr[F(__is_sealed(HasAnonymousUnion))]; }
339 	{ int arr[F(__is_sealed(PotentiallyFinal<float>))]; }
340 }
341 
342 typedef HasVirt Polymorph;
343 struct InheritPolymorph : Polymorph {};
344 
345 void is_polymorphic()
346 {
347   { int arr[T(__is_polymorphic(Polymorph))]; }
348   { int arr[T(__is_polymorphic(InheritPolymorph))]; }
349 
350   { int arr[F(__is_polymorphic(int))]; }
351   { int arr[F(__is_polymorphic(Union))]; }
352   { int arr[F(__is_polymorphic(Int))]; }
353   { int arr[F(__is_polymorphic(IntAr))]; }
354   { int arr[F(__is_polymorphic(UnionAr))]; }
355   { int arr[F(__is_polymorphic(Derives))]; }
356   { int arr[F(__is_polymorphic(ClassType))]; }
357   { int arr[F(__is_polymorphic(Enum))]; }
358   { int arr[F(__is_polymorphic(cvoid))]; }
359   { int arr[F(__is_polymorphic(IntArNB))]; }
360 }
361 
362 void is_integral()
363 {
364   int t01[T(__is_integral(bool))];
365   int t02[T(__is_integral(char))];
366   int t03[T(__is_integral(signed char))];
367   int t04[T(__is_integral(unsigned char))];
368   //int t05[T(__is_integral(char16_t))];
369   //int t06[T(__is_integral(char32_t))];
370   int t07[T(__is_integral(wchar_t))];
371   int t08[T(__is_integral(short))];
372   int t09[T(__is_integral(unsigned short))];
373   int t10[T(__is_integral(int))];
374   int t11[T(__is_integral(unsigned int))];
375   int t12[T(__is_integral(long))];
376   int t13[T(__is_integral(unsigned long))];
377 
378   int t21[F(__is_integral(float))];
379   int t22[F(__is_integral(double))];
380   int t23[F(__is_integral(long double))];
381   int t24[F(__is_integral(Union))];
382   int t25[F(__is_integral(UnionAr))];
383   int t26[F(__is_integral(Derives))];
384   int t27[F(__is_integral(ClassType))];
385   int t28[F(__is_integral(Enum))];
386   int t29[F(__is_integral(void))];
387   int t30[F(__is_integral(cvoid))];
388   int t31[F(__is_integral(IntArNB))];
389 }
390 
391 void is_floating_point()
392 {
393   int t01[T(__is_floating_point(float))];
394   int t02[T(__is_floating_point(double))];
395   int t03[T(__is_floating_point(long double))];
396 
397   int t11[F(__is_floating_point(bool))];
398   int t12[F(__is_floating_point(char))];
399   int t13[F(__is_floating_point(signed char))];
400   int t14[F(__is_floating_point(unsigned char))];
401   //int t15[F(__is_floating_point(char16_t))];
402   //int t16[F(__is_floating_point(char32_t))];
403   int t17[F(__is_floating_point(wchar_t))];
404   int t18[F(__is_floating_point(short))];
405   int t19[F(__is_floating_point(unsigned short))];
406   int t20[F(__is_floating_point(int))];
407   int t21[F(__is_floating_point(unsigned int))];
408   int t22[F(__is_floating_point(long))];
409   int t23[F(__is_floating_point(unsigned long))];
410   int t24[F(__is_floating_point(Union))];
411   int t25[F(__is_floating_point(UnionAr))];
412   int t26[F(__is_floating_point(Derives))];
413   int t27[F(__is_floating_point(ClassType))];
414   int t28[F(__is_floating_point(Enum))];
415   int t29[F(__is_floating_point(void))];
416   int t30[F(__is_floating_point(cvoid))];
417   int t31[F(__is_floating_point(IntArNB))];
418 }
419 
420 void is_arithmetic()
421 {
422   int t01[T(__is_arithmetic(float))];
423   int t02[T(__is_arithmetic(double))];
424   int t03[T(__is_arithmetic(long double))];
425   int t11[T(__is_arithmetic(bool))];
426   int t12[T(__is_arithmetic(char))];
427   int t13[T(__is_arithmetic(signed char))];
428   int t14[T(__is_arithmetic(unsigned char))];
429   //int t15[T(__is_arithmetic(char16_t))];
430   //int t16[T(__is_arithmetic(char32_t))];
431   int t17[T(__is_arithmetic(wchar_t))];
432   int t18[T(__is_arithmetic(short))];
433   int t19[T(__is_arithmetic(unsigned short))];
434   int t20[T(__is_arithmetic(int))];
435   int t21[T(__is_arithmetic(unsigned int))];
436   int t22[T(__is_arithmetic(long))];
437   int t23[T(__is_arithmetic(unsigned long))];
438 
439   int t24[F(__is_arithmetic(Union))];
440   int t25[F(__is_arithmetic(UnionAr))];
441   int t26[F(__is_arithmetic(Derives))];
442   int t27[F(__is_arithmetic(ClassType))];
443   int t28[F(__is_arithmetic(Enum))];
444   int t29[F(__is_arithmetic(void))];
445   int t30[F(__is_arithmetic(cvoid))];
446   int t31[F(__is_arithmetic(IntArNB))];
447 }
448 
449 struct ACompleteType {};
450 struct AnIncompleteType;
451 
452 void is_complete_type()
453 {
454   int t01[T(__is_complete_type(float))];
455   int t02[T(__is_complete_type(double))];
456   int t03[T(__is_complete_type(long double))];
457   int t11[T(__is_complete_type(bool))];
458   int t12[T(__is_complete_type(char))];
459   int t13[T(__is_complete_type(signed char))];
460   int t14[T(__is_complete_type(unsigned char))];
461   //int t15[T(__is_complete_type(char16_t))];
462   //int t16[T(__is_complete_type(char32_t))];
463   int t17[T(__is_complete_type(wchar_t))];
464   int t18[T(__is_complete_type(short))];
465   int t19[T(__is_complete_type(unsigned short))];
466   int t20[T(__is_complete_type(int))];
467   int t21[T(__is_complete_type(unsigned int))];
468   int t22[T(__is_complete_type(long))];
469   int t23[T(__is_complete_type(unsigned long))];
470   int t24[T(__is_complete_type(ACompleteType))];
471 
472   int t30[F(__is_complete_type(AnIncompleteType))];
473 }
474 
475 void is_void()
476 {
477   int t01[T(__is_void(void))];
478   int t02[T(__is_void(cvoid))];
479 
480   int t10[F(__is_void(float))];
481   int t11[F(__is_void(double))];
482   int t12[F(__is_void(long double))];
483   int t13[F(__is_void(bool))];
484   int t14[F(__is_void(char))];
485   int t15[F(__is_void(signed char))];
486   int t16[F(__is_void(unsigned char))];
487   int t17[F(__is_void(wchar_t))];
488   int t18[F(__is_void(short))];
489   int t19[F(__is_void(unsigned short))];
490   int t20[F(__is_void(int))];
491   int t21[F(__is_void(unsigned int))];
492   int t22[F(__is_void(long))];
493   int t23[F(__is_void(unsigned long))];
494   int t24[F(__is_void(Union))];
495   int t25[F(__is_void(UnionAr))];
496   int t26[F(__is_void(Derives))];
497   int t27[F(__is_void(ClassType))];
498   int t28[F(__is_void(Enum))];
499   int t29[F(__is_void(IntArNB))];
500   int t30[F(__is_void(void*))];
501   int t31[F(__is_void(cvoid*))];
502 }
503 
504 void is_array()
505 {
506   int t01[T(__is_array(IntAr))];
507   int t02[T(__is_array(IntArNB))];
508   int t03[T(__is_array(UnionAr))];
509 
510   int t10[F(__is_array(void))];
511   int t11[F(__is_array(cvoid))];
512   int t12[F(__is_array(float))];
513   int t13[F(__is_array(double))];
514   int t14[F(__is_array(long double))];
515   int t15[F(__is_array(bool))];
516   int t16[F(__is_array(char))];
517   int t17[F(__is_array(signed char))];
518   int t18[F(__is_array(unsigned char))];
519   int t19[F(__is_array(wchar_t))];
520   int t20[F(__is_array(short))];
521   int t21[F(__is_array(unsigned short))];
522   int t22[F(__is_array(int))];
523   int t23[F(__is_array(unsigned int))];
524   int t24[F(__is_array(long))];
525   int t25[F(__is_array(unsigned long))];
526   int t26[F(__is_array(Union))];
527   int t27[F(__is_array(Derives))];
528   int t28[F(__is_array(ClassType))];
529   int t29[F(__is_array(Enum))];
530   int t30[F(__is_array(void*))];
531   int t31[F(__is_array(cvoid*))];
532 }
533 
534 template <typename T> void tmpl_func(T&) {}
535 
536 template <typename T> struct type_wrapper {
537   typedef T type;
538   typedef T* ptrtype;
539   typedef T& reftype;
540 };
541 
542 void is_function()
543 {
544   int t01[T(__is_function(type_wrapper<void(void)>::type))];
545   int t02[T(__is_function(typeof(tmpl_func<int>)))];
546 
547   typedef void (*ptr_to_func_type)(void);
548 
549   int t10[F(__is_function(void))];
550   int t11[F(__is_function(cvoid))];
551   int t12[F(__is_function(float))];
552   int t13[F(__is_function(double))];
553   int t14[F(__is_function(long double))];
554   int t15[F(__is_function(bool))];
555   int t16[F(__is_function(char))];
556   int t17[F(__is_function(signed char))];
557   int t18[F(__is_function(unsigned char))];
558   int t19[F(__is_function(wchar_t))];
559   int t20[F(__is_function(short))];
560   int t21[F(__is_function(unsigned short))];
561   int t22[F(__is_function(int))];
562   int t23[F(__is_function(unsigned int))];
563   int t24[F(__is_function(long))];
564   int t25[F(__is_function(unsigned long))];
565   int t26[F(__is_function(Union))];
566   int t27[F(__is_function(Derives))];
567   int t28[F(__is_function(ClassType))];
568   int t29[F(__is_function(Enum))];
569   int t30[F(__is_function(void*))];
570   int t31[F(__is_function(cvoid*))];
571   int t32[F(__is_function(void(*)()))];
572   int t33[F(__is_function(ptr_to_func_type))];
573   int t34[F(__is_function(type_wrapper<void(void)>::ptrtype))];
574   int t35[F(__is_function(type_wrapper<void(void)>::reftype))];
575 }
576 
577 void is_reference()
578 {
579   int t01[T(__is_reference(int&))];
580   int t02[T(__is_reference(const int&))];
581   int t03[T(__is_reference(void *&))];
582 
583   int t10[F(__is_reference(int))];
584   int t11[F(__is_reference(const int))];
585   int t12[F(__is_reference(void *))];
586 }
587 
588 void is_lvalue_reference()
589 {
590   int t01[T(__is_lvalue_reference(int&))];
591   int t02[T(__is_lvalue_reference(void *&))];
592   int t03[T(__is_lvalue_reference(const int&))];
593   int t04[T(__is_lvalue_reference(void * const &))];
594 
595   int t10[F(__is_lvalue_reference(int))];
596   int t11[F(__is_lvalue_reference(const int))];
597   int t12[F(__is_lvalue_reference(void *))];
598 }
599 
600 #if __has_feature(cxx_rvalue_references)
601 
602 void is_rvalue_reference()
603 {
604   int t01[T(__is_rvalue_reference(const int&&))];
605   int t02[T(__is_rvalue_reference(void * const &&))];
606 
607   int t10[F(__is_rvalue_reference(int&))];
608   int t11[F(__is_rvalue_reference(void *&))];
609   int t12[F(__is_rvalue_reference(const int&))];
610   int t13[F(__is_rvalue_reference(void * const &))];
611   int t14[F(__is_rvalue_reference(int))];
612   int t15[F(__is_rvalue_reference(const int))];
613   int t16[F(__is_rvalue_reference(void *))];
614 }
615 
616 #endif
617 
618 void is_fundamental()
619 {
620   int t01[T(__is_fundamental(float))];
621   int t02[T(__is_fundamental(double))];
622   int t03[T(__is_fundamental(long double))];
623   int t11[T(__is_fundamental(bool))];
624   int t12[T(__is_fundamental(char))];
625   int t13[T(__is_fundamental(signed char))];
626   int t14[T(__is_fundamental(unsigned char))];
627   //int t15[T(__is_fundamental(char16_t))];
628   //int t16[T(__is_fundamental(char32_t))];
629   int t17[T(__is_fundamental(wchar_t))];
630   int t18[T(__is_fundamental(short))];
631   int t19[T(__is_fundamental(unsigned short))];
632   int t20[T(__is_fundamental(int))];
633   int t21[T(__is_fundamental(unsigned int))];
634   int t22[T(__is_fundamental(long))];
635   int t23[T(__is_fundamental(unsigned long))];
636   int t24[T(__is_fundamental(void))];
637   int t25[T(__is_fundamental(cvoid))];
638 
639   int t30[F(__is_fundamental(Union))];
640   int t31[F(__is_fundamental(UnionAr))];
641   int t32[F(__is_fundamental(Derives))];
642   int t33[F(__is_fundamental(ClassType))];
643   int t34[F(__is_fundamental(Enum))];
644   int t35[F(__is_fundamental(IntArNB))];
645 }
646 
647 void is_object()
648 {
649   int t01[T(__is_object(int))];
650   int t02[T(__is_object(int *))];
651   int t03[T(__is_object(void *))];
652   int t04[T(__is_object(Union))];
653   int t05[T(__is_object(UnionAr))];
654   int t06[T(__is_object(ClassType))];
655   int t07[T(__is_object(Enum))];
656 
657   int t10[F(__is_object(type_wrapper<void(void)>::type))];
658   int t11[F(__is_object(int&))];
659   int t12[F(__is_object(void))];
660 }
661 
662 void is_scalar()
663 {
664   int t01[T(__is_scalar(float))];
665   int t02[T(__is_scalar(double))];
666   int t03[T(__is_scalar(long double))];
667   int t04[T(__is_scalar(bool))];
668   int t05[T(__is_scalar(char))];
669   int t06[T(__is_scalar(signed char))];
670   int t07[T(__is_scalar(unsigned char))];
671   int t08[T(__is_scalar(wchar_t))];
672   int t09[T(__is_scalar(short))];
673   int t10[T(__is_scalar(unsigned short))];
674   int t11[T(__is_scalar(int))];
675   int t12[T(__is_scalar(unsigned int))];
676   int t13[T(__is_scalar(long))];
677   int t14[T(__is_scalar(unsigned long))];
678   int t15[T(__is_scalar(Enum))];
679   int t16[T(__is_scalar(void*))];
680   int t17[T(__is_scalar(cvoid*))];
681 
682   int t20[F(__is_scalar(void))];
683   int t21[F(__is_scalar(cvoid))];
684   int t22[F(__is_scalar(Union))];
685   int t23[F(__is_scalar(UnionAr))];
686   int t24[F(__is_scalar(Derives))];
687   int t25[F(__is_scalar(ClassType))];
688   int t26[F(__is_scalar(IntArNB))];
689 }
690 
691 struct StructWithMembers {
692   int member;
693   void method() {}
694 };
695 
696 void is_compound()
697 {
698   int t01[T(__is_compound(void*))];
699   int t02[T(__is_compound(cvoid*))];
700   int t03[T(__is_compound(void (*)()))];
701   int t04[T(__is_compound(int StructWithMembers::*))];
702   int t05[T(__is_compound(void (StructWithMembers::*)()))];
703   int t06[T(__is_compound(int&))];
704   int t07[T(__is_compound(Union))];
705   int t08[T(__is_compound(UnionAr))];
706   int t09[T(__is_compound(Derives))];
707   int t10[T(__is_compound(ClassType))];
708   int t11[T(__is_compound(IntArNB))];
709   int t12[T(__is_compound(Enum))];
710 
711   int t20[F(__is_compound(float))];
712   int t21[F(__is_compound(double))];
713   int t22[F(__is_compound(long double))];
714   int t23[F(__is_compound(bool))];
715   int t24[F(__is_compound(char))];
716   int t25[F(__is_compound(signed char))];
717   int t26[F(__is_compound(unsigned char))];
718   int t27[F(__is_compound(wchar_t))];
719   int t28[F(__is_compound(short))];
720   int t29[F(__is_compound(unsigned short))];
721   int t30[F(__is_compound(int))];
722   int t31[F(__is_compound(unsigned int))];
723   int t32[F(__is_compound(long))];
724   int t33[F(__is_compound(unsigned long))];
725   int t34[F(__is_compound(void))];
726   int t35[F(__is_compound(cvoid))];
727 }
728 
729 void is_pointer()
730 {
731   StructWithMembers x;
732 
733   int t01[T(__is_pointer(void*))];
734   int t02[T(__is_pointer(cvoid*))];
735   int t03[T(__is_pointer(cvoid*))];
736   int t04[T(__is_pointer(char*))];
737   int t05[T(__is_pointer(int*))];
738   int t06[T(__is_pointer(int**))];
739   int t07[T(__is_pointer(ClassType*))];
740   int t08[T(__is_pointer(Derives*))];
741   int t09[T(__is_pointer(Enum*))];
742   int t10[T(__is_pointer(IntArNB*))];
743   int t11[T(__is_pointer(Union*))];
744   int t12[T(__is_pointer(UnionAr*))];
745   int t13[T(__is_pointer(StructWithMembers*))];
746   int t14[T(__is_pointer(void (*)()))];
747 
748   int t20[F(__is_pointer(void))];
749   int t21[F(__is_pointer(cvoid))];
750   int t22[F(__is_pointer(cvoid))];
751   int t23[F(__is_pointer(char))];
752   int t24[F(__is_pointer(int))];
753   int t25[F(__is_pointer(int))];
754   int t26[F(__is_pointer(ClassType))];
755   int t27[F(__is_pointer(Derives))];
756   int t28[F(__is_pointer(Enum))];
757   int t29[F(__is_pointer(IntArNB))];
758   int t30[F(__is_pointer(Union))];
759   int t31[F(__is_pointer(UnionAr))];
760   int t32[F(__is_pointer(StructWithMembers))];
761   int t33[F(__is_pointer(int StructWithMembers::*))];
762   int t34[F(__is_pointer(void (StructWithMembers::*) ()))];
763 }
764 
765 void is_member_object_pointer()
766 {
767   StructWithMembers x;
768 
769   int t01[T(__is_member_object_pointer(int StructWithMembers::*))];
770 
771   int t10[F(__is_member_object_pointer(void (StructWithMembers::*) ()))];
772   int t11[F(__is_member_object_pointer(void*))];
773   int t12[F(__is_member_object_pointer(cvoid*))];
774   int t13[F(__is_member_object_pointer(cvoid*))];
775   int t14[F(__is_member_object_pointer(char*))];
776   int t15[F(__is_member_object_pointer(int*))];
777   int t16[F(__is_member_object_pointer(int**))];
778   int t17[F(__is_member_object_pointer(ClassType*))];
779   int t18[F(__is_member_object_pointer(Derives*))];
780   int t19[F(__is_member_object_pointer(Enum*))];
781   int t20[F(__is_member_object_pointer(IntArNB*))];
782   int t21[F(__is_member_object_pointer(Union*))];
783   int t22[F(__is_member_object_pointer(UnionAr*))];
784   int t23[F(__is_member_object_pointer(StructWithMembers*))];
785   int t24[F(__is_member_object_pointer(void))];
786   int t25[F(__is_member_object_pointer(cvoid))];
787   int t26[F(__is_member_object_pointer(cvoid))];
788   int t27[F(__is_member_object_pointer(char))];
789   int t28[F(__is_member_object_pointer(int))];
790   int t29[F(__is_member_object_pointer(int))];
791   int t30[F(__is_member_object_pointer(ClassType))];
792   int t31[F(__is_member_object_pointer(Derives))];
793   int t32[F(__is_member_object_pointer(Enum))];
794   int t33[F(__is_member_object_pointer(IntArNB))];
795   int t34[F(__is_member_object_pointer(Union))];
796   int t35[F(__is_member_object_pointer(UnionAr))];
797   int t36[F(__is_member_object_pointer(StructWithMembers))];
798   int t37[F(__is_member_object_pointer(void (*)()))];
799 }
800 
801 void is_member_function_pointer()
802 {
803   StructWithMembers x;
804 
805   int t01[T(__is_member_function_pointer(void (StructWithMembers::*) ()))];
806 
807   int t10[F(__is_member_function_pointer(int StructWithMembers::*))];
808   int t11[F(__is_member_function_pointer(void*))];
809   int t12[F(__is_member_function_pointer(cvoid*))];
810   int t13[F(__is_member_function_pointer(cvoid*))];
811   int t14[F(__is_member_function_pointer(char*))];
812   int t15[F(__is_member_function_pointer(int*))];
813   int t16[F(__is_member_function_pointer(int**))];
814   int t17[F(__is_member_function_pointer(ClassType*))];
815   int t18[F(__is_member_function_pointer(Derives*))];
816   int t19[F(__is_member_function_pointer(Enum*))];
817   int t20[F(__is_member_function_pointer(IntArNB*))];
818   int t21[F(__is_member_function_pointer(Union*))];
819   int t22[F(__is_member_function_pointer(UnionAr*))];
820   int t23[F(__is_member_function_pointer(StructWithMembers*))];
821   int t24[F(__is_member_function_pointer(void))];
822   int t25[F(__is_member_function_pointer(cvoid))];
823   int t26[F(__is_member_function_pointer(cvoid))];
824   int t27[F(__is_member_function_pointer(char))];
825   int t28[F(__is_member_function_pointer(int))];
826   int t29[F(__is_member_function_pointer(int))];
827   int t30[F(__is_member_function_pointer(ClassType))];
828   int t31[F(__is_member_function_pointer(Derives))];
829   int t32[F(__is_member_function_pointer(Enum))];
830   int t33[F(__is_member_function_pointer(IntArNB))];
831   int t34[F(__is_member_function_pointer(Union))];
832   int t35[F(__is_member_function_pointer(UnionAr))];
833   int t36[F(__is_member_function_pointer(StructWithMembers))];
834   int t37[F(__is_member_function_pointer(void (*)()))];
835 }
836 
837 void is_member_pointer()
838 {
839   StructWithMembers x;
840 
841   int t01[T(__is_member_pointer(int StructWithMembers::*))];
842   int t02[T(__is_member_pointer(void (StructWithMembers::*) ()))];
843 
844   int t10[F(__is_member_pointer(void*))];
845   int t11[F(__is_member_pointer(cvoid*))];
846   int t12[F(__is_member_pointer(cvoid*))];
847   int t13[F(__is_member_pointer(char*))];
848   int t14[F(__is_member_pointer(int*))];
849   int t15[F(__is_member_pointer(int**))];
850   int t16[F(__is_member_pointer(ClassType*))];
851   int t17[F(__is_member_pointer(Derives*))];
852   int t18[F(__is_member_pointer(Enum*))];
853   int t19[F(__is_member_pointer(IntArNB*))];
854   int t20[F(__is_member_pointer(Union*))];
855   int t21[F(__is_member_pointer(UnionAr*))];
856   int t22[F(__is_member_pointer(StructWithMembers*))];
857   int t23[F(__is_member_pointer(void))];
858   int t24[F(__is_member_pointer(cvoid))];
859   int t25[F(__is_member_pointer(cvoid))];
860   int t26[F(__is_member_pointer(char))];
861   int t27[F(__is_member_pointer(int))];
862   int t28[F(__is_member_pointer(int))];
863   int t29[F(__is_member_pointer(ClassType))];
864   int t30[F(__is_member_pointer(Derives))];
865   int t31[F(__is_member_pointer(Enum))];
866   int t32[F(__is_member_pointer(IntArNB))];
867   int t33[F(__is_member_pointer(Union))];
868   int t34[F(__is_member_pointer(UnionAr))];
869   int t35[F(__is_member_pointer(StructWithMembers))];
870   int t36[F(__is_member_pointer(void (*)()))];
871 }
872 
873 void is_const()
874 {
875   int t01[T(__is_const(cvoid))];
876   int t02[T(__is_const(const char))];
877   int t03[T(__is_const(const int))];
878   int t04[T(__is_const(const long))];
879   int t05[T(__is_const(const short))];
880   int t06[T(__is_const(const signed char))];
881   int t07[T(__is_const(const wchar_t))];
882   int t08[T(__is_const(const bool))];
883   int t09[T(__is_const(const float))];
884   int t10[T(__is_const(const double))];
885   int t11[T(__is_const(const long double))];
886   int t12[T(__is_const(const unsigned char))];
887   int t13[T(__is_const(const unsigned int))];
888   int t14[T(__is_const(const unsigned long long))];
889   int t15[T(__is_const(const unsigned long))];
890   int t16[T(__is_const(const unsigned short))];
891   int t17[T(__is_const(const void))];
892   int t18[T(__is_const(const ClassType))];
893   int t19[T(__is_const(const Derives))];
894   int t20[T(__is_const(const Enum))];
895   int t21[T(__is_const(const IntArNB))];
896   int t22[T(__is_const(const Union))];
897   int t23[T(__is_const(const UnionAr))];
898 
899   int t30[F(__is_const(char))];
900   int t31[F(__is_const(int))];
901   int t32[F(__is_const(long))];
902   int t33[F(__is_const(short))];
903   int t34[F(__is_const(signed char))];
904   int t35[F(__is_const(wchar_t))];
905   int t36[F(__is_const(bool))];
906   int t37[F(__is_const(float))];
907   int t38[F(__is_const(double))];
908   int t39[F(__is_const(long double))];
909   int t40[F(__is_const(unsigned char))];
910   int t41[F(__is_const(unsigned int))];
911   int t42[F(__is_const(unsigned long long))];
912   int t43[F(__is_const(unsigned long))];
913   int t44[F(__is_const(unsigned short))];
914   int t45[F(__is_const(void))];
915   int t46[F(__is_const(ClassType))];
916   int t47[F(__is_const(Derives))];
917   int t48[F(__is_const(Enum))];
918   int t49[F(__is_const(IntArNB))];
919   int t50[F(__is_const(Union))];
920   int t51[F(__is_const(UnionAr))];
921 }
922 
923 void is_volatile()
924 {
925   int t02[T(__is_volatile(volatile char))];
926   int t03[T(__is_volatile(volatile int))];
927   int t04[T(__is_volatile(volatile long))];
928   int t05[T(__is_volatile(volatile short))];
929   int t06[T(__is_volatile(volatile signed char))];
930   int t07[T(__is_volatile(volatile wchar_t))];
931   int t08[T(__is_volatile(volatile bool))];
932   int t09[T(__is_volatile(volatile float))];
933   int t10[T(__is_volatile(volatile double))];
934   int t11[T(__is_volatile(volatile long double))];
935   int t12[T(__is_volatile(volatile unsigned char))];
936   int t13[T(__is_volatile(volatile unsigned int))];
937   int t14[T(__is_volatile(volatile unsigned long long))];
938   int t15[T(__is_volatile(volatile unsigned long))];
939   int t16[T(__is_volatile(volatile unsigned short))];
940   int t17[T(__is_volatile(volatile void))];
941   int t18[T(__is_volatile(volatile ClassType))];
942   int t19[T(__is_volatile(volatile Derives))];
943   int t20[T(__is_volatile(volatile Enum))];
944   int t21[T(__is_volatile(volatile IntArNB))];
945   int t22[T(__is_volatile(volatile Union))];
946   int t23[T(__is_volatile(volatile UnionAr))];
947 
948   int t30[F(__is_volatile(char))];
949   int t31[F(__is_volatile(int))];
950   int t32[F(__is_volatile(long))];
951   int t33[F(__is_volatile(short))];
952   int t34[F(__is_volatile(signed char))];
953   int t35[F(__is_volatile(wchar_t))];
954   int t36[F(__is_volatile(bool))];
955   int t37[F(__is_volatile(float))];
956   int t38[F(__is_volatile(double))];
957   int t39[F(__is_volatile(long double))];
958   int t40[F(__is_volatile(unsigned char))];
959   int t41[F(__is_volatile(unsigned int))];
960   int t42[F(__is_volatile(unsigned long long))];
961   int t43[F(__is_volatile(unsigned long))];
962   int t44[F(__is_volatile(unsigned short))];
963   int t45[F(__is_volatile(void))];
964   int t46[F(__is_volatile(ClassType))];
965   int t47[F(__is_volatile(Derives))];
966   int t48[F(__is_volatile(Enum))];
967   int t49[F(__is_volatile(IntArNB))];
968   int t50[F(__is_volatile(Union))];
969   int t51[F(__is_volatile(UnionAr))];
970 }
971 
972 struct TrivialStruct {
973   int member;
974 };
975 
976 struct NonTrivialStruct {
977   int member;
978   NonTrivialStruct() {
979     member = 0;
980   }
981 };
982 
983 struct SuperNonTrivialStruct {
984   SuperNonTrivialStruct() { }
985   ~SuperNonTrivialStruct() { }
986 };
987 
988 struct NonTCStruct {
989   NonTCStruct(const NonTCStruct&) {}
990 };
991 
992 struct AllDefaulted {
993   AllDefaulted() = default;
994   AllDefaulted(const AllDefaulted &) = default;
995   AllDefaulted(AllDefaulted &&) = default;
996   AllDefaulted &operator=(const AllDefaulted &) = default;
997   AllDefaulted &operator=(AllDefaulted &&) = default;
998   ~AllDefaulted() = default;
999 };
1000 
1001 struct NoDefaultMoveAssignDueToUDCopyCtor {
1002   NoDefaultMoveAssignDueToUDCopyCtor(const NoDefaultMoveAssignDueToUDCopyCtor&);
1003 };
1004 
1005 struct NoDefaultMoveAssignDueToUDCopyAssign {
1006   NoDefaultMoveAssignDueToUDCopyAssign& operator=(
1007     const NoDefaultMoveAssignDueToUDCopyAssign&);
1008 };
1009 
1010 struct NoDefaultMoveAssignDueToDtor {
1011   ~NoDefaultMoveAssignDueToDtor();
1012 };
1013 
1014 struct AllDeleted {
1015   AllDeleted() = delete;
1016   AllDeleted(const AllDeleted &) = delete;
1017   AllDeleted(AllDeleted &&) = delete;
1018   AllDeleted &operator=(const AllDeleted &) = delete;
1019   AllDeleted &operator=(AllDeleted &&) = delete;
1020   ~AllDeleted() = delete;
1021 };
1022 
1023 struct ExtDefaulted {
1024   ExtDefaulted();
1025   ExtDefaulted(const ExtDefaulted &);
1026   ExtDefaulted(ExtDefaulted &&);
1027   ExtDefaulted &operator=(const ExtDefaulted &);
1028   ExtDefaulted &operator=(ExtDefaulted &&);
1029   ~ExtDefaulted();
1030 };
1031 
1032 // Despite being defaulted, these functions are not trivial.
1033 ExtDefaulted::ExtDefaulted() = default;
1034 ExtDefaulted::ExtDefaulted(const ExtDefaulted &) = default;
1035 ExtDefaulted::ExtDefaulted(ExtDefaulted &&) = default;
1036 ExtDefaulted &ExtDefaulted::operator=(const ExtDefaulted &) = default;
1037 ExtDefaulted &ExtDefaulted::operator=(ExtDefaulted &&) = default;
1038 ExtDefaulted::~ExtDefaulted() = default;
1039 
1040 void is_trivial2()
1041 {
1042   int t01[T(__is_trivial(char))];
1043   int t02[T(__is_trivial(int))];
1044   int t03[T(__is_trivial(long))];
1045   int t04[T(__is_trivial(short))];
1046   int t05[T(__is_trivial(signed char))];
1047   int t06[T(__is_trivial(wchar_t))];
1048   int t07[T(__is_trivial(bool))];
1049   int t08[T(__is_trivial(float))];
1050   int t09[T(__is_trivial(double))];
1051   int t10[T(__is_trivial(long double))];
1052   int t11[T(__is_trivial(unsigned char))];
1053   int t12[T(__is_trivial(unsigned int))];
1054   int t13[T(__is_trivial(unsigned long long))];
1055   int t14[T(__is_trivial(unsigned long))];
1056   int t15[T(__is_trivial(unsigned short))];
1057   int t16[T(__is_trivial(ClassType))];
1058   int t17[T(__is_trivial(Derives))];
1059   int t18[T(__is_trivial(Enum))];
1060   int t19[T(__is_trivial(IntAr))];
1061   int t20[T(__is_trivial(Union))];
1062   int t21[T(__is_trivial(UnionAr))];
1063   int t22[T(__is_trivial(TrivialStruct))];
1064   int t23[T(__is_trivial(AllDefaulted))];
1065   int t24[T(__is_trivial(AllDeleted))];
1066 
1067   int t30[F(__is_trivial(void))];
1068   int t31[F(__is_trivial(NonTrivialStruct))];
1069   int t32[F(__is_trivial(SuperNonTrivialStruct))];
1070   int t33[F(__is_trivial(NonTCStruct))];
1071   int t34[F(__is_trivial(ExtDefaulted))];
1072 }
1073 
1074 void is_trivially_copyable2()
1075 {
1076   int t01[T(__is_trivially_copyable(char))];
1077   int t02[T(__is_trivially_copyable(int))];
1078   int t03[T(__is_trivially_copyable(long))];
1079   int t04[T(__is_trivially_copyable(short))];
1080   int t05[T(__is_trivially_copyable(signed char))];
1081   int t06[T(__is_trivially_copyable(wchar_t))];
1082   int t07[T(__is_trivially_copyable(bool))];
1083   int t08[T(__is_trivially_copyable(float))];
1084   int t09[T(__is_trivially_copyable(double))];
1085   int t10[T(__is_trivially_copyable(long double))];
1086   int t11[T(__is_trivially_copyable(unsigned char))];
1087   int t12[T(__is_trivially_copyable(unsigned int))];
1088   int t13[T(__is_trivially_copyable(unsigned long long))];
1089   int t14[T(__is_trivially_copyable(unsigned long))];
1090   int t15[T(__is_trivially_copyable(unsigned short))];
1091   int t16[T(__is_trivially_copyable(ClassType))];
1092   int t17[T(__is_trivially_copyable(Derives))];
1093   int t18[T(__is_trivially_copyable(Enum))];
1094   int t19[T(__is_trivially_copyable(IntAr))];
1095   int t20[T(__is_trivially_copyable(Union))];
1096   int t21[T(__is_trivially_copyable(UnionAr))];
1097   int t22[T(__is_trivially_copyable(TrivialStruct))];
1098   int t23[T(__is_trivially_copyable(NonTrivialStruct))];
1099   int t24[T(__is_trivially_copyable(AllDefaulted))];
1100   int t25[T(__is_trivially_copyable(AllDeleted))];
1101 
1102   int t30[F(__is_trivially_copyable(void))];
1103   int t31[F(__is_trivially_copyable(SuperNonTrivialStruct))];
1104   int t32[F(__is_trivially_copyable(NonTCStruct))];
1105   int t33[F(__is_trivially_copyable(ExtDefaulted))];
1106 
1107   int t34[T(__is_trivially_copyable(const int))];
1108   int t35[F(__is_trivially_copyable(volatile int))];
1109 }
1110 
1111 struct CStruct {
1112   int one;
1113   int two;
1114 };
1115 
1116 struct CEmptyStruct {};
1117 
1118 struct CppEmptyStruct : CStruct {};
1119 struct CppStructStandard : CEmptyStruct {
1120   int three;
1121   int four;
1122 };
1123 struct CppStructNonStandardByBase : CStruct {
1124   int three;
1125   int four;
1126 };
1127 struct CppStructNonStandardByVirt : CStruct {
1128   virtual void method() {}
1129 };
1130 struct CppStructNonStandardByMemb : CStruct {
1131   CppStructNonStandardByVirt member;
1132 };
1133 struct CppStructNonStandardByProt : CStruct {
1134   int five;
1135 protected:
1136   int six;
1137 };
1138 struct CppStructNonStandardByVirtBase : virtual CStruct {
1139 };
1140 struct CppStructNonStandardBySameBase : CEmptyStruct {
1141   CEmptyStruct member;
1142 };
1143 struct CppStructNonStandardBy2ndVirtBase : CEmptyStruct {
1144   CEmptyStruct member;
1145 };
1146 
1147 void is_standard_layout()
1148 {
1149   typedef const int ConstInt;
1150   typedef ConstInt ConstIntAr[4];
1151   typedef CppStructStandard CppStructStandardAr[4];
1152 
1153   int t01[T(__is_standard_layout(int))];
1154   int t02[T(__is_standard_layout(ConstInt))];
1155   int t03[T(__is_standard_layout(ConstIntAr))];
1156   int t04[T(__is_standard_layout(CStruct))];
1157   int t05[T(__is_standard_layout(CppStructStandard))];
1158   int t06[T(__is_standard_layout(CppStructStandardAr))];
1159   int t07[T(__is_standard_layout(Vector))];
1160   int t08[T(__is_standard_layout(VectorExt))];
1161 
1162   typedef CppStructNonStandardByBase CppStructNonStandardByBaseAr[4];
1163 
1164   int t10[F(__is_standard_layout(CppStructNonStandardByVirt))];
1165   int t11[F(__is_standard_layout(CppStructNonStandardByMemb))];
1166   int t12[F(__is_standard_layout(CppStructNonStandardByProt))];
1167   int t13[F(__is_standard_layout(CppStructNonStandardByVirtBase))];
1168   int t14[F(__is_standard_layout(CppStructNonStandardByBase))];
1169   int t15[F(__is_standard_layout(CppStructNonStandardByBaseAr))];
1170   int t16[F(__is_standard_layout(CppStructNonStandardBySameBase))];
1171   int t17[F(__is_standard_layout(CppStructNonStandardBy2ndVirtBase))];
1172 }
1173 
1174 void is_signed()
1175 {
1176   //int t01[T(__is_signed(char))];
1177   int t02[T(__is_signed(int))];
1178   int t03[T(__is_signed(long))];
1179   int t04[T(__is_signed(short))];
1180   int t05[T(__is_signed(signed char))];
1181   int t06[T(__is_signed(wchar_t))];
1182 
1183   int t10[F(__is_signed(bool))];
1184   int t11[F(__is_signed(cvoid))];
1185   int t12[F(__is_signed(float))];
1186   int t13[F(__is_signed(double))];
1187   int t14[F(__is_signed(long double))];
1188   int t15[F(__is_signed(unsigned char))];
1189   int t16[F(__is_signed(unsigned int))];
1190   int t17[F(__is_signed(unsigned long long))];
1191   int t18[F(__is_signed(unsigned long))];
1192   int t19[F(__is_signed(unsigned short))];
1193   int t20[F(__is_signed(void))];
1194   int t21[F(__is_signed(ClassType))];
1195   int t22[F(__is_signed(Derives))];
1196   int t23[F(__is_signed(Enum))];
1197   int t24[F(__is_signed(IntArNB))];
1198   int t25[F(__is_signed(Union))];
1199   int t26[F(__is_signed(UnionAr))];
1200 }
1201 
1202 void is_unsigned()
1203 {
1204   int t01[T(__is_unsigned(bool))];
1205   int t02[T(__is_unsigned(unsigned char))];
1206   int t03[T(__is_unsigned(unsigned short))];
1207   int t04[T(__is_unsigned(unsigned int))];
1208   int t05[T(__is_unsigned(unsigned long))];
1209   int t06[T(__is_unsigned(unsigned long long))];
1210   int t07[T(__is_unsigned(Enum))];
1211 
1212   int t10[F(__is_unsigned(void))];
1213   int t11[F(__is_unsigned(cvoid))];
1214   int t12[F(__is_unsigned(float))];
1215   int t13[F(__is_unsigned(double))];
1216   int t14[F(__is_unsigned(long double))];
1217   int t16[F(__is_unsigned(char))];
1218   int t17[F(__is_unsigned(signed char))];
1219   int t18[F(__is_unsigned(wchar_t))];
1220   int t19[F(__is_unsigned(short))];
1221   int t20[F(__is_unsigned(int))];
1222   int t21[F(__is_unsigned(long))];
1223   int t22[F(__is_unsigned(Union))];
1224   int t23[F(__is_unsigned(UnionAr))];
1225   int t24[F(__is_unsigned(Derives))];
1226   int t25[F(__is_unsigned(ClassType))];
1227   int t26[F(__is_unsigned(IntArNB))];
1228 }
1229 
1230 typedef Int& IntRef;
1231 typedef const IntAr ConstIntAr;
1232 typedef ConstIntAr ConstIntArAr[4];
1233 
1234 struct HasCopy {
1235   HasCopy(HasCopy& cp);
1236 };
1237 
1238 struct HasMove {
1239   HasMove(HasMove&& cp);
1240 };
1241 
1242 struct HasTemplateCons {
1243   HasVirt Annoying;
1244 
1245   template <typename T>
1246   HasTemplateCons(const T&);
1247 };
1248 
1249 void has_trivial_default_constructor() {
1250   { int arr[T(__has_trivial_constructor(Int))]; }
1251   { int arr[T(__has_trivial_constructor(IntAr))]; }
1252   { int arr[T(__has_trivial_constructor(Union))]; }
1253   { int arr[T(__has_trivial_constructor(UnionAr))]; }
1254   { int arr[T(__has_trivial_constructor(POD))]; }
1255   { int arr[T(__has_trivial_constructor(Derives))]; }
1256   { int arr[T(__has_trivial_constructor(DerivesAr))]; }
1257   { int arr[T(__has_trivial_constructor(ConstIntAr))]; }
1258   { int arr[T(__has_trivial_constructor(ConstIntArAr))]; }
1259   { int arr[T(__has_trivial_constructor(HasDest))]; }
1260   { int arr[T(__has_trivial_constructor(HasPriv))]; }
1261   { int arr[T(__has_trivial_constructor(HasCopyAssign))]; }
1262   { int arr[T(__has_trivial_constructor(HasMoveAssign))]; }
1263   { int arr[T(__has_trivial_constructor(const Int))]; }
1264   { int arr[T(__has_trivial_constructor(AllDefaulted))]; }
1265   { int arr[T(__has_trivial_constructor(AllDeleted))]; }
1266 
1267   { int arr[F(__has_trivial_constructor(HasCons))]; }
1268   { int arr[F(__has_trivial_constructor(HasRef))]; }
1269   { int arr[F(__has_trivial_constructor(HasCopy))]; }
1270   { int arr[F(__has_trivial_constructor(IntRef))]; }
1271   { int arr[F(__has_trivial_constructor(VirtAr))]; }
1272   { int arr[F(__has_trivial_constructor(void))]; }
1273   { int arr[F(__has_trivial_constructor(cvoid))]; }
1274   { int arr[F(__has_trivial_constructor(HasTemplateCons))]; }
1275   { int arr[F(__has_trivial_constructor(AllPrivate))]; }
1276   { int arr[F(__has_trivial_constructor(ExtDefaulted))]; }
1277 }
1278 
1279 void has_trivial_move_constructor() {
1280   // n3376 12.8 [class.copy]/12
1281   // A copy/move constructor for class X is trivial if it is not
1282   // user-provided, its declared parameter type is the same as
1283   // if it had been implicitly declared, and if
1284   //   - class X has no virtual functions (10.3) and no virtual
1285   //     base classes (10.1), and
1286   //   - the constructor selected to copy/move each direct base
1287   //     class subobject is trivial, and
1288   //   - for each non-static data member of X that is of class
1289   //     type (or array thereof), the constructor selected
1290   //     to copy/move that member is trivial;
1291   // otherwise the copy/move constructor is non-trivial.
1292   { int arr[T(__has_trivial_move_constructor(POD))]; }
1293   { int arr[T(__has_trivial_move_constructor(Union))]; }
1294   { int arr[T(__has_trivial_move_constructor(HasCons))]; }
1295   { int arr[T(__has_trivial_move_constructor(HasStaticMemberMoveCtor))]; }
1296   { int arr[T(__has_trivial_move_constructor(AllDeleted))]; }
1297 
1298   { int arr[F(__has_trivial_move_constructor(HasVirt))]; }
1299   { int arr[F(__has_trivial_move_constructor(DerivesVirt))]; }
1300   { int arr[F(__has_trivial_move_constructor(HasMoveCtor))]; }
1301   { int arr[F(__has_trivial_move_constructor(DerivesHasMoveCtor))]; }
1302   { int arr[F(__has_trivial_move_constructor(HasMemberMoveCtor))]; }
1303 }
1304 
1305 void has_trivial_copy_constructor() {
1306   { int arr[T(__has_trivial_copy(Int))]; }
1307   { int arr[T(__has_trivial_copy(IntAr))]; }
1308   { int arr[T(__has_trivial_copy(Union))]; }
1309   { int arr[T(__has_trivial_copy(UnionAr))]; }
1310   { int arr[T(__has_trivial_copy(POD))]; }
1311   { int arr[T(__has_trivial_copy(Derives))]; }
1312   { int arr[T(__has_trivial_copy(ConstIntAr))]; }
1313   { int arr[T(__has_trivial_copy(ConstIntArAr))]; }
1314   { int arr[T(__has_trivial_copy(HasDest))]; }
1315   { int arr[T(__has_trivial_copy(HasPriv))]; }
1316   { int arr[T(__has_trivial_copy(HasCons))]; }
1317   { int arr[T(__has_trivial_copy(HasRef))]; }
1318   { int arr[T(__has_trivial_copy(HasMove))]; }
1319   { int arr[T(__has_trivial_copy(IntRef))]; }
1320   { int arr[T(__has_trivial_copy(HasCopyAssign))]; }
1321   { int arr[T(__has_trivial_copy(HasMoveAssign))]; }
1322   { int arr[T(__has_trivial_copy(const Int))]; }
1323   { int arr[T(__has_trivial_copy(AllDefaulted))]; }
1324   { int arr[T(__has_trivial_copy(AllDeleted))]; }
1325   { int arr[T(__has_trivial_copy(DerivesAr))]; }
1326   { int arr[T(__has_trivial_copy(DerivesHasRef))]; }
1327 
1328   { int arr[F(__has_trivial_copy(HasCopy))]; }
1329   { int arr[F(__has_trivial_copy(HasTemplateCons))]; }
1330   { int arr[F(__has_trivial_copy(VirtAr))]; }
1331   { int arr[F(__has_trivial_copy(void))]; }
1332   { int arr[F(__has_trivial_copy(cvoid))]; }
1333   { int arr[F(__has_trivial_copy(AllPrivate))]; }
1334   { int arr[F(__has_trivial_copy(ExtDefaulted))]; }
1335 }
1336 
1337 void has_trivial_copy_assignment() {
1338   { int arr[T(__has_trivial_assign(Int))]; }
1339   { int arr[T(__has_trivial_assign(IntAr))]; }
1340   { int arr[T(__has_trivial_assign(Union))]; }
1341   { int arr[T(__has_trivial_assign(UnionAr))]; }
1342   { int arr[T(__has_trivial_assign(POD))]; }
1343   { int arr[T(__has_trivial_assign(Derives))]; }
1344   { int arr[T(__has_trivial_assign(HasDest))]; }
1345   { int arr[T(__has_trivial_assign(HasPriv))]; }
1346   { int arr[T(__has_trivial_assign(HasCons))]; }
1347   { int arr[T(__has_trivial_assign(HasRef))]; }
1348   { int arr[T(__has_trivial_assign(HasCopy))]; }
1349   { int arr[T(__has_trivial_assign(HasMove))]; }
1350   { int arr[T(__has_trivial_assign(HasMoveAssign))]; }
1351   { int arr[T(__has_trivial_assign(AllDefaulted))]; }
1352   { int arr[T(__has_trivial_assign(AllDeleted))]; }
1353   { int arr[T(__has_trivial_assign(DerivesAr))]; }
1354   { int arr[T(__has_trivial_assign(DerivesHasRef))]; }
1355 
1356   { int arr[F(__has_trivial_assign(IntRef))]; }
1357   { int arr[F(__has_trivial_assign(HasCopyAssign))]; }
1358   { int arr[F(__has_trivial_assign(const Int))]; }
1359   { int arr[F(__has_trivial_assign(ConstIntAr))]; }
1360   { int arr[F(__has_trivial_assign(ConstIntArAr))]; }
1361   { int arr[F(__has_trivial_assign(VirtAr))]; }
1362   { int arr[F(__has_trivial_assign(void))]; }
1363   { int arr[F(__has_trivial_assign(cvoid))]; }
1364   { int arr[F(__has_trivial_assign(AllPrivate))]; }
1365   { int arr[F(__has_trivial_assign(ExtDefaulted))]; }
1366 }
1367 
1368 void has_trivial_destructor() {
1369   { int arr[T(__has_trivial_destructor(Int))]; }
1370   { int arr[T(__has_trivial_destructor(IntAr))]; }
1371   { int arr[T(__has_trivial_destructor(Union))]; }
1372   { int arr[T(__has_trivial_destructor(UnionAr))]; }
1373   { int arr[T(__has_trivial_destructor(POD))]; }
1374   { int arr[T(__has_trivial_destructor(Derives))]; }
1375   { int arr[T(__has_trivial_destructor(ConstIntAr))]; }
1376   { int arr[T(__has_trivial_destructor(ConstIntArAr))]; }
1377   { int arr[T(__has_trivial_destructor(HasPriv))]; }
1378   { int arr[T(__has_trivial_destructor(HasCons))]; }
1379   { int arr[T(__has_trivial_destructor(HasRef))]; }
1380   { int arr[T(__has_trivial_destructor(HasCopy))]; }
1381   { int arr[T(__has_trivial_destructor(HasMove))]; }
1382   { int arr[T(__has_trivial_destructor(IntRef))]; }
1383   { int arr[T(__has_trivial_destructor(HasCopyAssign))]; }
1384   { int arr[T(__has_trivial_destructor(HasMoveAssign))]; }
1385   { int arr[T(__has_trivial_destructor(const Int))]; }
1386   { int arr[T(__has_trivial_destructor(DerivesAr))]; }
1387   { int arr[T(__has_trivial_destructor(VirtAr))]; }
1388   { int arr[T(__has_trivial_destructor(AllDefaulted))]; }
1389   { int arr[T(__has_trivial_destructor(AllDeleted))]; }
1390   { int arr[T(__has_trivial_destructor(DerivesHasRef))]; }
1391 
1392   { int arr[F(__has_trivial_destructor(HasDest))]; }
1393   { int arr[F(__has_trivial_destructor(void))]; }
1394   { int arr[F(__has_trivial_destructor(cvoid))]; }
1395   { int arr[F(__has_trivial_destructor(AllPrivate))]; }
1396   { int arr[F(__has_trivial_destructor(ExtDefaulted))]; }
1397 }
1398 
1399 struct A { ~A() {} };
1400 template<typename> struct B : A { };
1401 
1402 void f() {
1403   { int arr[F(__has_trivial_destructor(A))]; }
1404   { int arr[F(__has_trivial_destructor(B<int>))]; }
1405 }
1406 
1407 class PR11110 {
1408   template <int> int operator=( int );
1409   int operator=(PR11110);
1410 };
1411 
1412 class UsingAssign;
1413 
1414 class UsingAssignBase {
1415 protected:
1416   UsingAssign &operator=(const UsingAssign&) throw();
1417 };
1418 
1419 class UsingAssign : public UsingAssignBase {
1420 public:
1421   using UsingAssignBase::operator=;
1422 };
1423 
1424 void has_nothrow_assign() {
1425   { int arr[T(__has_nothrow_assign(Int))]; }
1426   { int arr[T(__has_nothrow_assign(IntAr))]; }
1427   { int arr[T(__has_nothrow_assign(Union))]; }
1428   { int arr[T(__has_nothrow_assign(UnionAr))]; }
1429   { int arr[T(__has_nothrow_assign(POD))]; }
1430   { int arr[T(__has_nothrow_assign(Derives))]; }
1431   { int arr[T(__has_nothrow_assign(HasDest))]; }
1432   { int arr[T(__has_nothrow_assign(HasPriv))]; }
1433   { int arr[T(__has_nothrow_assign(HasCons))]; }
1434   { int arr[T(__has_nothrow_assign(HasRef))]; }
1435   { int arr[T(__has_nothrow_assign(HasCopy))]; }
1436   { int arr[T(__has_nothrow_assign(HasMove))]; }
1437   { int arr[T(__has_nothrow_assign(HasMoveAssign))]; }
1438   { int arr[T(__has_nothrow_assign(HasNoThrowCopyAssign))]; }
1439   { int arr[T(__has_nothrow_assign(HasMultipleNoThrowCopyAssign))]; }
1440   { int arr[T(__has_nothrow_assign(HasVirtDest))]; }
1441   { int arr[T(__has_nothrow_assign(AllPrivate))]; }
1442   { int arr[T(__has_nothrow_assign(UsingAssign))]; }
1443   { int arr[T(__has_nothrow_assign(DerivesAr))]; }
1444 
1445   { int arr[F(__has_nothrow_assign(IntRef))]; }
1446   { int arr[F(__has_nothrow_assign(HasCopyAssign))]; }
1447   { int arr[F(__has_nothrow_assign(HasMultipleCopyAssign))]; }
1448   { int arr[F(__has_nothrow_assign(const Int))]; }
1449   { int arr[F(__has_nothrow_assign(ConstIntAr))]; }
1450   { int arr[F(__has_nothrow_assign(ConstIntArAr))]; }
1451   { int arr[F(__has_nothrow_assign(VirtAr))]; }
1452   { int arr[F(__has_nothrow_assign(void))]; }
1453   { int arr[F(__has_nothrow_assign(cvoid))]; }
1454   { int arr[F(__has_nothrow_assign(PR11110))]; }
1455 }
1456 
1457 void has_nothrow_move_assign() {
1458   { int arr[T(__has_nothrow_move_assign(Int))]; }
1459   { int arr[T(__has_nothrow_move_assign(Enum))]; }
1460   { int arr[T(__has_nothrow_move_assign(Int*))]; }
1461   { int arr[T(__has_nothrow_move_assign(Enum POD::*))]; }
1462   { int arr[T(__has_nothrow_move_assign(POD))]; }
1463   { int arr[T(__has_nothrow_move_assign(HasPriv))]; }
1464   { int arr[T(__has_nothrow_move_assign(HasNoThrowMoveAssign))]; }
1465   { int arr[T(__has_nothrow_move_assign(HasNoExceptNoThrowMoveAssign))]; }
1466   { int arr[T(__has_nothrow_move_assign(HasMemberNoThrowMoveAssign))]; }
1467   { int arr[T(__has_nothrow_move_assign(HasMemberNoExceptNoThrowMoveAssign))]; }
1468   { int arr[T(__has_nothrow_move_assign(AllDeleted))]; }
1469 
1470 
1471   { int arr[F(__has_nothrow_move_assign(HasThrowMoveAssign))]; }
1472   { int arr[F(__has_nothrow_move_assign(HasNoExceptFalseMoveAssign))]; }
1473   { int arr[F(__has_nothrow_move_assign(HasMemberThrowMoveAssign))]; }
1474   { int arr[F(__has_nothrow_move_assign(HasMemberNoExceptFalseMoveAssign))]; }
1475   { int arr[F(__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyCtor))]; }
1476   { int arr[F(__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyAssign))]; }
1477   { int arr[F(__has_nothrow_move_assign(NoDefaultMoveAssignDueToDtor))]; }
1478 }
1479 
1480 void has_trivial_move_assign() {
1481   // n3376 12.8 [class.copy]/25
1482   // A copy/move assignment operator for class X is trivial if it
1483   // is not user-provided, its declared parameter type is the same
1484   // as if it had been implicitly declared, and if:
1485   //  - class X has no virtual functions (10.3) and no virtual base
1486   //    classes (10.1), and
1487   //  - the assignment operator selected to copy/move each direct
1488   //    base class subobject is trivial, and
1489   //  - for each non-static data member of X that is of class type
1490   //    (or array thereof), the assignment operator
1491   //    selected to copy/move that member is trivial;
1492   { int arr[T(__has_trivial_move_assign(Int))]; }
1493   { int arr[T(__has_trivial_move_assign(HasStaticMemberMoveAssign))]; }
1494   { int arr[T(__has_trivial_move_assign(AllDeleted))]; }
1495 
1496   { int arr[F(__has_trivial_move_assign(HasVirt))]; }
1497   { int arr[F(__has_trivial_move_assign(DerivesVirt))]; }
1498   { int arr[F(__has_trivial_move_assign(HasMoveAssign))]; }
1499   { int arr[F(__has_trivial_move_assign(DerivesHasMoveAssign))]; }
1500   { int arr[F(__has_trivial_move_assign(HasMemberMoveAssign))]; }
1501   { int arr[F(__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyCtor))]; }
1502   { int arr[F(__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyAssign))]; }
1503 }
1504 
1505 void has_nothrow_copy() {
1506   { int arr[T(__has_nothrow_copy(Int))]; }
1507   { int arr[T(__has_nothrow_copy(IntAr))]; }
1508   { int arr[T(__has_nothrow_copy(Union))]; }
1509   { int arr[T(__has_nothrow_copy(UnionAr))]; }
1510   { int arr[T(__has_nothrow_copy(POD))]; }
1511   { int arr[T(__has_nothrow_copy(const Int))]; }
1512   { int arr[T(__has_nothrow_copy(ConstIntAr))]; }
1513   { int arr[T(__has_nothrow_copy(ConstIntArAr))]; }
1514   { int arr[T(__has_nothrow_copy(Derives))]; }
1515   { int arr[T(__has_nothrow_copy(IntRef))]; }
1516   { int arr[T(__has_nothrow_copy(HasDest))]; }
1517   { int arr[T(__has_nothrow_copy(HasPriv))]; }
1518   { int arr[T(__has_nothrow_copy(HasCons))]; }
1519   { int arr[T(__has_nothrow_copy(HasRef))]; }
1520   { int arr[T(__has_nothrow_copy(HasMove))]; }
1521   { int arr[T(__has_nothrow_copy(HasCopyAssign))]; }
1522   { int arr[T(__has_nothrow_copy(HasMoveAssign))]; }
1523   { int arr[T(__has_nothrow_copy(HasNoThrowCopy))]; }
1524   { int arr[T(__has_nothrow_copy(HasMultipleNoThrowCopy))]; }
1525   { int arr[T(__has_nothrow_copy(HasVirtDest))]; }
1526   { int arr[T(__has_nothrow_copy(HasTemplateCons))]; }
1527   { int arr[T(__has_nothrow_copy(AllPrivate))]; }
1528   { int arr[T(__has_nothrow_copy(DerivesAr))]; }
1529 
1530   { int arr[F(__has_nothrow_copy(HasCopy))]; }
1531   { int arr[F(__has_nothrow_copy(HasMultipleCopy))]; }
1532   { int arr[F(__has_nothrow_copy(VirtAr))]; }
1533   { int arr[F(__has_nothrow_copy(void))]; }
1534   { int arr[F(__has_nothrow_copy(cvoid))]; }
1535 }
1536 
1537 void has_nothrow_constructor() {
1538   { int arr[T(__has_nothrow_constructor(Int))]; }
1539   { int arr[T(__has_nothrow_constructor(IntAr))]; }
1540   { int arr[T(__has_nothrow_constructor(Union))]; }
1541   { int arr[T(__has_nothrow_constructor(UnionAr))]; }
1542   { int arr[T(__has_nothrow_constructor(POD))]; }
1543   { int arr[T(__has_nothrow_constructor(Derives))]; }
1544   { int arr[T(__has_nothrow_constructor(DerivesAr))]; }
1545   { int arr[T(__has_nothrow_constructor(ConstIntAr))]; }
1546   { int arr[T(__has_nothrow_constructor(ConstIntArAr))]; }
1547   { int arr[T(__has_nothrow_constructor(HasDest))]; }
1548   { int arr[T(__has_nothrow_constructor(HasPriv))]; }
1549   { int arr[T(__has_nothrow_constructor(HasCopyAssign))]; }
1550   { int arr[T(__has_nothrow_constructor(const Int))]; }
1551   { int arr[T(__has_nothrow_constructor(HasNoThrowConstructor))]; }
1552   { int arr[T(__has_nothrow_constructor(HasVirtDest))]; }
1553   // { int arr[T(__has_nothrow_constructor(VirtAr))]; } // not implemented
1554   { int arr[T(__has_nothrow_constructor(AllPrivate))]; }
1555 
1556   { int arr[F(__has_nothrow_constructor(HasCons))]; }
1557   { int arr[F(__has_nothrow_constructor(HasRef))]; }
1558   { int arr[F(__has_nothrow_constructor(HasCopy))]; }
1559   { int arr[F(__has_nothrow_constructor(HasMove))]; }
1560   { int arr[F(__has_nothrow_constructor(HasNoThrowConstructorWithArgs))]; }
1561   { int arr[F(__has_nothrow_constructor(IntRef))]; }
1562   { int arr[F(__has_nothrow_constructor(void))]; }
1563   { int arr[F(__has_nothrow_constructor(cvoid))]; }
1564   { int arr[F(__has_nothrow_constructor(HasTemplateCons))]; }
1565 }
1566 
1567 void has_virtual_destructor() {
1568   { int arr[F(__has_virtual_destructor(Int))]; }
1569   { int arr[F(__has_virtual_destructor(IntAr))]; }
1570   { int arr[F(__has_virtual_destructor(Union))]; }
1571   { int arr[F(__has_virtual_destructor(UnionAr))]; }
1572   { int arr[F(__has_virtual_destructor(POD))]; }
1573   { int arr[F(__has_virtual_destructor(Derives))]; }
1574   { int arr[F(__has_virtual_destructor(DerivesAr))]; }
1575   { int arr[F(__has_virtual_destructor(const Int))]; }
1576   { int arr[F(__has_virtual_destructor(ConstIntAr))]; }
1577   { int arr[F(__has_virtual_destructor(ConstIntArAr))]; }
1578   { int arr[F(__has_virtual_destructor(HasDest))]; }
1579   { int arr[F(__has_virtual_destructor(HasPriv))]; }
1580   { int arr[F(__has_virtual_destructor(HasCons))]; }
1581   { int arr[F(__has_virtual_destructor(HasRef))]; }
1582   { int arr[F(__has_virtual_destructor(HasCopy))]; }
1583   { int arr[F(__has_virtual_destructor(HasMove))]; }
1584   { int arr[F(__has_virtual_destructor(HasCopyAssign))]; }
1585   { int arr[F(__has_virtual_destructor(HasMoveAssign))]; }
1586   { int arr[F(__has_virtual_destructor(IntRef))]; }
1587   { int arr[F(__has_virtual_destructor(VirtAr))]; }
1588 
1589   { int arr[T(__has_virtual_destructor(HasVirtDest))]; }
1590   { int arr[T(__has_virtual_destructor(DerivedVirtDest))]; }
1591   { int arr[F(__has_virtual_destructor(VirtDestAr))]; }
1592   { int arr[F(__has_virtual_destructor(void))]; }
1593   { int arr[F(__has_virtual_destructor(cvoid))]; }
1594   { int arr[F(__has_virtual_destructor(AllPrivate))]; }
1595 }
1596 
1597 
1598 class Base {};
1599 class Derived : Base {};
1600 class Derived2a : Derived {};
1601 class Derived2b : Derived {};
1602 class Derived3 : virtual Derived2a, virtual Derived2b {};
1603 template<typename T> struct BaseA { T a;  };
1604 template<typename T> struct DerivedB : BaseA<T> { };
1605 template<typename T> struct CrazyDerived : T { };
1606 
1607 
1608 class class_forward; // expected-note 2 {{forward declaration of 'class_forward'}}
1609 
1610 template <typename Base, typename Derived>
1611 void isBaseOfT() {
1612   int t[T(__is_base_of(Base, Derived))];
1613 };
1614 template <typename Base, typename Derived>
1615 void isBaseOfF() {
1616   int t[F(__is_base_of(Base, Derived))];
1617 };
1618 
1619 template <class T> class DerivedTemp : Base {};
1620 template <class T> class NonderivedTemp {};
1621 template <class T> class UndefinedTemp; // expected-note {{declared here}}
1622 
1623 void is_base_of() {
1624   { int arr[T(__is_base_of(Base, Derived))]; }
1625   { int arr[T(__is_base_of(const Base, Derived))]; }
1626   { int arr[F(__is_base_of(Derived, Base))]; }
1627   { int arr[F(__is_base_of(Derived, int))]; }
1628   { int arr[T(__is_base_of(Base, Base))]; }
1629   { int arr[T(__is_base_of(Base, Derived3))]; }
1630   { int arr[T(__is_base_of(Derived, Derived3))]; }
1631   { int arr[T(__is_base_of(Derived2b, Derived3))]; }
1632   { int arr[T(__is_base_of(Derived2a, Derived3))]; }
1633   { int arr[T(__is_base_of(BaseA<int>, DerivedB<int>))]; }
1634   { int arr[F(__is_base_of(DerivedB<int>, BaseA<int>))]; }
1635   { int arr[T(__is_base_of(Base, CrazyDerived<Base>))]; }
1636   { int arr[F(__is_base_of(Union, Union))]; }
1637   { int arr[T(__is_base_of(Empty, Empty))]; }
1638   { int arr[T(__is_base_of(class_forward, class_forward))]; }
1639   { int arr[F(__is_base_of(Empty, class_forward))]; } // expected-error {{incomplete type 'class_forward' used in type trait expression}}
1640   { int arr[F(__is_base_of(Base&, Derived&))]; }
1641   int t18[F(__is_base_of(Base[10], Derived[10]))];
1642   { int arr[F(__is_base_of(int, int))]; }
1643   { int arr[F(__is_base_of(long, int))]; }
1644   { int arr[T(__is_base_of(Base, DerivedTemp<int>))]; }
1645   { int arr[F(__is_base_of(Base, NonderivedTemp<int>))]; }
1646   { int arr[F(__is_base_of(Base, UndefinedTemp<int>))]; } // expected-error {{implicit instantiation of undefined template 'UndefinedTemp<int>'}}
1647 
1648   isBaseOfT<Base, Derived>();
1649   isBaseOfF<Derived, Base>();
1650 
1651   isBaseOfT<Base, CrazyDerived<Base> >();
1652   isBaseOfF<CrazyDerived<Base>, Base>();
1653 
1654   isBaseOfT<BaseA<int>, DerivedB<int> >();
1655   isBaseOfF<DerivedB<int>, BaseA<int> >();
1656 }
1657 
1658 template<class T, class U>
1659 class TemplateClass {};
1660 
1661 template<class T>
1662 using TemplateAlias = TemplateClass<T, int>;
1663 
1664 typedef class Base BaseTypedef;
1665 
1666 void is_same()
1667 {
1668   int t01[T(__is_same(Base, Base))];
1669   int t02[T(__is_same(Base, BaseTypedef))];
1670   int t03[T(__is_same(TemplateClass<int, int>, TemplateAlias<int>))];
1671 
1672   int t10[F(__is_same(Base, const Base))];
1673   int t11[F(__is_same(Base, Base&))];
1674   int t12[F(__is_same(Base, Derived))];
1675 }
1676 
1677 struct IntWrapper
1678 {
1679   int value;
1680   IntWrapper(int _value) : value(_value) {}
1681   operator int() const {
1682     return value;
1683   }
1684 };
1685 
1686 struct FloatWrapper
1687 {
1688   float value;
1689   FloatWrapper(float _value) : value(_value) {}
1690   FloatWrapper(const IntWrapper& obj)
1691     : value(static_cast<float>(obj.value)) {}
1692   operator float() const {
1693     return value;
1694   }
1695   operator IntWrapper() const {
1696     return IntWrapper(static_cast<int>(value));
1697   }
1698 };
1699 
1700 void is_convertible()
1701 {
1702   int t01[T(__is_convertible(IntWrapper, IntWrapper))];
1703   int t02[T(__is_convertible(IntWrapper, const IntWrapper))];
1704   int t03[T(__is_convertible(IntWrapper, int))];
1705   int t04[T(__is_convertible(int, IntWrapper))];
1706   int t05[T(__is_convertible(IntWrapper, FloatWrapper))];
1707   int t06[T(__is_convertible(FloatWrapper, IntWrapper))];
1708   int t07[T(__is_convertible(FloatWrapper, float))];
1709   int t08[T(__is_convertible(float, FloatWrapper))];
1710 }
1711 
1712 struct FromInt { FromInt(int); };
1713 struct ToInt { operator int(); };
1714 typedef void Function();
1715 
1716 void is_convertible_to();
1717 class PrivateCopy {
1718   PrivateCopy(const PrivateCopy&);
1719   friend void is_convertible_to();
1720 };
1721 
1722 template<typename T>
1723 struct X0 {
1724   template<typename U> X0(const X0<U>&);
1725 };
1726 
1727 struct Abstract { virtual void f() = 0; };
1728 
1729 void is_convertible_to() {
1730   { int arr[T(__is_convertible_to(Int, Int))]; }
1731   { int arr[F(__is_convertible_to(Int, IntAr))]; }
1732   { int arr[F(__is_convertible_to(IntAr, IntAr))]; }
1733   { int arr[T(__is_convertible_to(void, void))]; }
1734   { int arr[T(__is_convertible_to(cvoid, void))]; }
1735   { int arr[T(__is_convertible_to(void, cvoid))]; }
1736   { int arr[T(__is_convertible_to(cvoid, cvoid))]; }
1737   { int arr[T(__is_convertible_to(int, FromInt))]; }
1738   { int arr[T(__is_convertible_to(long, FromInt))]; }
1739   { int arr[T(__is_convertible_to(double, FromInt))]; }
1740   { int arr[T(__is_convertible_to(const int, FromInt))]; }
1741   { int arr[T(__is_convertible_to(const int&, FromInt))]; }
1742   { int arr[T(__is_convertible_to(ToInt, int))]; }
1743   { int arr[T(__is_convertible_to(ToInt, const int&))]; }
1744   { int arr[T(__is_convertible_to(ToInt, long))]; }
1745   { int arr[F(__is_convertible_to(ToInt, int&))]; }
1746   { int arr[F(__is_convertible_to(ToInt, FromInt))]; }
1747   { int arr[T(__is_convertible_to(IntAr&, IntAr&))]; }
1748   { int arr[T(__is_convertible_to(IntAr&, const IntAr&))]; }
1749   { int arr[F(__is_convertible_to(const IntAr&, IntAr&))]; }
1750   { int arr[F(__is_convertible_to(Function, Function))]; }
1751   { int arr[F(__is_convertible_to(PrivateCopy, PrivateCopy))]; }
1752   { int arr[T(__is_convertible_to(X0<int>, X0<float>))]; }
1753   { int arr[F(__is_convertible_to(Abstract, Abstract))]; }
1754 }
1755 
1756 namespace is_convertible_to_instantiate {
1757   // Make sure we don't try to instantiate the constructor.
1758   template<int x> class A { A(int) { int a[x]; } };
1759   int x = __is_convertible_to(int, A<-1>);
1760 }
1761 
1762 void is_trivial()
1763 {
1764   { int arr[T(__is_trivial(int))]; }
1765   { int arr[T(__is_trivial(Enum))]; }
1766   { int arr[T(__is_trivial(POD))]; }
1767   { int arr[T(__is_trivial(Int))]; }
1768   { int arr[T(__is_trivial(IntAr))]; }
1769   { int arr[T(__is_trivial(IntArNB))]; }
1770   { int arr[T(__is_trivial(Statics))]; }
1771   { int arr[T(__is_trivial(Empty))]; }
1772   { int arr[T(__is_trivial(EmptyUnion))]; }
1773   { int arr[T(__is_trivial(Union))]; }
1774   { int arr[T(__is_trivial(Derives))]; }
1775   { int arr[T(__is_trivial(DerivesAr))]; }
1776   { int arr[T(__is_trivial(DerivesArNB))]; }
1777   { int arr[T(__is_trivial(DerivesEmpty))]; }
1778   { int arr[T(__is_trivial(HasFunc))]; }
1779   { int arr[T(__is_trivial(HasOp))]; }
1780   { int arr[T(__is_trivial(HasConv))]; }
1781   { int arr[T(__is_trivial(HasAssign))]; }
1782   { int arr[T(__is_trivial(HasAnonymousUnion))]; }
1783   { int arr[T(__is_trivial(HasPriv))]; }
1784   { int arr[T(__is_trivial(HasProt))]; }
1785   { int arr[T(__is_trivial(DerivesHasPriv))]; }
1786   { int arr[T(__is_trivial(DerivesHasProt))]; }
1787   { int arr[T(__is_trivial(Vector))]; }
1788   { int arr[T(__is_trivial(VectorExt))]; }
1789 
1790   { int arr[F(__is_trivial(HasCons))]; }
1791   { int arr[F(__is_trivial(HasCopyAssign))]; }
1792   { int arr[F(__is_trivial(HasMoveAssign))]; }
1793   { int arr[F(__is_trivial(HasDest))]; }
1794   { int arr[F(__is_trivial(HasRef))]; }
1795   { int arr[F(__is_trivial(HasNonPOD))]; }
1796   { int arr[F(__is_trivial(HasVirt))]; }
1797   { int arr[F(__is_trivial(DerivesHasCons))]; }
1798   { int arr[F(__is_trivial(DerivesHasCopyAssign))]; }
1799   { int arr[F(__is_trivial(DerivesHasMoveAssign))]; }
1800   { int arr[F(__is_trivial(DerivesHasDest))]; }
1801   { int arr[F(__is_trivial(DerivesHasRef))]; }
1802   { int arr[F(__is_trivial(DerivesHasVirt))]; }
1803   { int arr[F(__is_trivial(void))]; }
1804   { int arr[F(__is_trivial(cvoid))]; }
1805 }
1806 
1807 template<typename T> struct TriviallyConstructibleTemplate {};
1808 
1809 void trivial_checks()
1810 {
1811   { int arr[T(__is_trivially_copyable(int))]; }
1812   { int arr[T(__is_trivially_copyable(Enum))]; }
1813   { int arr[T(__is_trivially_copyable(POD))]; }
1814   { int arr[T(__is_trivially_copyable(Int))]; }
1815   { int arr[T(__is_trivially_copyable(IntAr))]; }
1816   { int arr[T(__is_trivially_copyable(IntArNB))]; }
1817   { int arr[T(__is_trivially_copyable(Statics))]; }
1818   { int arr[T(__is_trivially_copyable(Empty))]; }
1819   { int arr[T(__is_trivially_copyable(EmptyUnion))]; }
1820   { int arr[T(__is_trivially_copyable(Union))]; }
1821   { int arr[T(__is_trivially_copyable(Derives))]; }
1822   { int arr[T(__is_trivially_copyable(DerivesAr))]; }
1823   { int arr[T(__is_trivially_copyable(DerivesArNB))]; }
1824   { int arr[T(__is_trivially_copyable(DerivesEmpty))]; }
1825   { int arr[T(__is_trivially_copyable(HasFunc))]; }
1826   { int arr[T(__is_trivially_copyable(HasOp))]; }
1827   { int arr[T(__is_trivially_copyable(HasConv))]; }
1828   { int arr[T(__is_trivially_copyable(HasAssign))]; }
1829   { int arr[T(__is_trivially_copyable(HasAnonymousUnion))]; }
1830   { int arr[T(__is_trivially_copyable(HasPriv))]; }
1831   { int arr[T(__is_trivially_copyable(HasProt))]; }
1832   { int arr[T(__is_trivially_copyable(DerivesHasPriv))]; }
1833   { int arr[T(__is_trivially_copyable(DerivesHasProt))]; }
1834   { int arr[T(__is_trivially_copyable(Vector))]; }
1835   { int arr[T(__is_trivially_copyable(VectorExt))]; }
1836   { int arr[T(__is_trivially_copyable(HasCons))]; }
1837   { int arr[T(__is_trivially_copyable(HasRef))]; }
1838   { int arr[T(__is_trivially_copyable(HasNonPOD))]; }
1839   { int arr[T(__is_trivially_copyable(DerivesHasCons))]; }
1840   { int arr[T(__is_trivially_copyable(DerivesHasRef))]; }
1841 
1842   { int arr[F(__is_trivially_copyable(HasCopyAssign))]; }
1843   { int arr[F(__is_trivially_copyable(HasMoveAssign))]; }
1844   { int arr[F(__is_trivially_copyable(HasDest))]; }
1845   { int arr[F(__is_trivially_copyable(HasVirt))]; }
1846   { int arr[F(__is_trivially_copyable(DerivesHasCopyAssign))]; }
1847   { int arr[F(__is_trivially_copyable(DerivesHasMoveAssign))]; }
1848   { int arr[F(__is_trivially_copyable(DerivesHasDest))]; }
1849   { int arr[F(__is_trivially_copyable(DerivesHasVirt))]; }
1850   { int arr[F(__is_trivially_copyable(void))]; }
1851   { int arr[F(__is_trivially_copyable(cvoid))]; }
1852 
1853   { int arr[T((__is_trivially_constructible(int)))]; }
1854   { int arr[T((__is_trivially_constructible(int, int)))]; }
1855   { int arr[T((__is_trivially_constructible(int, float)))]; }
1856   { int arr[T((__is_trivially_constructible(int, int&)))]; }
1857   { int arr[T((__is_trivially_constructible(int, const int&)))]; }
1858   { int arr[T((__is_trivially_constructible(int, int)))]; }
1859   { int arr[T((__is_trivially_constructible(HasCopyAssign, HasCopyAssign)))]; }
1860   { int arr[T((__is_trivially_constructible(HasCopyAssign, const HasCopyAssign&)))]; }
1861   { int arr[T((__is_trivially_constructible(HasCopyAssign, HasCopyAssign&&)))]; }
1862   { int arr[T((__is_trivially_constructible(HasCopyAssign)))]; }
1863   { int arr[T((__is_trivially_constructible(NonTrivialDefault,
1864                                             const NonTrivialDefault&)))]; }
1865   { int arr[T((__is_trivially_constructible(NonTrivialDefault,
1866                                             NonTrivialDefault&&)))]; }
1867   { int arr[T((__is_trivially_constructible(AllDefaulted)))]; }
1868   { int arr[T((__is_trivially_constructible(AllDefaulted,
1869                                             const AllDefaulted &)))]; }
1870   { int arr[T((__is_trivially_constructible(AllDefaulted,
1871                                             AllDefaulted &&)))]; }
1872 
1873   { int arr[F((__is_trivially_constructible(int, int*)))]; }
1874   { int arr[F((__is_trivially_constructible(NonTrivialDefault)))]; }
1875   { int arr[F((__is_trivially_constructible(ThreeArgCtor, int*, char*, int&)))]; }
1876   { int arr[F((__is_trivially_constructible(AllDeleted)))]; }
1877   { int arr[F((__is_trivially_constructible(AllDeleted,
1878                                             const AllDeleted &)))]; }
1879   { int arr[F((__is_trivially_constructible(AllDeleted,
1880                                             AllDeleted &&)))]; }
1881   { int arr[F((__is_trivially_constructible(ExtDefaulted)))]; }
1882   { int arr[F((__is_trivially_constructible(ExtDefaulted,
1883                                             const ExtDefaulted &)))]; }
1884   { int arr[F((__is_trivially_constructible(ExtDefaulted,
1885                                             ExtDefaulted &&)))]; }
1886 
1887   { int arr[T((__is_trivially_constructible(TriviallyConstructibleTemplate<int>)))]; }
1888   { int arr[F((__is_trivially_constructible(class_forward)))]; } // expected-error {{incomplete type 'class_forward' used in type trait expression}}
1889   { int arr[F((__is_trivially_constructible(class_forward[])))]; }
1890   { int arr[F((__is_trivially_constructible(void)))]; }
1891 
1892   { int arr[T((__is_trivially_assignable(int&, int)))]; }
1893   { int arr[T((__is_trivially_assignable(int&, int&)))]; }
1894   { int arr[T((__is_trivially_assignable(int&, int&&)))]; }
1895   { int arr[T((__is_trivially_assignable(int&, const int&)))]; }
1896   { int arr[T((__is_trivially_assignable(POD&, POD)))]; }
1897   { int arr[T((__is_trivially_assignable(POD&, POD&)))]; }
1898   { int arr[T((__is_trivially_assignable(POD&, POD&&)))]; }
1899   { int arr[T((__is_trivially_assignable(POD&, const POD&)))]; }
1900   { int arr[T((__is_trivially_assignable(int*&, int*)))]; }
1901   { int arr[T((__is_trivially_assignable(AllDefaulted,
1902                                          const AllDefaulted &)))]; }
1903   { int arr[T((__is_trivially_assignable(AllDefaulted,
1904                                          AllDefaulted &&)))]; }
1905 
1906   { int arr[F((__is_trivially_assignable(int*&, float*)))]; }
1907   { int arr[F((__is_trivially_assignable(HasCopyAssign&, HasCopyAssign)))]; }
1908   { int arr[F((__is_trivially_assignable(HasCopyAssign&, HasCopyAssign&)))]; }
1909   { int arr[F((__is_trivially_assignable(HasCopyAssign&, const HasCopyAssign&)))]; }
1910   { int arr[F((__is_trivially_assignable(HasCopyAssign&, HasCopyAssign&&)))]; }
1911   { int arr[F((__is_trivially_assignable(TrivialMoveButNotCopy&,
1912                                         TrivialMoveButNotCopy&)))]; }
1913   { int arr[F((__is_trivially_assignable(TrivialMoveButNotCopy&,
1914                                         const TrivialMoveButNotCopy&)))]; }
1915   { int arr[F((__is_trivially_assignable(AllDeleted,
1916                                          const AllDeleted &)))]; }
1917   { int arr[F((__is_trivially_assignable(AllDeleted,
1918                                          AllDeleted &&)))]; }
1919   { int arr[F((__is_trivially_assignable(ExtDefaulted,
1920                                          const ExtDefaulted &)))]; }
1921   { int arr[F((__is_trivially_assignable(ExtDefaulted,
1922                                          ExtDefaulted &&)))]; }
1923 
1924   { int arr[T((__is_trivially_assignable(HasDefaultTrivialCopyAssign&,
1925                                          HasDefaultTrivialCopyAssign&)))]; }
1926   { int arr[T((__is_trivially_assignable(HasDefaultTrivialCopyAssign&,
1927                                        const HasDefaultTrivialCopyAssign&)))]; }
1928   { int arr[T((__is_trivially_assignable(TrivialMoveButNotCopy&,
1929                                          TrivialMoveButNotCopy)))]; }
1930   { int arr[T((__is_trivially_assignable(TrivialMoveButNotCopy&,
1931                                          TrivialMoveButNotCopy&&)))]; }
1932 }
1933 
1934 // Instantiation of __is_trivially_constructible
1935 template<typename T, typename ...Args>
1936 struct is_trivially_constructible {
1937   static const bool value = __is_trivially_constructible(T, Args...);
1938 };
1939 
1940 void is_trivially_constructible_test() {
1941   { int arr[T((is_trivially_constructible<int>::value))]; }
1942   { int arr[T((is_trivially_constructible<int, int>::value))]; }
1943   { int arr[T((is_trivially_constructible<int, float>::value))]; }
1944   { int arr[T((is_trivially_constructible<int, int&>::value))]; }
1945   { int arr[T((is_trivially_constructible<int, const int&>::value))]; }
1946   { int arr[T((is_trivially_constructible<int, int>::value))]; }
1947   { int arr[T((is_trivially_constructible<HasCopyAssign, HasCopyAssign>::value))]; }
1948   { int arr[T((is_trivially_constructible<HasCopyAssign, const HasCopyAssign&>::value))]; }
1949   { int arr[T((is_trivially_constructible<HasCopyAssign, HasCopyAssign&&>::value))]; }
1950   { int arr[T((is_trivially_constructible<HasCopyAssign>::value))]; }
1951   { int arr[T((is_trivially_constructible<NonTrivialDefault,
1952                                             const NonTrivialDefault&>::value))]; }
1953   { int arr[T((is_trivially_constructible<NonTrivialDefault,
1954                                             NonTrivialDefault&&>::value))]; }
1955 
1956   { int arr[F((is_trivially_constructible<int, int*>::value))]; }
1957   { int arr[F((is_trivially_constructible<NonTrivialDefault>::value))]; }
1958   { int arr[F((is_trivially_constructible<ThreeArgCtor, int*, char*, int&>::value))]; }
1959 }
1960 
1961 void array_rank() {
1962   int t01[T(__array_rank(IntAr) == 1)];
1963   int t02[T(__array_rank(ConstIntArAr) == 2)];
1964 }
1965 
1966 void array_extent() {
1967   int t01[T(__array_extent(IntAr, 0) == 10)];
1968   int t02[T(__array_extent(ConstIntArAr, 0) == 4)];
1969   int t03[T(__array_extent(ConstIntArAr, 1) == 10)];
1970 }
1971