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