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