1 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 -fms-extensions -Wno-microsoft %s
2 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++14 -fms-extensions -Wno-microsoft %s
3 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++1z -fms-extensions -Wno-microsoft %s
4
5 #define T(b) (b) ? 1 : -1
6 #define F(b) (b) ? -1 : 1
7
8 struct NonPOD { NonPOD(int); };
9 typedef NonPOD NonPODAr[10];
10 typedef NonPOD NonPODArNB[];
11 typedef NonPOD NonPODArMB[10][2];
12
13 // PODs
14 enum Enum { EV };
15 enum SignedEnum : signed int { };
16 struct POD { Enum e; int i; float f; NonPOD* p; };
17 struct Empty {};
18 struct IncompleteStruct;
19 typedef Empty EmptyAr[10];
20 typedef Empty EmptyArNB[];
21 typedef Empty EmptyArMB[1][2];
22 typedef int Int;
23 typedef Int IntAr[10];
24 typedef Int IntArNB[];
25 class Statics { static int priv; static NonPOD np; };
26 union EmptyUnion {};
27 union IncompleteUnion; // expected-note {{forward declaration of 'IncompleteUnion'}}
28 union Union { int i; float f; };
29 struct HasFunc { void f (); };
30 struct HasOp { void operator *(); };
31 struct HasConv { operator int(); };
32 struct HasAssign { void operator =(int); };
33
34 struct HasAnonymousUnion {
35 union {
36 int i;
37 float f;
38 };
39 };
40
41 typedef int Vector __attribute__((vector_size(16)));
42 typedef int VectorExt __attribute__((ext_vector_type(4)));
43
44 using ComplexFloat = _Complex float;
45 using ComplexInt = _Complex int;
46
47 // Not PODs
48 typedef const void cvoid;
49 struct Derives : POD {};
50 typedef Derives DerivesAr[10];
51 typedef Derives DerivesArNB[];
52 struct DerivesEmpty : Empty {};
53 struct HasCons { HasCons(int); };
54 struct HasDefaultCons { HasDefaultCons() = default; };
55 struct HasExplicitDefaultCons { explicit HasExplicitDefaultCons() = default; };
56 struct HasInheritedCons : HasDefaultCons { using HasDefaultCons::HasDefaultCons; };
57 struct HasNoInheritedCons : HasCons {};
58 struct HasCopyAssign { HasCopyAssign operator =(const HasCopyAssign&); };
59 struct HasMoveAssign { HasMoveAssign operator =(const HasMoveAssign&&); };
60 struct HasNoThrowMoveAssign {
61 HasNoThrowMoveAssign& operator=(
62 const HasNoThrowMoveAssign&&) throw(); };
63 struct HasNoExceptNoThrowMoveAssign {
64 HasNoExceptNoThrowMoveAssign& operator=(
65 const HasNoExceptNoThrowMoveAssign&&) noexcept;
66 };
67 struct HasThrowMoveAssign {
68 HasThrowMoveAssign& operator=(const HasThrowMoveAssign&&)
69 #if __cplusplus <= 201402L
70 throw(POD);
71 #else
72 noexcept(false);
73 #endif
74 };
75
76
77 struct HasNoExceptFalseMoveAssign {
78 HasNoExceptFalseMoveAssign& operator=(
79 const HasNoExceptFalseMoveAssign&&) noexcept(false); };
80 struct HasMoveCtor { HasMoveCtor(const HasMoveCtor&&); };
81 struct HasMemberMoveCtor { HasMoveCtor member; };
82 struct HasMemberMoveAssign { HasMoveAssign member; };
83 struct HasStaticMemberMoveCtor { static HasMoveCtor member; };
84 struct HasStaticMemberMoveAssign { static HasMoveAssign member; };
85 struct HasMemberThrowMoveAssign { HasThrowMoveAssign member; };
86 struct HasMemberNoExceptFalseMoveAssign {
87 HasNoExceptFalseMoveAssign member; };
88 struct HasMemberNoThrowMoveAssign { HasNoThrowMoveAssign member; };
89 struct HasMemberNoExceptNoThrowMoveAssign {
90 HasNoExceptNoThrowMoveAssign member; };
91
92 struct HasDefaultTrivialCopyAssign {
93 HasDefaultTrivialCopyAssign &operator=(
94 const HasDefaultTrivialCopyAssign&) = default;
95 };
96 struct TrivialMoveButNotCopy {
97 TrivialMoveButNotCopy &operator=(TrivialMoveButNotCopy&&) = default;
98 TrivialMoveButNotCopy &operator=(const TrivialMoveButNotCopy&);
99 };
100 struct NonTrivialDefault {
101 NonTrivialDefault();
102 };
103
104 struct HasDest { ~HasDest(); };
105 class HasPriv { int priv; };
106 class HasProt { protected: int prot; };
HasRefHasRef107 struct HasRef { int i; int& ref; HasRef() : i(0), ref(i) {} };
108 struct HasRefAggregate { int i; int& ref; };
109 struct HasNonPOD { NonPOD np; };
VirtHasVirt110 struct HasVirt { virtual void Virt() {}; };
111 typedef NonPOD NonPODAr[10];
112 typedef HasVirt VirtAr[10];
113 typedef NonPOD NonPODArNB[];
114 union NonPODUnion { int i; Derives n; };
115 struct DerivesHasCons : HasCons {};
116 struct DerivesHasCopyAssign : HasCopyAssign {};
117 struct DerivesHasMoveAssign : HasMoveAssign {};
118 struct DerivesHasDest : HasDest {};
119 struct DerivesHasPriv : HasPriv {};
120 struct DerivesHasProt : HasProt {};
121 struct DerivesHasRef : HasRef {};
122 struct DerivesHasVirt : HasVirt {};
123 struct DerivesHasMoveCtor : HasMoveCtor {};
124
125 struct HasNoThrowCopyAssign {
126 void operator =(const HasNoThrowCopyAssign&) throw();
127 };
128 struct HasMultipleCopyAssign {
129 void operator =(const HasMultipleCopyAssign&) throw();
130 void operator =(volatile HasMultipleCopyAssign&);
131 };
132 struct HasMultipleNoThrowCopyAssign {
133 void operator =(const HasMultipleNoThrowCopyAssign&) throw();
134 void operator =(volatile HasMultipleNoThrowCopyAssign&) throw();
135 };
136
137 struct HasNoThrowConstructor { HasNoThrowConstructor() throw(); };
138 struct HasNoThrowConstructorWithArgs {
139 HasNoThrowConstructorWithArgs(HasCons i = HasCons(0)) throw();
140 };
141 struct HasMultipleDefaultConstructor1 {
142 HasMultipleDefaultConstructor1() throw();
143 HasMultipleDefaultConstructor1(int i = 0);
144 };
145 struct HasMultipleDefaultConstructor2 {
146 HasMultipleDefaultConstructor2(int i = 0);
147 HasMultipleDefaultConstructor2() throw();
148 };
149
150 struct HasNoThrowCopy { HasNoThrowCopy(const HasNoThrowCopy&) throw(); };
151 struct HasMultipleCopy {
152 HasMultipleCopy(const HasMultipleCopy&) throw();
153 HasMultipleCopy(volatile HasMultipleCopy&);
154 };
155 struct HasMultipleNoThrowCopy {
156 HasMultipleNoThrowCopy(const HasMultipleNoThrowCopy&) throw();
157 HasMultipleNoThrowCopy(volatile HasMultipleNoThrowCopy&) throw();
158 };
159
160 struct HasVirtDest { virtual ~HasVirtDest(); };
161 struct DerivedVirtDest : HasVirtDest {};
162 typedef HasVirtDest VirtDestAr[1];
163
164 class AllPrivate {
165 AllPrivate() throw();
166 AllPrivate(const AllPrivate&) throw();
167 AllPrivate &operator=(const AllPrivate &) throw();
168 ~AllPrivate() throw();
169 };
170
171 struct ThreeArgCtor {
172 ThreeArgCtor(int*, char*, int);
173 };
174
175 struct VariadicCtor {
176 template<typename...T> VariadicCtor(T...);
177 };
178
179 struct ThrowingDtor {
180 ~ThrowingDtor()
181 #if __cplusplus <= 201402L
182 throw(int);
183 #else
184 noexcept(false);
185 #endif
186 };
187
188 struct NoExceptDtor {
189 ~NoExceptDtor() noexcept(true);
190 };
191
192 struct NoThrowDtor {
193 ~NoThrowDtor() throw();
194 };
195
196 struct ACompleteType {};
197 struct AnIncompleteType; // expected-note 1+ {{forward declaration of 'AnIncompleteType'}}
198 typedef AnIncompleteType AnIncompleteTypeAr[42];
199 typedef AnIncompleteType AnIncompleteTypeArNB[];
200 typedef AnIncompleteType AnIncompleteTypeArMB[1][10];
201
202 struct HasInClassInit {
203 int x = 42;
204 };
205
206 struct HasPrivateBase : private ACompleteType {};
207 struct HasProtectedBase : protected ACompleteType {};
208 struct HasVirtBase : virtual ACompleteType {};
209
is_pod()210 void is_pod()
211 {
212 { int arr[T(__is_pod(int))]; }
213 { int arr[T(__is_pod(Enum))]; }
214 { int arr[T(__is_pod(POD))]; }
215 { int arr[T(__is_pod(Int))]; }
216 { int arr[T(__is_pod(IntAr))]; }
217 { int arr[T(__is_pod(Statics))]; }
218 { int arr[T(__is_pod(Empty))]; }
219 { int arr[T(__is_pod(EmptyUnion))]; }
220 { int arr[T(__is_pod(Union))]; }
221 { int arr[T(__is_pod(HasFunc))]; }
222 { int arr[T(__is_pod(HasOp))]; }
223 { int arr[T(__is_pod(HasConv))]; }
224 { int arr[T(__is_pod(HasAssign))]; }
225 { int arr[T(__is_pod(IntArNB))]; }
226 { int arr[T(__is_pod(HasAnonymousUnion))]; }
227 { int arr[T(__is_pod(Vector))]; }
228 { int arr[T(__is_pod(VectorExt))]; }
229 { int arr[T(__is_pod(Derives))]; }
230 { int arr[T(__is_pod(DerivesAr))]; }
231 { int arr[T(__is_pod(DerivesArNB))]; }
232 { int arr[T(__is_pod(DerivesEmpty))]; }
233 { int arr[T(__is_pod(HasPriv))]; }
234 { int arr[T(__is_pod(HasProt))]; }
235 { int arr[T(__is_pod(DerivesHasPriv))]; }
236 { int arr[T(__is_pod(DerivesHasProt))]; }
237
238 { int arr[F(__is_pod(HasCons))]; }
239 { int arr[F(__is_pod(HasCopyAssign))]; }
240 { int arr[F(__is_pod(HasMoveAssign))]; }
241 { int arr[F(__is_pod(HasDest))]; }
242 { int arr[F(__is_pod(HasRef))]; }
243 { int arr[F(__is_pod(HasVirt))]; }
244 { int arr[F(__is_pod(DerivesHasCons))]; }
245 { int arr[F(__is_pod(DerivesHasCopyAssign))]; }
246 { int arr[F(__is_pod(DerivesHasMoveAssign))]; }
247 { int arr[F(__is_pod(DerivesHasDest))]; }
248 { int arr[F(__is_pod(DerivesHasRef))]; }
249 { int arr[F(__is_pod(DerivesHasVirt))]; }
250 { int arr[F(__is_pod(NonPOD))]; }
251 { int arr[F(__is_pod(HasNonPOD))]; }
252 { int arr[F(__is_pod(NonPODAr))]; }
253 { int arr[F(__is_pod(NonPODArNB))]; }
254 { int arr[F(__is_pod(void))]; }
255 { int arr[F(__is_pod(cvoid))]; }
256 // { int arr[F(__is_pod(NonPODUnion))]; }
257
258 { int arr[T(__is_pod(ACompleteType))]; }
259 { int arr[F(__is_pod(AnIncompleteType))]; } // expected-error {{incomplete type}}
260 { int arr[F(__is_pod(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
261 { int arr[F(__is_pod(AnIncompleteType[1]))]; } // expected-error {{incomplete type}}
262 }
263
264 typedef Empty EmptyAr[10];
265 struct Bit0 { int : 0; };
266 struct Bit0Cons { int : 0; Bit0Cons(); };
267 struct AnonBitOnly { int : 3; };
268 struct BitOnly { int x : 3; };
269 struct DerivesVirt : virtual POD {};
270
is_empty()271 void is_empty()
272 {
273 { int arr[T(__is_empty(Empty))]; }
274 { int arr[T(__is_empty(DerivesEmpty))]; }
275 { int arr[T(__is_empty(HasCons))]; }
276 { int arr[T(__is_empty(HasCopyAssign))]; }
277 { int arr[T(__is_empty(HasMoveAssign))]; }
278 { int arr[T(__is_empty(HasDest))]; }
279 { int arr[T(__is_empty(HasFunc))]; }
280 { int arr[T(__is_empty(HasOp))]; }
281 { int arr[T(__is_empty(HasConv))]; }
282 { int arr[T(__is_empty(HasAssign))]; }
283 { int arr[T(__is_empty(Bit0))]; }
284 { int arr[T(__is_empty(Bit0Cons))]; }
285
286 { int arr[F(__is_empty(Int))]; }
287 { int arr[F(__is_empty(POD))]; }
288 { int arr[F(__is_empty(EmptyUnion))]; }
289 { int arr[F(__is_empty(IncompleteUnion))]; }
290 { int arr[F(__is_empty(EmptyAr))]; }
291 { int arr[F(__is_empty(HasRef))]; }
292 { int arr[F(__is_empty(HasVirt))]; }
293 { int arr[F(__is_empty(AnonBitOnly))]; }
294 { int arr[F(__is_empty(BitOnly))]; }
295 { int arr[F(__is_empty(void))]; }
296 { int arr[F(__is_empty(IntArNB))]; }
297 { int arr[F(__is_empty(HasAnonymousUnion))]; }
298 // { int arr[F(__is_empty(DerivesVirt))]; }
299
300 { int arr[T(__is_empty(ACompleteType))]; }
301 { int arr[F(__is_empty(AnIncompleteType))]; } // expected-error {{incomplete type}}
302 { int arr[F(__is_empty(AnIncompleteType[]))]; }
303 { int arr[F(__is_empty(AnIncompleteType[1]))]; }
304 }
305
306 typedef Derives ClassType;
307
is_class()308 void is_class()
309 {
310 { int arr[T(__is_class(Derives))]; }
311 { int arr[T(__is_class(HasPriv))]; }
312 { int arr[T(__is_class(ClassType))]; }
313 { int arr[T(__is_class(HasAnonymousUnion))]; }
314
315 { int arr[F(__is_class(int))]; }
316 { int arr[F(__is_class(Enum))]; }
317 { int arr[F(__is_class(Int))]; }
318 { int arr[F(__is_class(IntAr))]; }
319 { int arr[F(__is_class(DerivesAr))]; }
320 { int arr[F(__is_class(Union))]; }
321 { int arr[F(__is_class(cvoid))]; }
322 { int arr[F(__is_class(IntArNB))]; }
323 }
324
325 typedef Union UnionAr[10];
326 typedef Union UnionType;
327
is_union()328 void is_union()
329 {
330 { int arr[T(__is_union(Union))]; }
331 { int arr[T(__is_union(UnionType))]; }
332
333 { int arr[F(__is_union(int))]; }
334 { int arr[F(__is_union(Enum))]; }
335 { int arr[F(__is_union(Int))]; }
336 { int arr[F(__is_union(IntAr))]; }
337 { int arr[F(__is_union(UnionAr))]; }
338 { int arr[F(__is_union(cvoid))]; }
339 { int arr[F(__is_union(IntArNB))]; }
340 { int arr[F(__is_union(HasAnonymousUnion))]; }
341 }
342
343 typedef Enum EnumType;
344
is_enum()345 void is_enum()
346 {
347 { int arr[T(__is_enum(Enum))]; }
348 { int arr[T(__is_enum(EnumType))]; }
349
350 { int arr[F(__is_enum(int))]; }
351 { int arr[F(__is_enum(Union))]; }
352 { int arr[F(__is_enum(Int))]; }
353 { int arr[F(__is_enum(IntAr))]; }
354 { int arr[F(__is_enum(UnionAr))]; }
355 { int arr[F(__is_enum(Derives))]; }
356 { int arr[F(__is_enum(ClassType))]; }
357 { int arr[F(__is_enum(cvoid))]; }
358 { int arr[F(__is_enum(IntArNB))]; }
359 { int arr[F(__is_enum(HasAnonymousUnion))]; }
360 }
361
362 struct FinalClass final {
363 };
364
365 template<typename T>
366 struct PotentiallyFinal { };
367
368 template<typename T>
369 struct PotentiallyFinal<T*> final { };
370
371 template<>
372 struct PotentiallyFinal<int> final { };
373
374 struct SealedClass sealed {
375 };
376
377 template<typename T>
378 struct PotentiallySealed { };
379
380 template<typename T>
381 struct PotentiallySealed<T*> sealed { };
382
383 template<>
384 struct PotentiallySealed<int> sealed { };
385
is_final()386 void is_final()
387 {
388 { int arr[T(__is_final(SealedClass))]; }
389 { int arr[T(__is_final(PotentiallySealed<float*>))]; }
390 { int arr[T(__is_final(PotentiallySealed<int>))]; }
391 { int arr[T(__is_final(FinalClass))]; }
392 { int arr[T(__is_final(PotentiallyFinal<float*>))]; }
393 { int arr[T(__is_final(PotentiallyFinal<int>))]; }
394
395 { int arr[F(__is_final(int))]; }
396 { int arr[F(__is_final(Union))]; }
397 { int arr[F(__is_final(Int))]; }
398 { int arr[F(__is_final(IntAr))]; }
399 { int arr[F(__is_final(UnionAr))]; }
400 { int arr[F(__is_final(Derives))]; }
401 { int arr[F(__is_final(ClassType))]; }
402 { int arr[F(__is_final(cvoid))]; }
403 { int arr[F(__is_final(IntArNB))]; }
404 { int arr[F(__is_final(HasAnonymousUnion))]; }
405 { int arr[F(__is_final(PotentiallyFinal<float>))]; }
406 { int arr[F(__is_final(PotentiallySealed<float>))]; }
407 }
408
is_sealed()409 void is_sealed()
410 {
411 { int arr[T(__is_sealed(SealedClass))]; }
412 { int arr[T(__is_sealed(PotentiallySealed<float*>))]; }
413 { int arr[T(__is_sealed(PotentiallySealed<int>))]; }
414 { int arr[T(__is_sealed(FinalClass))]; }
415 { int arr[T(__is_sealed(PotentiallyFinal<float*>))]; }
416 { int arr[T(__is_sealed(PotentiallyFinal<int>))]; }
417
418 { int arr[F(__is_sealed(int))]; }
419 { int arr[F(__is_sealed(Union))]; }
420 { int arr[F(__is_sealed(Int))]; }
421 { int arr[F(__is_sealed(IntAr))]; }
422 { int arr[F(__is_sealed(UnionAr))]; }
423 { int arr[F(__is_sealed(Derives))]; }
424 { int arr[F(__is_sealed(ClassType))]; }
425 { int arr[F(__is_sealed(cvoid))]; }
426 { int arr[F(__is_sealed(IntArNB))]; }
427 { int arr[F(__is_sealed(HasAnonymousUnion))]; }
428 { int arr[F(__is_sealed(PotentiallyFinal<float>))]; }
429 { int arr[F(__is_sealed(PotentiallySealed<float>))]; }
430 }
431
432 typedef HasVirt Polymorph;
433 struct InheritPolymorph : Polymorph {};
434
is_polymorphic()435 void is_polymorphic()
436 {
437 { int arr[T(__is_polymorphic(Polymorph))]; }
438 { int arr[T(__is_polymorphic(InheritPolymorph))]; }
439
440 { int arr[F(__is_polymorphic(int))]; }
441 { int arr[F(__is_polymorphic(Union))]; }
442 { int arr[F(__is_polymorphic(IncompleteUnion))]; }
443 { int arr[F(__is_polymorphic(Int))]; }
444 { int arr[F(__is_polymorphic(IntAr))]; }
445 { int arr[F(__is_polymorphic(UnionAr))]; }
446 { int arr[F(__is_polymorphic(Derives))]; }
447 { int arr[F(__is_polymorphic(ClassType))]; }
448 { int arr[F(__is_polymorphic(Enum))]; }
449 { int arr[F(__is_polymorphic(cvoid))]; }
450 { int arr[F(__is_polymorphic(IntArNB))]; }
451 }
452
is_integral()453 void is_integral()
454 {
455 int t01[T(__is_integral(bool))];
456 int t02[T(__is_integral(char))];
457 int t03[T(__is_integral(signed char))];
458 int t04[T(__is_integral(unsigned char))];
459 //int t05[T(__is_integral(char16_t))];
460 //int t06[T(__is_integral(char32_t))];
461 int t07[T(__is_integral(wchar_t))];
462 int t08[T(__is_integral(short))];
463 int t09[T(__is_integral(unsigned short))];
464 int t10[T(__is_integral(int))];
465 int t11[T(__is_integral(unsigned int))];
466 int t12[T(__is_integral(long))];
467 int t13[T(__is_integral(unsigned long))];
468
469 int t21[F(__is_integral(float))];
470 int t22[F(__is_integral(double))];
471 int t23[F(__is_integral(long double))];
472 int t24[F(__is_integral(Union))];
473 int t25[F(__is_integral(UnionAr))];
474 int t26[F(__is_integral(Derives))];
475 int t27[F(__is_integral(ClassType))];
476 int t28[F(__is_integral(Enum))];
477 int t29[F(__is_integral(void))];
478 int t30[F(__is_integral(cvoid))];
479 int t31[F(__is_integral(IntArNB))];
480 }
481
is_floating_point()482 void is_floating_point()
483 {
484 int t01[T(__is_floating_point(float))];
485 int t02[T(__is_floating_point(double))];
486 int t03[T(__is_floating_point(long double))];
487
488 int t11[F(__is_floating_point(bool))];
489 int t12[F(__is_floating_point(char))];
490 int t13[F(__is_floating_point(signed char))];
491 int t14[F(__is_floating_point(unsigned char))];
492 //int t15[F(__is_floating_point(char16_t))];
493 //int t16[F(__is_floating_point(char32_t))];
494 int t17[F(__is_floating_point(wchar_t))];
495 int t18[F(__is_floating_point(short))];
496 int t19[F(__is_floating_point(unsigned short))];
497 int t20[F(__is_floating_point(int))];
498 int t21[F(__is_floating_point(unsigned int))];
499 int t22[F(__is_floating_point(long))];
500 int t23[F(__is_floating_point(unsigned long))];
501 int t24[F(__is_floating_point(Union))];
502 int t25[F(__is_floating_point(UnionAr))];
503 int t26[F(__is_floating_point(Derives))];
504 int t27[F(__is_floating_point(ClassType))];
505 int t28[F(__is_floating_point(Enum))];
506 int t29[F(__is_floating_point(void))];
507 int t30[F(__is_floating_point(cvoid))];
508 int t31[F(__is_floating_point(IntArNB))];
509 }
510
511 template <class T>
512 struct AggregateTemplate {
513 T value;
514 };
515
516 template <class T>
517 struct NonAggregateTemplate {
518 T value;
519 NonAggregateTemplate();
520 };
521
is_aggregate()522 void is_aggregate()
523 {
524 constexpr bool TrueAfterCpp11 = __cplusplus > 201103L;
525 constexpr bool TrueAfterCpp14 = __cplusplus > 201402L;
526
527 __is_aggregate(AnIncompleteType); // expected-error {{incomplete type}}
528 __is_aggregate(AnIncompleteType[]); // expected-error {{incomplete type}}
529 __is_aggregate(AnIncompleteType[1]); // expected-error {{incomplete type}}
530 __is_aggregate(AnIncompleteTypeAr); // expected-error {{incomplete type}}
531 __is_aggregate(AnIncompleteTypeArNB); // expected-error {{incomplete type}}
532 __is_aggregate(AnIncompleteTypeArMB); // expected-error {{incomplete type}}
533 __is_aggregate(IncompleteUnion); // expected-error {{incomplete type}}
534
535 static_assert(!__is_aggregate(NonPOD), "");
536 static_assert(__is_aggregate(NonPODAr), "");
537 static_assert(__is_aggregate(NonPODArNB), "");
538 static_assert(__is_aggregate(NonPODArMB), "");
539
540 static_assert(!__is_aggregate(Enum), "");
541 static_assert(__is_aggregate(POD), "");
542 static_assert(__is_aggregate(Empty), "");
543 static_assert(__is_aggregate(EmptyAr), "");
544 static_assert(__is_aggregate(EmptyArNB), "");
545 static_assert(__is_aggregate(EmptyArMB), "");
546 static_assert(!__is_aggregate(void), "");
547 static_assert(!__is_aggregate(const volatile void), "");
548 static_assert(!__is_aggregate(int), "");
549 static_assert(__is_aggregate(IntAr), "");
550 static_assert(__is_aggregate(IntArNB), "");
551 static_assert(__is_aggregate(EmptyUnion), "");
552 static_assert(__is_aggregate(Union), "");
553 static_assert(__is_aggregate(Statics), "");
554 static_assert(__is_aggregate(HasFunc), "");
555 static_assert(__is_aggregate(HasOp), "");
556 static_assert(__is_aggregate(HasAssign), "");
557 static_assert(__is_aggregate(HasAnonymousUnion), "");
558
559 static_assert(__is_aggregate(Derives) == TrueAfterCpp14, "");
560 static_assert(__is_aggregate(DerivesAr), "");
561 static_assert(__is_aggregate(DerivesArNB), "");
562 static_assert(!__is_aggregate(HasCons), "");
563 static_assert(__is_aggregate(HasDefaultCons), "");
564 static_assert(!__is_aggregate(HasExplicitDefaultCons), "");
565 static_assert(!__is_aggregate(HasInheritedCons), "");
566 static_assert(__is_aggregate(HasNoInheritedCons) == TrueAfterCpp14, "");
567 static_assert(__is_aggregate(HasCopyAssign), "");
568 static_assert(!__is_aggregate(NonTrivialDefault), "");
569 static_assert(__is_aggregate(HasDest), "");
570 static_assert(!__is_aggregate(HasPriv), "");
571 static_assert(!__is_aggregate(HasProt), "");
572 static_assert(__is_aggregate(HasRefAggregate), "");
573 static_assert(__is_aggregate(HasNonPOD), "");
574 static_assert(!__is_aggregate(HasVirt), "");
575 static_assert(__is_aggregate(VirtAr), "");
576 static_assert(__is_aggregate(HasInClassInit) == TrueAfterCpp11, "");
577 static_assert(!__is_aggregate(HasPrivateBase), "");
578 static_assert(!__is_aggregate(HasProtectedBase), "");
579 static_assert(!__is_aggregate(HasVirtBase), "");
580
581 static_assert(__is_aggregate(AggregateTemplate<int>), "");
582 static_assert(!__is_aggregate(NonAggregateTemplate<int>), "");
583
584 static_assert(__is_aggregate(Vector), ""); // Extension supported by GCC and Clang
585 static_assert(__is_aggregate(VectorExt), "");
586 static_assert(__is_aggregate(ComplexInt), "");
587 static_assert(__is_aggregate(ComplexFloat), "");
588 }
589
is_arithmetic()590 void is_arithmetic()
591 {
592 int t01[T(__is_arithmetic(float))];
593 int t02[T(__is_arithmetic(double))];
594 int t03[T(__is_arithmetic(long double))];
595 int t11[T(__is_arithmetic(bool))];
596 int t12[T(__is_arithmetic(char))];
597 int t13[T(__is_arithmetic(signed char))];
598 int t14[T(__is_arithmetic(unsigned char))];
599 //int t15[T(__is_arithmetic(char16_t))];
600 //int t16[T(__is_arithmetic(char32_t))];
601 int t17[T(__is_arithmetic(wchar_t))];
602 int t18[T(__is_arithmetic(short))];
603 int t19[T(__is_arithmetic(unsigned short))];
604 int t20[T(__is_arithmetic(int))];
605 int t21[T(__is_arithmetic(unsigned int))];
606 int t22[T(__is_arithmetic(long))];
607 int t23[T(__is_arithmetic(unsigned long))];
608
609 int t24[F(__is_arithmetic(Union))];
610 int t25[F(__is_arithmetic(UnionAr))];
611 int t26[F(__is_arithmetic(Derives))];
612 int t27[F(__is_arithmetic(ClassType))];
613 int t28[F(__is_arithmetic(Enum))];
614 int t29[F(__is_arithmetic(void))];
615 int t30[F(__is_arithmetic(cvoid))];
616 int t31[F(__is_arithmetic(IntArNB))];
617 }
618
is_complete_type()619 void is_complete_type()
620 {
621 int t01[T(__is_complete_type(float))];
622 int t02[T(__is_complete_type(double))];
623 int t03[T(__is_complete_type(long double))];
624 int t11[T(__is_complete_type(bool))];
625 int t12[T(__is_complete_type(char))];
626 int t13[T(__is_complete_type(signed char))];
627 int t14[T(__is_complete_type(unsigned char))];
628 //int t15[T(__is_complete_type(char16_t))];
629 //int t16[T(__is_complete_type(char32_t))];
630 int t17[T(__is_complete_type(wchar_t))];
631 int t18[T(__is_complete_type(short))];
632 int t19[T(__is_complete_type(unsigned short))];
633 int t20[T(__is_complete_type(int))];
634 int t21[T(__is_complete_type(unsigned int))];
635 int t22[T(__is_complete_type(long))];
636 int t23[T(__is_complete_type(unsigned long))];
637 int t24[T(__is_complete_type(ACompleteType))];
638
639 int t30[F(__is_complete_type(AnIncompleteType))];
640 }
641
is_void()642 void is_void()
643 {
644 int t01[T(__is_void(void))];
645 int t02[T(__is_void(cvoid))];
646
647 int t10[F(__is_void(float))];
648 int t11[F(__is_void(double))];
649 int t12[F(__is_void(long double))];
650 int t13[F(__is_void(bool))];
651 int t14[F(__is_void(char))];
652 int t15[F(__is_void(signed char))];
653 int t16[F(__is_void(unsigned char))];
654 int t17[F(__is_void(wchar_t))];
655 int t18[F(__is_void(short))];
656 int t19[F(__is_void(unsigned short))];
657 int t20[F(__is_void(int))];
658 int t21[F(__is_void(unsigned int))];
659 int t22[F(__is_void(long))];
660 int t23[F(__is_void(unsigned long))];
661 int t24[F(__is_void(Union))];
662 int t25[F(__is_void(UnionAr))];
663 int t26[F(__is_void(Derives))];
664 int t27[F(__is_void(ClassType))];
665 int t28[F(__is_void(Enum))];
666 int t29[F(__is_void(IntArNB))];
667 int t30[F(__is_void(void*))];
668 int t31[F(__is_void(cvoid*))];
669 }
670
is_array()671 void is_array()
672 {
673 int t01[T(__is_array(IntAr))];
674 int t02[T(__is_array(IntArNB))];
675 int t03[T(__is_array(UnionAr))];
676
677 int t10[F(__is_array(void))];
678 int t11[F(__is_array(cvoid))];
679 int t12[F(__is_array(float))];
680 int t13[F(__is_array(double))];
681 int t14[F(__is_array(long double))];
682 int t15[F(__is_array(bool))];
683 int t16[F(__is_array(char))];
684 int t17[F(__is_array(signed char))];
685 int t18[F(__is_array(unsigned char))];
686 int t19[F(__is_array(wchar_t))];
687 int t20[F(__is_array(short))];
688 int t21[F(__is_array(unsigned short))];
689 int t22[F(__is_array(int))];
690 int t23[F(__is_array(unsigned int))];
691 int t24[F(__is_array(long))];
692 int t25[F(__is_array(unsigned long))];
693 int t26[F(__is_array(Union))];
694 int t27[F(__is_array(Derives))];
695 int t28[F(__is_array(ClassType))];
696 int t29[F(__is_array(Enum))];
697 int t30[F(__is_array(void*))];
698 int t31[F(__is_array(cvoid*))];
699 }
700
tmpl_func(T &)701 template <typename T> void tmpl_func(T&) {}
702
703 template <typename T> struct type_wrapper {
704 typedef T type;
705 typedef T* ptrtype;
706 typedef T& reftype;
707 };
708
is_function()709 void is_function()
710 {
711 int t01[T(__is_function(type_wrapper<void(void)>::type))];
712 int t02[T(__is_function(typeof(tmpl_func<int>)))];
713
714 typedef void (*ptr_to_func_type)(void);
715
716 int t10[F(__is_function(void))];
717 int t11[F(__is_function(cvoid))];
718 int t12[F(__is_function(float))];
719 int t13[F(__is_function(double))];
720 int t14[F(__is_function(long double))];
721 int t15[F(__is_function(bool))];
722 int t16[F(__is_function(char))];
723 int t17[F(__is_function(signed char))];
724 int t18[F(__is_function(unsigned char))];
725 int t19[F(__is_function(wchar_t))];
726 int t20[F(__is_function(short))];
727 int t21[F(__is_function(unsigned short))];
728 int t22[F(__is_function(int))];
729 int t23[F(__is_function(unsigned int))];
730 int t24[F(__is_function(long))];
731 int t25[F(__is_function(unsigned long))];
732 int t26[F(__is_function(Union))];
733 int t27[F(__is_function(Derives))];
734 int t28[F(__is_function(ClassType))];
735 int t29[F(__is_function(Enum))];
736 int t30[F(__is_function(void*))];
737 int t31[F(__is_function(cvoid*))];
738 int t32[F(__is_function(void(*)()))];
739 int t33[F(__is_function(ptr_to_func_type))];
740 int t34[F(__is_function(type_wrapper<void(void)>::ptrtype))];
741 int t35[F(__is_function(type_wrapper<void(void)>::reftype))];
742 }
743
is_reference()744 void is_reference()
745 {
746 int t01[T(__is_reference(int&))];
747 int t02[T(__is_reference(const int&))];
748 int t03[T(__is_reference(void *&))];
749
750 int t10[F(__is_reference(int))];
751 int t11[F(__is_reference(const int))];
752 int t12[F(__is_reference(void *))];
753 }
754
is_lvalue_reference()755 void is_lvalue_reference()
756 {
757 int t01[T(__is_lvalue_reference(int&))];
758 int t02[T(__is_lvalue_reference(void *&))];
759 int t03[T(__is_lvalue_reference(const int&))];
760 int t04[T(__is_lvalue_reference(void * const &))];
761
762 int t10[F(__is_lvalue_reference(int))];
763 int t11[F(__is_lvalue_reference(const int))];
764 int t12[F(__is_lvalue_reference(void *))];
765 }
766
767 #if __has_feature(cxx_rvalue_references)
768
is_rvalue_reference()769 void is_rvalue_reference()
770 {
771 int t01[T(__is_rvalue_reference(const int&&))];
772 int t02[T(__is_rvalue_reference(void * const &&))];
773
774 int t10[F(__is_rvalue_reference(int&))];
775 int t11[F(__is_rvalue_reference(void *&))];
776 int t12[F(__is_rvalue_reference(const int&))];
777 int t13[F(__is_rvalue_reference(void * const &))];
778 int t14[F(__is_rvalue_reference(int))];
779 int t15[F(__is_rvalue_reference(const int))];
780 int t16[F(__is_rvalue_reference(void *))];
781 }
782
783 #endif
784
is_fundamental()785 void is_fundamental()
786 {
787 int t01[T(__is_fundamental(float))];
788 int t02[T(__is_fundamental(double))];
789 int t03[T(__is_fundamental(long double))];
790 int t11[T(__is_fundamental(bool))];
791 int t12[T(__is_fundamental(char))];
792 int t13[T(__is_fundamental(signed char))];
793 int t14[T(__is_fundamental(unsigned char))];
794 //int t15[T(__is_fundamental(char16_t))];
795 //int t16[T(__is_fundamental(char32_t))];
796 int t17[T(__is_fundamental(wchar_t))];
797 int t18[T(__is_fundamental(short))];
798 int t19[T(__is_fundamental(unsigned short))];
799 int t20[T(__is_fundamental(int))];
800 int t21[T(__is_fundamental(unsigned int))];
801 int t22[T(__is_fundamental(long))];
802 int t23[T(__is_fundamental(unsigned long))];
803 int t24[T(__is_fundamental(void))];
804 int t25[T(__is_fundamental(cvoid))];
805 int t26[T(__is_fundamental(decltype(nullptr)))];
806
807 int t30[F(__is_fundamental(Union))];
808 int t31[F(__is_fundamental(UnionAr))];
809 int t32[F(__is_fundamental(Derives))];
810 int t33[F(__is_fundamental(ClassType))];
811 int t34[F(__is_fundamental(Enum))];
812 int t35[F(__is_fundamental(IntArNB))];
813 }
814
is_object()815 void is_object()
816 {
817 int t01[T(__is_object(int))];
818 int t02[T(__is_object(int *))];
819 int t03[T(__is_object(void *))];
820 int t04[T(__is_object(Union))];
821 int t05[T(__is_object(UnionAr))];
822 int t06[T(__is_object(ClassType))];
823 int t07[T(__is_object(Enum))];
824
825 int t10[F(__is_object(type_wrapper<void(void)>::type))];
826 int t11[F(__is_object(int&))];
827 int t12[F(__is_object(void))];
828 }
829
is_scalar()830 void is_scalar()
831 {
832 int t01[T(__is_scalar(float))];
833 int t02[T(__is_scalar(double))];
834 int t03[T(__is_scalar(long double))];
835 int t04[T(__is_scalar(bool))];
836 int t05[T(__is_scalar(char))];
837 int t06[T(__is_scalar(signed char))];
838 int t07[T(__is_scalar(unsigned char))];
839 int t08[T(__is_scalar(wchar_t))];
840 int t09[T(__is_scalar(short))];
841 int t10[T(__is_scalar(unsigned short))];
842 int t11[T(__is_scalar(int))];
843 int t12[T(__is_scalar(unsigned int))];
844 int t13[T(__is_scalar(long))];
845 int t14[T(__is_scalar(unsigned long))];
846 int t15[T(__is_scalar(Enum))];
847 int t16[T(__is_scalar(void*))];
848 int t17[T(__is_scalar(cvoid*))];
849
850 int t20[F(__is_scalar(void))];
851 int t21[F(__is_scalar(cvoid))];
852 int t22[F(__is_scalar(Union))];
853 int t23[F(__is_scalar(UnionAr))];
854 int t24[F(__is_scalar(Derives))];
855 int t25[F(__is_scalar(ClassType))];
856 int t26[F(__is_scalar(IntArNB))];
857 }
858
859 struct StructWithMembers {
860 int member;
methodStructWithMembers861 void method() {}
862 };
863
is_compound()864 void is_compound()
865 {
866 int t01[T(__is_compound(void*))];
867 int t02[T(__is_compound(cvoid*))];
868 int t03[T(__is_compound(void (*)()))];
869 int t04[T(__is_compound(int StructWithMembers::*))];
870 int t05[T(__is_compound(void (StructWithMembers::*)()))];
871 int t06[T(__is_compound(int&))];
872 int t07[T(__is_compound(Union))];
873 int t08[T(__is_compound(UnionAr))];
874 int t09[T(__is_compound(Derives))];
875 int t10[T(__is_compound(ClassType))];
876 int t11[T(__is_compound(IntArNB))];
877 int t12[T(__is_compound(Enum))];
878
879 int t20[F(__is_compound(float))];
880 int t21[F(__is_compound(double))];
881 int t22[F(__is_compound(long double))];
882 int t23[F(__is_compound(bool))];
883 int t24[F(__is_compound(char))];
884 int t25[F(__is_compound(signed char))];
885 int t26[F(__is_compound(unsigned char))];
886 int t27[F(__is_compound(wchar_t))];
887 int t28[F(__is_compound(short))];
888 int t29[F(__is_compound(unsigned short))];
889 int t30[F(__is_compound(int))];
890 int t31[F(__is_compound(unsigned int))];
891 int t32[F(__is_compound(long))];
892 int t33[F(__is_compound(unsigned long))];
893 int t34[F(__is_compound(void))];
894 int t35[F(__is_compound(cvoid))];
895 }
896
is_pointer()897 void is_pointer()
898 {
899 StructWithMembers x;
900
901 int t01[T(__is_pointer(void*))];
902 int t02[T(__is_pointer(cvoid*))];
903 int t03[T(__is_pointer(cvoid*))];
904 int t04[T(__is_pointer(char*))];
905 int t05[T(__is_pointer(int*))];
906 int t06[T(__is_pointer(int**))];
907 int t07[T(__is_pointer(ClassType*))];
908 int t08[T(__is_pointer(Derives*))];
909 int t09[T(__is_pointer(Enum*))];
910 int t10[T(__is_pointer(IntArNB*))];
911 int t11[T(__is_pointer(Union*))];
912 int t12[T(__is_pointer(UnionAr*))];
913 int t13[T(__is_pointer(StructWithMembers*))];
914 int t14[T(__is_pointer(void (*)()))];
915
916 int t20[F(__is_pointer(void))];
917 int t21[F(__is_pointer(cvoid))];
918 int t22[F(__is_pointer(cvoid))];
919 int t23[F(__is_pointer(char))];
920 int t24[F(__is_pointer(int))];
921 int t25[F(__is_pointer(int))];
922 int t26[F(__is_pointer(ClassType))];
923 int t27[F(__is_pointer(Derives))];
924 int t28[F(__is_pointer(Enum))];
925 int t29[F(__is_pointer(IntArNB))];
926 int t30[F(__is_pointer(Union))];
927 int t31[F(__is_pointer(UnionAr))];
928 int t32[F(__is_pointer(StructWithMembers))];
929 int t33[F(__is_pointer(int StructWithMembers::*))];
930 int t34[F(__is_pointer(void (StructWithMembers::*) ()))];
931 }
932
is_member_object_pointer()933 void is_member_object_pointer()
934 {
935 StructWithMembers x;
936
937 int t01[T(__is_member_object_pointer(int StructWithMembers::*))];
938
939 int t10[F(__is_member_object_pointer(void (StructWithMembers::*) ()))];
940 int t11[F(__is_member_object_pointer(void*))];
941 int t12[F(__is_member_object_pointer(cvoid*))];
942 int t13[F(__is_member_object_pointer(cvoid*))];
943 int t14[F(__is_member_object_pointer(char*))];
944 int t15[F(__is_member_object_pointer(int*))];
945 int t16[F(__is_member_object_pointer(int**))];
946 int t17[F(__is_member_object_pointer(ClassType*))];
947 int t18[F(__is_member_object_pointer(Derives*))];
948 int t19[F(__is_member_object_pointer(Enum*))];
949 int t20[F(__is_member_object_pointer(IntArNB*))];
950 int t21[F(__is_member_object_pointer(Union*))];
951 int t22[F(__is_member_object_pointer(UnionAr*))];
952 int t23[F(__is_member_object_pointer(StructWithMembers*))];
953 int t24[F(__is_member_object_pointer(void))];
954 int t25[F(__is_member_object_pointer(cvoid))];
955 int t26[F(__is_member_object_pointer(cvoid))];
956 int t27[F(__is_member_object_pointer(char))];
957 int t28[F(__is_member_object_pointer(int))];
958 int t29[F(__is_member_object_pointer(int))];
959 int t30[F(__is_member_object_pointer(ClassType))];
960 int t31[F(__is_member_object_pointer(Derives))];
961 int t32[F(__is_member_object_pointer(Enum))];
962 int t33[F(__is_member_object_pointer(IntArNB))];
963 int t34[F(__is_member_object_pointer(Union))];
964 int t35[F(__is_member_object_pointer(UnionAr))];
965 int t36[F(__is_member_object_pointer(StructWithMembers))];
966 int t37[F(__is_member_object_pointer(void (*)()))];
967 }
968
is_member_function_pointer()969 void is_member_function_pointer()
970 {
971 StructWithMembers x;
972
973 int t01[T(__is_member_function_pointer(void (StructWithMembers::*) ()))];
974
975 int t10[F(__is_member_function_pointer(int StructWithMembers::*))];
976 int t11[F(__is_member_function_pointer(void*))];
977 int t12[F(__is_member_function_pointer(cvoid*))];
978 int t13[F(__is_member_function_pointer(cvoid*))];
979 int t14[F(__is_member_function_pointer(char*))];
980 int t15[F(__is_member_function_pointer(int*))];
981 int t16[F(__is_member_function_pointer(int**))];
982 int t17[F(__is_member_function_pointer(ClassType*))];
983 int t18[F(__is_member_function_pointer(Derives*))];
984 int t19[F(__is_member_function_pointer(Enum*))];
985 int t20[F(__is_member_function_pointer(IntArNB*))];
986 int t21[F(__is_member_function_pointer(Union*))];
987 int t22[F(__is_member_function_pointer(UnionAr*))];
988 int t23[F(__is_member_function_pointer(StructWithMembers*))];
989 int t24[F(__is_member_function_pointer(void))];
990 int t25[F(__is_member_function_pointer(cvoid))];
991 int t26[F(__is_member_function_pointer(cvoid))];
992 int t27[F(__is_member_function_pointer(char))];
993 int t28[F(__is_member_function_pointer(int))];
994 int t29[F(__is_member_function_pointer(int))];
995 int t30[F(__is_member_function_pointer(ClassType))];
996 int t31[F(__is_member_function_pointer(Derives))];
997 int t32[F(__is_member_function_pointer(Enum))];
998 int t33[F(__is_member_function_pointer(IntArNB))];
999 int t34[F(__is_member_function_pointer(Union))];
1000 int t35[F(__is_member_function_pointer(UnionAr))];
1001 int t36[F(__is_member_function_pointer(StructWithMembers))];
1002 int t37[F(__is_member_function_pointer(void (*)()))];
1003 }
1004
is_member_pointer()1005 void is_member_pointer()
1006 {
1007 StructWithMembers x;
1008
1009 int t01[T(__is_member_pointer(int StructWithMembers::*))];
1010 int t02[T(__is_member_pointer(void (StructWithMembers::*) ()))];
1011
1012 int t10[F(__is_member_pointer(void*))];
1013 int t11[F(__is_member_pointer(cvoid*))];
1014 int t12[F(__is_member_pointer(cvoid*))];
1015 int t13[F(__is_member_pointer(char*))];
1016 int t14[F(__is_member_pointer(int*))];
1017 int t15[F(__is_member_pointer(int**))];
1018 int t16[F(__is_member_pointer(ClassType*))];
1019 int t17[F(__is_member_pointer(Derives*))];
1020 int t18[F(__is_member_pointer(Enum*))];
1021 int t19[F(__is_member_pointer(IntArNB*))];
1022 int t20[F(__is_member_pointer(Union*))];
1023 int t21[F(__is_member_pointer(UnionAr*))];
1024 int t22[F(__is_member_pointer(StructWithMembers*))];
1025 int t23[F(__is_member_pointer(void))];
1026 int t24[F(__is_member_pointer(cvoid))];
1027 int t25[F(__is_member_pointer(cvoid))];
1028 int t26[F(__is_member_pointer(char))];
1029 int t27[F(__is_member_pointer(int))];
1030 int t28[F(__is_member_pointer(int))];
1031 int t29[F(__is_member_pointer(ClassType))];
1032 int t30[F(__is_member_pointer(Derives))];
1033 int t31[F(__is_member_pointer(Enum))];
1034 int t32[F(__is_member_pointer(IntArNB))];
1035 int t33[F(__is_member_pointer(Union))];
1036 int t34[F(__is_member_pointer(UnionAr))];
1037 int t35[F(__is_member_pointer(StructWithMembers))];
1038 int t36[F(__is_member_pointer(void (*)()))];
1039 }
1040
is_const()1041 void is_const()
1042 {
1043 int t01[T(__is_const(cvoid))];
1044 int t02[T(__is_const(const char))];
1045 int t03[T(__is_const(const int))];
1046 int t04[T(__is_const(const long))];
1047 int t05[T(__is_const(const short))];
1048 int t06[T(__is_const(const signed char))];
1049 int t07[T(__is_const(const wchar_t))];
1050 int t08[T(__is_const(const bool))];
1051 int t09[T(__is_const(const float))];
1052 int t10[T(__is_const(const double))];
1053 int t11[T(__is_const(const long double))];
1054 int t12[T(__is_const(const unsigned char))];
1055 int t13[T(__is_const(const unsigned int))];
1056 int t14[T(__is_const(const unsigned long long))];
1057 int t15[T(__is_const(const unsigned long))];
1058 int t16[T(__is_const(const unsigned short))];
1059 int t17[T(__is_const(const void))];
1060 int t18[T(__is_const(const ClassType))];
1061 int t19[T(__is_const(const Derives))];
1062 int t20[T(__is_const(const Enum))];
1063 int t21[T(__is_const(const IntArNB))];
1064 int t22[T(__is_const(const Union))];
1065 int t23[T(__is_const(const UnionAr))];
1066
1067 int t30[F(__is_const(char))];
1068 int t31[F(__is_const(int))];
1069 int t32[F(__is_const(long))];
1070 int t33[F(__is_const(short))];
1071 int t34[F(__is_const(signed char))];
1072 int t35[F(__is_const(wchar_t))];
1073 int t36[F(__is_const(bool))];
1074 int t37[F(__is_const(float))];
1075 int t38[F(__is_const(double))];
1076 int t39[F(__is_const(long double))];
1077 int t40[F(__is_const(unsigned char))];
1078 int t41[F(__is_const(unsigned int))];
1079 int t42[F(__is_const(unsigned long long))];
1080 int t43[F(__is_const(unsigned long))];
1081 int t44[F(__is_const(unsigned short))];
1082 int t45[F(__is_const(void))];
1083 int t46[F(__is_const(ClassType))];
1084 int t47[F(__is_const(Derives))];
1085 int t48[F(__is_const(Enum))];
1086 int t49[F(__is_const(IntArNB))];
1087 int t50[F(__is_const(Union))];
1088 int t51[F(__is_const(UnionAr))];
1089 }
1090
is_volatile()1091 void is_volatile()
1092 {
1093 int t02[T(__is_volatile(volatile char))];
1094 int t03[T(__is_volatile(volatile int))];
1095 int t04[T(__is_volatile(volatile long))];
1096 int t05[T(__is_volatile(volatile short))];
1097 int t06[T(__is_volatile(volatile signed char))];
1098 int t07[T(__is_volatile(volatile wchar_t))];
1099 int t08[T(__is_volatile(volatile bool))];
1100 int t09[T(__is_volatile(volatile float))];
1101 int t10[T(__is_volatile(volatile double))];
1102 int t11[T(__is_volatile(volatile long double))];
1103 int t12[T(__is_volatile(volatile unsigned char))];
1104 int t13[T(__is_volatile(volatile unsigned int))];
1105 int t14[T(__is_volatile(volatile unsigned long long))];
1106 int t15[T(__is_volatile(volatile unsigned long))];
1107 int t16[T(__is_volatile(volatile unsigned short))];
1108 int t17[T(__is_volatile(volatile void))];
1109 int t18[T(__is_volatile(volatile ClassType))];
1110 int t19[T(__is_volatile(volatile Derives))];
1111 int t20[T(__is_volatile(volatile Enum))];
1112 int t21[T(__is_volatile(volatile IntArNB))];
1113 int t22[T(__is_volatile(volatile Union))];
1114 int t23[T(__is_volatile(volatile UnionAr))];
1115
1116 int t30[F(__is_volatile(char))];
1117 int t31[F(__is_volatile(int))];
1118 int t32[F(__is_volatile(long))];
1119 int t33[F(__is_volatile(short))];
1120 int t34[F(__is_volatile(signed char))];
1121 int t35[F(__is_volatile(wchar_t))];
1122 int t36[F(__is_volatile(bool))];
1123 int t37[F(__is_volatile(float))];
1124 int t38[F(__is_volatile(double))];
1125 int t39[F(__is_volatile(long double))];
1126 int t40[F(__is_volatile(unsigned char))];
1127 int t41[F(__is_volatile(unsigned int))];
1128 int t42[F(__is_volatile(unsigned long long))];
1129 int t43[F(__is_volatile(unsigned long))];
1130 int t44[F(__is_volatile(unsigned short))];
1131 int t45[F(__is_volatile(void))];
1132 int t46[F(__is_volatile(ClassType))];
1133 int t47[F(__is_volatile(Derives))];
1134 int t48[F(__is_volatile(Enum))];
1135 int t49[F(__is_volatile(IntArNB))];
1136 int t50[F(__is_volatile(Union))];
1137 int t51[F(__is_volatile(UnionAr))];
1138 }
1139
1140 struct TrivialStruct {
1141 int member;
1142 };
1143
1144 struct NonTrivialStruct {
1145 int member;
NonTrivialStructNonTrivialStruct1146 NonTrivialStruct() {
1147 member = 0;
1148 }
1149 };
1150
1151 struct SuperNonTrivialStruct {
SuperNonTrivialStructSuperNonTrivialStruct1152 SuperNonTrivialStruct() { }
~SuperNonTrivialStructSuperNonTrivialStruct1153 ~SuperNonTrivialStruct() { }
1154 };
1155
1156 struct NonTCStruct {
NonTCStructNonTCStruct1157 NonTCStruct(const NonTCStruct&) {}
1158 };
1159
1160 struct AllDefaulted {
1161 AllDefaulted() = default;
1162 AllDefaulted(const AllDefaulted &) = default;
1163 AllDefaulted(AllDefaulted &&) = default;
1164 AllDefaulted &operator=(const AllDefaulted &) = default;
1165 AllDefaulted &operator=(AllDefaulted &&) = default;
1166 ~AllDefaulted() = default;
1167 };
1168
1169 struct NoDefaultMoveAssignDueToUDCopyCtor {
1170 NoDefaultMoveAssignDueToUDCopyCtor(const NoDefaultMoveAssignDueToUDCopyCtor&);
1171 };
1172
1173 struct NoDefaultMoveAssignDueToUDCopyAssign {
1174 NoDefaultMoveAssignDueToUDCopyAssign& operator=(
1175 const NoDefaultMoveAssignDueToUDCopyAssign&);
1176 };
1177
1178 struct NoDefaultMoveAssignDueToDtor {
1179 ~NoDefaultMoveAssignDueToDtor();
1180 };
1181
1182 struct AllDeleted {
1183 AllDeleted() = delete;
1184 AllDeleted(const AllDeleted &) = delete;
1185 AllDeleted(AllDeleted &&) = delete;
1186 AllDeleted &operator=(const AllDeleted &) = delete;
1187 AllDeleted &operator=(AllDeleted &&) = delete;
1188 ~AllDeleted() = delete;
1189 };
1190
1191 struct ExtDefaulted {
1192 ExtDefaulted();
1193 ExtDefaulted(const ExtDefaulted &);
1194 ExtDefaulted(ExtDefaulted &&);
1195 ExtDefaulted &operator=(const ExtDefaulted &);
1196 ExtDefaulted &operator=(ExtDefaulted &&);
1197 ~ExtDefaulted();
1198 };
1199
1200 // Despite being defaulted, these functions are not trivial.
1201 ExtDefaulted::ExtDefaulted() = default;
1202 ExtDefaulted::ExtDefaulted(const ExtDefaulted &) = default;
1203 ExtDefaulted::ExtDefaulted(ExtDefaulted &&) = default;
1204 ExtDefaulted &ExtDefaulted::operator=(const ExtDefaulted &) = default;
1205 ExtDefaulted &ExtDefaulted::operator=(ExtDefaulted &&) = default;
1206 ExtDefaulted::~ExtDefaulted() = default;
1207
is_trivial2()1208 void is_trivial2()
1209 {
1210 int t01[T(__is_trivial(char))];
1211 int t02[T(__is_trivial(int))];
1212 int t03[T(__is_trivial(long))];
1213 int t04[T(__is_trivial(short))];
1214 int t05[T(__is_trivial(signed char))];
1215 int t06[T(__is_trivial(wchar_t))];
1216 int t07[T(__is_trivial(bool))];
1217 int t08[T(__is_trivial(float))];
1218 int t09[T(__is_trivial(double))];
1219 int t10[T(__is_trivial(long double))];
1220 int t11[T(__is_trivial(unsigned char))];
1221 int t12[T(__is_trivial(unsigned int))];
1222 int t13[T(__is_trivial(unsigned long long))];
1223 int t14[T(__is_trivial(unsigned long))];
1224 int t15[T(__is_trivial(unsigned short))];
1225 int t16[T(__is_trivial(ClassType))];
1226 int t17[T(__is_trivial(Derives))];
1227 int t18[T(__is_trivial(Enum))];
1228 int t19[T(__is_trivial(IntAr))];
1229 int t20[T(__is_trivial(Union))];
1230 int t21[T(__is_trivial(UnionAr))];
1231 int t22[T(__is_trivial(TrivialStruct))];
1232 int t23[T(__is_trivial(AllDefaulted))];
1233 int t24[T(__is_trivial(AllDeleted))];
1234
1235 int t30[F(__is_trivial(void))];
1236 int t31[F(__is_trivial(NonTrivialStruct))];
1237 int t32[F(__is_trivial(SuperNonTrivialStruct))];
1238 int t33[F(__is_trivial(NonTCStruct))];
1239 int t34[F(__is_trivial(ExtDefaulted))];
1240
1241 int t40[T(__is_trivial(ACompleteType))];
1242 int t41[F(__is_trivial(AnIncompleteType))]; // expected-error {{incomplete type}}
1243 int t42[F(__is_trivial(AnIncompleteType[]))]; // expected-error {{incomplete type}}
1244 int t43[F(__is_trivial(AnIncompleteType[1]))]; // expected-error {{incomplete type}}
1245 int t44[F(__is_trivial(void))];
1246 int t45[F(__is_trivial(const volatile void))];
1247 }
1248
is_trivially_copyable2()1249 void is_trivially_copyable2()
1250 {
1251 int t01[T(__is_trivially_copyable(char))];
1252 int t02[T(__is_trivially_copyable(int))];
1253 int t03[T(__is_trivially_copyable(long))];
1254 int t04[T(__is_trivially_copyable(short))];
1255 int t05[T(__is_trivially_copyable(signed char))];
1256 int t06[T(__is_trivially_copyable(wchar_t))];
1257 int t07[T(__is_trivially_copyable(bool))];
1258 int t08[T(__is_trivially_copyable(float))];
1259 int t09[T(__is_trivially_copyable(double))];
1260 int t10[T(__is_trivially_copyable(long double))];
1261 int t11[T(__is_trivially_copyable(unsigned char))];
1262 int t12[T(__is_trivially_copyable(unsigned int))];
1263 int t13[T(__is_trivially_copyable(unsigned long long))];
1264 int t14[T(__is_trivially_copyable(unsigned long))];
1265 int t15[T(__is_trivially_copyable(unsigned short))];
1266 int t16[T(__is_trivially_copyable(ClassType))];
1267 int t17[T(__is_trivially_copyable(Derives))];
1268 int t18[T(__is_trivially_copyable(Enum))];
1269 int t19[T(__is_trivially_copyable(IntAr))];
1270 int t20[T(__is_trivially_copyable(Union))];
1271 int t21[T(__is_trivially_copyable(UnionAr))];
1272 int t22[T(__is_trivially_copyable(TrivialStruct))];
1273 int t23[T(__is_trivially_copyable(NonTrivialStruct))];
1274 int t24[T(__is_trivially_copyable(AllDefaulted))];
1275 int t25[T(__is_trivially_copyable(AllDeleted))];
1276
1277 int t30[F(__is_trivially_copyable(void))];
1278 int t31[F(__is_trivially_copyable(SuperNonTrivialStruct))];
1279 int t32[F(__is_trivially_copyable(NonTCStruct))];
1280 int t33[F(__is_trivially_copyable(ExtDefaulted))];
1281
1282 int t34[T(__is_trivially_copyable(const int))];
1283 int t35[T(__is_trivially_copyable(volatile int))];
1284
1285 int t40[T(__is_trivially_copyable(ACompleteType))];
1286 int t41[F(__is_trivially_copyable(AnIncompleteType))]; // expected-error {{incomplete type}}
1287 int t42[F(__is_trivially_copyable(AnIncompleteType[]))]; // expected-error {{incomplete type}}
1288 int t43[F(__is_trivially_copyable(AnIncompleteType[1]))]; // expected-error {{incomplete type}}
1289 int t44[F(__is_trivially_copyable(void))];
1290 int t45[F(__is_trivially_copyable(const volatile void))];
1291 }
1292
1293 struct CStruct {
1294 int one;
1295 int two;
1296 };
1297
1298 struct CEmptyStruct {};
1299
1300 struct CppEmptyStruct : CStruct {};
1301 struct CppStructStandard : CEmptyStruct {
1302 int three;
1303 int four;
1304 };
1305 struct CppStructNonStandardByBase : CStruct {
1306 int three;
1307 int four;
1308 };
1309 struct CppStructNonStandardByVirt : CStruct {
methodCppStructNonStandardByVirt1310 virtual void method() {}
1311 };
1312 struct CppStructNonStandardByMemb : CStruct {
1313 CppStructNonStandardByVirt member;
1314 };
1315 struct CppStructNonStandardByProt : CStruct {
1316 int five;
1317 protected:
1318 int six;
1319 };
1320 struct CppStructNonStandardByVirtBase : virtual CStruct {
1321 };
1322 struct CppStructNonStandardBySameBase : CEmptyStruct {
1323 CEmptyStruct member;
1324 };
1325 struct CppStructNonStandardBy2ndVirtBase : CEmptyStruct {
1326 CEmptyStruct member;
1327 };
1328
is_standard_layout()1329 void is_standard_layout()
1330 {
1331 typedef const int ConstInt;
1332 typedef ConstInt ConstIntAr[4];
1333 typedef CppStructStandard CppStructStandardAr[4];
1334
1335 int t01[T(__is_standard_layout(int))];
1336 int t02[T(__is_standard_layout(ConstInt))];
1337 int t03[T(__is_standard_layout(ConstIntAr))];
1338 int t04[T(__is_standard_layout(CStruct))];
1339 int t05[T(__is_standard_layout(CppStructStandard))];
1340 int t06[T(__is_standard_layout(CppStructStandardAr))];
1341 int t07[T(__is_standard_layout(Vector))];
1342 int t08[T(__is_standard_layout(VectorExt))];
1343
1344 typedef CppStructNonStandardByBase CppStructNonStandardByBaseAr[4];
1345
1346 int t10[F(__is_standard_layout(CppStructNonStandardByVirt))];
1347 int t11[F(__is_standard_layout(CppStructNonStandardByMemb))];
1348 int t12[F(__is_standard_layout(CppStructNonStandardByProt))];
1349 int t13[F(__is_standard_layout(CppStructNonStandardByVirtBase))];
1350 int t14[F(__is_standard_layout(CppStructNonStandardByBase))];
1351 int t15[F(__is_standard_layout(CppStructNonStandardByBaseAr))];
1352 int t16[F(__is_standard_layout(CppStructNonStandardBySameBase))];
1353 int t17[F(__is_standard_layout(CppStructNonStandardBy2ndVirtBase))];
1354
1355 int t40[T(__is_standard_layout(ACompleteType))];
1356 int t41[F(__is_standard_layout(AnIncompleteType))]; // expected-error {{incomplete type}}
1357 int t42[F(__is_standard_layout(AnIncompleteType[]))]; // expected-error {{incomplete type}}
1358 int t43[F(__is_standard_layout(AnIncompleteType[1]))]; // expected-error {{incomplete type}}
1359 int t44[F(__is_standard_layout(void))];
1360 int t45[F(__is_standard_layout(const volatile void))];
1361
1362 struct HasAnonEmptyBitfield { int : 0; };
1363 struct HasAnonBitfield { int : 4; };
1364 struct DerivesFromBitfield : HasAnonBitfield {};
1365 struct DerivesFromBitfieldWithBitfield : HasAnonBitfield { int : 5; };
1366 struct DerivesFromBitfieldTwice : DerivesFromBitfield, HasAnonEmptyBitfield {};
1367
1368 int t50[T(__is_standard_layout(HasAnonEmptyBitfield))];
1369 int t51[T(__is_standard_layout(HasAnonBitfield))];
1370 int t52[T(__is_standard_layout(DerivesFromBitfield))];
1371 int t53[F(__is_standard_layout(DerivesFromBitfieldWithBitfield))];
1372 int t54[F(__is_standard_layout(DerivesFromBitfieldTwice))];
1373
1374 struct Empty {};
1375 struct HasEmptyBase : Empty {};
1376 struct HoldsEmptyBase { Empty e; };
1377 struct HasRepeatedEmptyBase : Empty, HasEmptyBase {}; // expected-warning {{inaccessible}}
1378 struct HasEmptyBaseAsMember : Empty { Empty e; };
1379 struct HasEmptyBaseAsSubobjectOfMember1 : Empty { HoldsEmptyBase e; };
1380 struct HasEmptyBaseAsSubobjectOfMember2 : Empty { HasEmptyBase e; };
1381 struct HasEmptyBaseAsSubobjectOfMember3 : Empty { HoldsEmptyBase e[2]; };
1382 struct HasEmptyIndirectBaseAsMember : HasEmptyBase { Empty e; };
1383 struct HasEmptyIndirectBaseAsSecondMember : HasEmptyBase { int n; Empty e; };
1384 struct HasEmptyIndirectBaseAfterBitfield : HasEmptyBase { int : 4; Empty e; };
1385
1386 int t60[T(__is_standard_layout(Empty))];
1387 int t61[T(__is_standard_layout(HasEmptyBase))];
1388 int t62[F(__is_standard_layout(HasRepeatedEmptyBase))];
1389 int t63[F(__is_standard_layout(HasEmptyBaseAsMember))];
1390 int t64[F(__is_standard_layout(HasEmptyBaseAsSubobjectOfMember1))];
1391 int t65[T(__is_standard_layout(HasEmptyBaseAsSubobjectOfMember2))]; // FIXME: standard bug?
1392 int t66[F(__is_standard_layout(HasEmptyBaseAsSubobjectOfMember3))];
1393 int t67[F(__is_standard_layout(HasEmptyIndirectBaseAsMember))];
1394 int t68[T(__is_standard_layout(HasEmptyIndirectBaseAsSecondMember))];
1395 int t69[F(__is_standard_layout(HasEmptyIndirectBaseAfterBitfield))]; // FIXME: standard bug?
1396
1397 struct StructWithEmptyFields {
1398 int n;
1399 HoldsEmptyBase e[3];
1400 };
1401 union UnionWithEmptyFields {
1402 int n;
1403 HoldsEmptyBase e[3];
1404 };
1405 struct HasEmptyIndirectBaseAsSecondStructMember : HasEmptyBase {
1406 StructWithEmptyFields u;
1407 };
1408 struct HasEmptyIndirectBaseAsSecondUnionMember : HasEmptyBase {
1409 UnionWithEmptyFields u;
1410 };
1411
1412 int t70[T(__is_standard_layout(HasEmptyIndirectBaseAsSecondStructMember))];
1413 int t71[F(__is_standard_layout(HasEmptyIndirectBaseAsSecondUnionMember))];
1414 }
1415
is_signed()1416 void is_signed()
1417 {
1418 //int t01[T(__is_signed(char))];
1419 int t02[T(__is_signed(int))];
1420 int t03[T(__is_signed(long))];
1421 int t04[T(__is_signed(short))];
1422 int t05[T(__is_signed(signed char))];
1423 int t06[T(__is_signed(wchar_t))];
1424 int t07[T(__is_signed(float))];
1425 int t08[T(__is_signed(double))];
1426 int t09[T(__is_signed(long double))];
1427
1428 int t13[F(__is_signed(bool))];
1429 int t14[F(__is_signed(cvoid))];
1430 int t15[F(__is_signed(unsigned char))];
1431 int t16[F(__is_signed(unsigned int))];
1432 int t17[F(__is_signed(unsigned long long))];
1433 int t18[F(__is_signed(unsigned long))];
1434 int t19[F(__is_signed(unsigned short))];
1435 int t20[F(__is_signed(void))];
1436 int t21[F(__is_signed(ClassType))];
1437 int t22[F(__is_signed(Derives))];
1438 int t23[F(__is_signed(Enum))];
1439 int t24[F(__is_signed(SignedEnum))];
1440 int t25[F(__is_signed(IntArNB))];
1441 int t26[F(__is_signed(Union))];
1442 int t27[F(__is_signed(UnionAr))];
1443 }
1444
is_unsigned()1445 void is_unsigned()
1446 {
1447 int t01[T(__is_unsigned(bool))];
1448 int t02[T(__is_unsigned(unsigned char))];
1449 int t03[T(__is_unsigned(unsigned short))];
1450 int t04[T(__is_unsigned(unsigned int))];
1451 int t05[T(__is_unsigned(unsigned long))];
1452 int t06[T(__is_unsigned(unsigned long long))];
1453 int t07[T(__is_unsigned(Enum))];
1454
1455 int t10[F(__is_unsigned(void))];
1456 int t11[F(__is_unsigned(cvoid))];
1457 int t12[F(__is_unsigned(float))];
1458 int t13[F(__is_unsigned(double))];
1459 int t14[F(__is_unsigned(long double))];
1460 int t16[F(__is_unsigned(char))];
1461 int t17[F(__is_unsigned(signed char))];
1462 int t18[F(__is_unsigned(wchar_t))];
1463 int t19[F(__is_unsigned(short))];
1464 int t20[F(__is_unsigned(int))];
1465 int t21[F(__is_unsigned(long))];
1466 int t22[F(__is_unsigned(Union))];
1467 int t23[F(__is_unsigned(UnionAr))];
1468 int t24[F(__is_unsigned(Derives))];
1469 int t25[F(__is_unsigned(ClassType))];
1470 int t26[F(__is_unsigned(IntArNB))];
1471 }
1472
1473 typedef Int& IntRef;
1474 typedef const IntAr ConstIntAr;
1475 typedef ConstIntAr ConstIntArAr[4];
1476
1477 struct HasCopy {
1478 HasCopy(HasCopy& cp);
1479 };
1480
1481 struct HasMove {
1482 HasMove(HasMove&& cp);
1483 };
1484
1485 struct HasTemplateCons {
1486 HasVirt Annoying;
1487
1488 template <typename T>
1489 HasTemplateCons(const T&);
1490 };
1491
has_trivial_default_constructor()1492 void has_trivial_default_constructor() {
1493 { int arr[T(__has_trivial_constructor(Int))]; }
1494 { int arr[T(__has_trivial_constructor(IntAr))]; }
1495 { int arr[T(__has_trivial_constructor(Union))]; }
1496 { int arr[T(__has_trivial_constructor(UnionAr))]; }
1497 { int arr[T(__has_trivial_constructor(POD))]; }
1498 { int arr[T(__has_trivial_constructor(Derives))]; }
1499 { int arr[T(__has_trivial_constructor(DerivesAr))]; }
1500 { int arr[T(__has_trivial_constructor(ConstIntAr))]; }
1501 { int arr[T(__has_trivial_constructor(ConstIntArAr))]; }
1502 { int arr[T(__has_trivial_constructor(HasDest))]; }
1503 { int arr[T(__has_trivial_constructor(HasPriv))]; }
1504 { int arr[T(__has_trivial_constructor(HasCopyAssign))]; }
1505 { int arr[T(__has_trivial_constructor(HasMoveAssign))]; }
1506 { int arr[T(__has_trivial_constructor(const Int))]; }
1507 { int arr[T(__has_trivial_constructor(AllDefaulted))]; }
1508 { int arr[T(__has_trivial_constructor(AllDeleted))]; }
1509 { int arr[T(__has_trivial_constructor(ACompleteType[]))]; }
1510
1511 { int arr[F(__has_trivial_constructor(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
1512 { int arr[F(__has_trivial_constructor(HasCons))]; }
1513 { int arr[F(__has_trivial_constructor(HasRef))]; }
1514 { int arr[F(__has_trivial_constructor(HasCopy))]; }
1515 { int arr[F(__has_trivial_constructor(IntRef))]; }
1516 { int arr[F(__has_trivial_constructor(VirtAr))]; }
1517 { int arr[F(__has_trivial_constructor(void))]; }
1518 { int arr[F(__has_trivial_constructor(cvoid))]; }
1519 { int arr[F(__has_trivial_constructor(HasTemplateCons))]; }
1520 { int arr[F(__has_trivial_constructor(AllPrivate))]; }
1521 { int arr[F(__has_trivial_constructor(ExtDefaulted))]; }
1522 }
1523
has_trivial_move_constructor()1524 void has_trivial_move_constructor() {
1525 // n3376 12.8 [class.copy]/12
1526 // A copy/move constructor for class X is trivial if it is not
1527 // user-provided, its declared parameter type is the same as
1528 // if it had been implicitly declared, and if
1529 // - class X has no virtual functions (10.3) and no virtual
1530 // base classes (10.1), and
1531 // - the constructor selected to copy/move each direct base
1532 // class subobject is trivial, and
1533 // - for each non-static data member of X that is of class
1534 // type (or array thereof), the constructor selected
1535 // to copy/move that member is trivial;
1536 // otherwise the copy/move constructor is non-trivial.
1537 { int arr[T(__has_trivial_move_constructor(POD))]; }
1538 { int arr[T(__has_trivial_move_constructor(Union))]; }
1539 { int arr[T(__has_trivial_move_constructor(HasCons))]; }
1540 { int arr[T(__has_trivial_move_constructor(HasStaticMemberMoveCtor))]; }
1541 { int arr[T(__has_trivial_move_constructor(AllDeleted))]; }
1542 { int arr[T(__has_trivial_move_constructor(ACompleteType[]))]; }
1543
1544 { int arr[F(__has_trivial_move_constructor(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
1545 { int arr[F(__has_trivial_move_constructor(HasVirt))]; }
1546 { int arr[F(__has_trivial_move_constructor(DerivesVirt))]; }
1547 { int arr[F(__has_trivial_move_constructor(HasMoveCtor))]; }
1548 { int arr[F(__has_trivial_move_constructor(DerivesHasMoveCtor))]; }
1549 { int arr[F(__has_trivial_move_constructor(HasMemberMoveCtor))]; }
1550 }
1551
has_trivial_copy_constructor()1552 void has_trivial_copy_constructor() {
1553 { int arr[T(__has_trivial_copy(Int))]; }
1554 { int arr[T(__has_trivial_copy(IntAr))]; }
1555 { int arr[T(__has_trivial_copy(Union))]; }
1556 { int arr[T(__has_trivial_copy(UnionAr))]; }
1557 { int arr[T(__has_trivial_copy(POD))]; }
1558 { int arr[T(__has_trivial_copy(Derives))]; }
1559 { int arr[T(__has_trivial_copy(ConstIntAr))]; }
1560 { int arr[T(__has_trivial_copy(ConstIntArAr))]; }
1561 { int arr[T(__has_trivial_copy(HasDest))]; }
1562 { int arr[T(__has_trivial_copy(HasPriv))]; }
1563 { int arr[T(__has_trivial_copy(HasCons))]; }
1564 { int arr[T(__has_trivial_copy(HasRef))]; }
1565 { int arr[T(__has_trivial_copy(HasMove))]; }
1566 { int arr[T(__has_trivial_copy(IntRef))]; }
1567 { int arr[T(__has_trivial_copy(HasCopyAssign))]; }
1568 { int arr[T(__has_trivial_copy(HasMoveAssign))]; }
1569 { int arr[T(__has_trivial_copy(const Int))]; }
1570 { int arr[T(__has_trivial_copy(AllDefaulted))]; }
1571 { int arr[T(__has_trivial_copy(AllDeleted))]; }
1572 { int arr[T(__has_trivial_copy(DerivesAr))]; }
1573 { int arr[T(__has_trivial_copy(DerivesHasRef))]; }
1574 { int arr[T(__has_trivial_copy(ACompleteType[]))]; }
1575
1576 { int arr[F(__has_trivial_copy(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
1577 { int arr[F(__has_trivial_copy(HasCopy))]; }
1578 { int arr[F(__has_trivial_copy(HasTemplateCons))]; }
1579 { int arr[F(__has_trivial_copy(VirtAr))]; }
1580 { int arr[F(__has_trivial_copy(void))]; }
1581 { int arr[F(__has_trivial_copy(cvoid))]; }
1582 { int arr[F(__has_trivial_copy(AllPrivate))]; }
1583 { int arr[F(__has_trivial_copy(ExtDefaulted))]; }
1584 }
1585
has_trivial_copy_assignment()1586 void has_trivial_copy_assignment() {
1587 { int arr[T(__has_trivial_assign(Int))]; }
1588 { int arr[T(__has_trivial_assign(IntAr))]; }
1589 { int arr[T(__has_trivial_assign(Union))]; }
1590 { int arr[T(__has_trivial_assign(UnionAr))]; }
1591 { int arr[T(__has_trivial_assign(POD))]; }
1592 { int arr[T(__has_trivial_assign(Derives))]; }
1593 { int arr[T(__has_trivial_assign(HasDest))]; }
1594 { int arr[T(__has_trivial_assign(HasPriv))]; }
1595 { int arr[T(__has_trivial_assign(HasCons))]; }
1596 { int arr[T(__has_trivial_assign(HasRef))]; }
1597 { int arr[T(__has_trivial_assign(HasCopy))]; }
1598 { int arr[T(__has_trivial_assign(HasMove))]; }
1599 { int arr[T(__has_trivial_assign(HasMoveAssign))]; }
1600 { int arr[T(__has_trivial_assign(AllDefaulted))]; }
1601 { int arr[T(__has_trivial_assign(AllDeleted))]; }
1602 { int arr[T(__has_trivial_assign(DerivesAr))]; }
1603 { int arr[T(__has_trivial_assign(DerivesHasRef))]; }
1604 { int arr[T(__has_trivial_assign(ACompleteType[]))]; }
1605
1606 { int arr[F(__has_trivial_assign(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
1607 { int arr[F(__has_trivial_assign(IntRef))]; }
1608 { int arr[F(__has_trivial_assign(HasCopyAssign))]; }
1609 { int arr[F(__has_trivial_assign(const Int))]; }
1610 { int arr[F(__has_trivial_assign(ConstIntAr))]; }
1611 { int arr[F(__has_trivial_assign(ConstIntArAr))]; }
1612 { int arr[F(__has_trivial_assign(VirtAr))]; }
1613 { int arr[F(__has_trivial_assign(void))]; }
1614 { int arr[F(__has_trivial_assign(cvoid))]; }
1615 { int arr[F(__has_trivial_assign(AllPrivate))]; }
1616 { int arr[F(__has_trivial_assign(ExtDefaulted))]; }
1617 }
1618
has_trivial_destructor()1619 void has_trivial_destructor() {
1620 { int arr[T(__has_trivial_destructor(Int))]; }
1621 { int arr[T(__has_trivial_destructor(IntAr))]; }
1622 { int arr[T(__has_trivial_destructor(Union))]; }
1623 { int arr[T(__has_trivial_destructor(UnionAr))]; }
1624 { int arr[T(__has_trivial_destructor(POD))]; }
1625 { int arr[T(__has_trivial_destructor(Derives))]; }
1626 { int arr[T(__has_trivial_destructor(ConstIntAr))]; }
1627 { int arr[T(__has_trivial_destructor(ConstIntArAr))]; }
1628 { int arr[T(__has_trivial_destructor(HasPriv))]; }
1629 { int arr[T(__has_trivial_destructor(HasCons))]; }
1630 { int arr[T(__has_trivial_destructor(HasRef))]; }
1631 { int arr[T(__has_trivial_destructor(HasCopy))]; }
1632 { int arr[T(__has_trivial_destructor(HasMove))]; }
1633 { int arr[T(__has_trivial_destructor(IntRef))]; }
1634 { int arr[T(__has_trivial_destructor(HasCopyAssign))]; }
1635 { int arr[T(__has_trivial_destructor(HasMoveAssign))]; }
1636 { int arr[T(__has_trivial_destructor(const Int))]; }
1637 { int arr[T(__has_trivial_destructor(DerivesAr))]; }
1638 { int arr[T(__has_trivial_destructor(VirtAr))]; }
1639 { int arr[T(__has_trivial_destructor(AllDefaulted))]; }
1640 { int arr[T(__has_trivial_destructor(AllDeleted))]; }
1641 { int arr[T(__has_trivial_destructor(DerivesHasRef))]; }
1642 { int arr[T(__has_trivial_destructor(ACompleteType[]))]; }
1643
1644 { int arr[F(__has_trivial_destructor(HasDest))]; }
1645 { int arr[F(__has_trivial_destructor(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
1646 { int arr[F(__has_trivial_destructor(void))]; }
1647 { int arr[F(__has_trivial_destructor(cvoid))]; }
1648 { int arr[F(__has_trivial_destructor(AllPrivate))]; }
1649 { int arr[F(__has_trivial_destructor(ExtDefaulted))]; }
1650 }
1651
~AA1652 struct A { ~A() {} };
1653 template<typename> struct B : A { };
1654
f()1655 void f() {
1656 { int arr[F(__has_trivial_destructor(A))]; }
1657 { int arr[F(__has_trivial_destructor(B<int>))]; }
1658 }
1659
1660 class PR11110 {
1661 template <int> int operator=( int );
1662 int operator=(PR11110);
1663 };
1664
1665 class UsingAssign;
1666
1667 class UsingAssignBase {
1668 protected:
1669 UsingAssign &operator=(const UsingAssign&) throw();
1670 };
1671
1672 class UsingAssign : public UsingAssignBase {
1673 public:
1674 using UsingAssignBase::operator=;
1675 };
1676
has_nothrow_assign()1677 void has_nothrow_assign() {
1678 { int arr[T(__has_nothrow_assign(Int))]; }
1679 { int arr[T(__has_nothrow_assign(IntAr))]; }
1680 { int arr[T(__has_nothrow_assign(Union))]; }
1681 { int arr[T(__has_nothrow_assign(UnionAr))]; }
1682 { int arr[T(__has_nothrow_assign(POD))]; }
1683 { int arr[T(__has_nothrow_assign(Derives))]; }
1684 { int arr[T(__has_nothrow_assign(HasDest))]; }
1685 { int arr[T(__has_nothrow_assign(HasPriv))]; }
1686 { int arr[T(__has_nothrow_assign(HasCons))]; }
1687 { int arr[T(__has_nothrow_assign(HasRef))]; }
1688 { int arr[T(__has_nothrow_assign(HasCopy))]; }
1689 { int arr[T(__has_nothrow_assign(HasMove))]; }
1690 { int arr[T(__has_nothrow_assign(HasMoveAssign))]; }
1691 { int arr[T(__has_nothrow_assign(HasNoThrowCopyAssign))]; }
1692 { int arr[T(__has_nothrow_assign(HasMultipleNoThrowCopyAssign))]; }
1693 { int arr[T(__has_nothrow_assign(HasVirtDest))]; }
1694 { int arr[T(__has_nothrow_assign(AllPrivate))]; }
1695 { int arr[T(__has_nothrow_assign(UsingAssign))]; }
1696 { int arr[T(__has_nothrow_assign(DerivesAr))]; }
1697 { int arr[T(__has_nothrow_assign(ACompleteType[]))]; }
1698
1699 { int arr[F(__has_nothrow_assign(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
1700 { int arr[F(__has_nothrow_assign(IntRef))]; }
1701 { int arr[F(__has_nothrow_assign(HasCopyAssign))]; }
1702 { int arr[F(__has_nothrow_assign(HasMultipleCopyAssign))]; }
1703 { int arr[F(__has_nothrow_assign(const Int))]; }
1704 { int arr[F(__has_nothrow_assign(ConstIntAr))]; }
1705 { int arr[F(__has_nothrow_assign(ConstIntArAr))]; }
1706 { int arr[F(__has_nothrow_assign(VirtAr))]; }
1707 { int arr[F(__has_nothrow_assign(void))]; }
1708 { int arr[F(__has_nothrow_assign(cvoid))]; }
1709 { int arr[F(__has_nothrow_assign(PR11110))]; }
1710 }
1711
has_nothrow_move_assign()1712 void has_nothrow_move_assign() {
1713 { int arr[T(__has_nothrow_move_assign(Int))]; }
1714 { int arr[T(__has_nothrow_move_assign(Enum))]; }
1715 { int arr[T(__has_nothrow_move_assign(Int*))]; }
1716 { int arr[T(__has_nothrow_move_assign(Enum POD::*))]; }
1717 { int arr[T(__has_nothrow_move_assign(POD))]; }
1718 { int arr[T(__has_nothrow_move_assign(HasPriv))]; }
1719 { int arr[T(__has_nothrow_move_assign(HasNoThrowMoveAssign))]; }
1720 { int arr[T(__has_nothrow_move_assign(HasNoExceptNoThrowMoveAssign))]; }
1721 { int arr[T(__has_nothrow_move_assign(HasMemberNoThrowMoveAssign))]; }
1722 { int arr[T(__has_nothrow_move_assign(HasMemberNoExceptNoThrowMoveAssign))]; }
1723 { int arr[T(__has_nothrow_move_assign(AllDeleted))]; }
1724 { int arr[T(__has_nothrow_move_assign(ACompleteType[]))]; }
1725
1726 { int arr[F(__has_nothrow_move_assign(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
1727 { int arr[F(__has_nothrow_move_assign(HasThrowMoveAssign))]; }
1728 { int arr[F(__has_nothrow_move_assign(HasNoExceptFalseMoveAssign))]; }
1729 { int arr[F(__has_nothrow_move_assign(HasMemberThrowMoveAssign))]; }
1730 { int arr[F(__has_nothrow_move_assign(HasMemberNoExceptFalseMoveAssign))]; }
1731 { int arr[F(__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyCtor))]; }
1732 { int arr[F(__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyAssign))]; }
1733 { int arr[F(__has_nothrow_move_assign(NoDefaultMoveAssignDueToDtor))]; }
1734
1735
1736 { int arr[T(__is_nothrow_assignable(HasNoThrowMoveAssign, HasNoThrowMoveAssign))]; }
1737 { int arr[F(__is_nothrow_assignable(HasThrowMoveAssign, HasThrowMoveAssign))]; }
1738
1739 { int arr[T(__is_assignable(HasNoThrowMoveAssign, HasNoThrowMoveAssign))]; }
1740 { int arr[T(__is_assignable(HasThrowMoveAssign, HasThrowMoveAssign))]; }
1741 }
1742
has_trivial_move_assign()1743 void has_trivial_move_assign() {
1744 // n3376 12.8 [class.copy]/25
1745 // A copy/move assignment operator for class X is trivial if it
1746 // is not user-provided, its declared parameter type is the same
1747 // as if it had been implicitly declared, and if:
1748 // - class X has no virtual functions (10.3) and no virtual base
1749 // classes (10.1), and
1750 // - the assignment operator selected to copy/move each direct
1751 // base class subobject is trivial, and
1752 // - for each non-static data member of X that is of class type
1753 // (or array thereof), the assignment operator
1754 // selected to copy/move that member is trivial;
1755 { int arr[T(__has_trivial_move_assign(Int))]; }
1756 { int arr[T(__has_trivial_move_assign(HasStaticMemberMoveAssign))]; }
1757 { int arr[T(__has_trivial_move_assign(AllDeleted))]; }
1758 { int arr[T(__has_trivial_move_assign(ACompleteType[]))]; }
1759
1760 { int arr[F(__has_trivial_move_assign(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
1761 { int arr[F(__has_trivial_move_assign(HasVirt))]; }
1762 { int arr[F(__has_trivial_move_assign(DerivesVirt))]; }
1763 { int arr[F(__has_trivial_move_assign(HasMoveAssign))]; }
1764 { int arr[F(__has_trivial_move_assign(DerivesHasMoveAssign))]; }
1765 { int arr[F(__has_trivial_move_assign(HasMemberMoveAssign))]; }
1766 { int arr[F(__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyCtor))]; }
1767 { int arr[F(__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyAssign))]; }
1768 }
1769
has_nothrow_copy()1770 void has_nothrow_copy() {
1771 { int arr[T(__has_nothrow_copy(Int))]; }
1772 { int arr[T(__has_nothrow_copy(IntAr))]; }
1773 { int arr[T(__has_nothrow_copy(Union))]; }
1774 { int arr[T(__has_nothrow_copy(UnionAr))]; }
1775 { int arr[T(__has_nothrow_copy(POD))]; }
1776 { int arr[T(__has_nothrow_copy(const Int))]; }
1777 { int arr[T(__has_nothrow_copy(ConstIntAr))]; }
1778 { int arr[T(__has_nothrow_copy(ConstIntArAr))]; }
1779 { int arr[T(__has_nothrow_copy(Derives))]; }
1780 { int arr[T(__has_nothrow_copy(IntRef))]; }
1781 { int arr[T(__has_nothrow_copy(HasDest))]; }
1782 { int arr[T(__has_nothrow_copy(HasPriv))]; }
1783 { int arr[T(__has_nothrow_copy(HasCons))]; }
1784 { int arr[T(__has_nothrow_copy(HasRef))]; }
1785 { int arr[T(__has_nothrow_copy(HasMove))]; }
1786 { int arr[T(__has_nothrow_copy(HasCopyAssign))]; }
1787 { int arr[T(__has_nothrow_copy(HasMoveAssign))]; }
1788 { int arr[T(__has_nothrow_copy(HasNoThrowCopy))]; }
1789 { int arr[T(__has_nothrow_copy(HasMultipleNoThrowCopy))]; }
1790 { int arr[T(__has_nothrow_copy(HasVirtDest))]; }
1791 { int arr[T(__has_nothrow_copy(HasTemplateCons))]; }
1792 { int arr[T(__has_nothrow_copy(AllPrivate))]; }
1793 { int arr[T(__has_nothrow_copy(DerivesAr))]; }
1794 { int arr[T(__has_nothrow_copy(ACompleteType[]))]; }
1795
1796 { int arr[F(__has_nothrow_copy(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
1797 { int arr[F(__has_nothrow_copy(HasCopy))]; }
1798 { int arr[F(__has_nothrow_copy(HasMultipleCopy))]; }
1799 { int arr[F(__has_nothrow_copy(VirtAr))]; }
1800 { int arr[F(__has_nothrow_copy(void))]; }
1801 { int arr[F(__has_nothrow_copy(cvoid))]; }
1802 }
1803
has_nothrow_constructor()1804 void has_nothrow_constructor() {
1805 { int arr[T(__has_nothrow_constructor(Int))]; }
1806 { int arr[T(__has_nothrow_constructor(IntAr))]; }
1807 { int arr[T(__has_nothrow_constructor(Union))]; }
1808 { int arr[T(__has_nothrow_constructor(UnionAr))]; }
1809 { int arr[T(__has_nothrow_constructor(POD))]; }
1810 { int arr[T(__has_nothrow_constructor(Derives))]; }
1811 { int arr[T(__has_nothrow_constructor(DerivesAr))]; }
1812 { int arr[T(__has_nothrow_constructor(ConstIntAr))]; }
1813 { int arr[T(__has_nothrow_constructor(ConstIntArAr))]; }
1814 { int arr[T(__has_nothrow_constructor(HasDest))]; }
1815 { int arr[T(__has_nothrow_constructor(HasPriv))]; }
1816 { int arr[T(__has_nothrow_constructor(HasCopyAssign))]; }
1817 { int arr[T(__has_nothrow_constructor(const Int))]; }
1818 { int arr[T(__has_nothrow_constructor(HasNoThrowConstructor))]; }
1819 { int arr[T(__has_nothrow_constructor(HasVirtDest))]; }
1820 // { int arr[T(__has_nothrow_constructor(VirtAr))]; } // not implemented
1821 { int arr[T(__has_nothrow_constructor(AllPrivate))]; }
1822 { int arr[T(__has_nothrow_constructor(ACompleteType[]))]; }
1823
1824 { int arr[F(__has_nothrow_constructor(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
1825 { int arr[F(__has_nothrow_constructor(HasCons))]; }
1826 { int arr[F(__has_nothrow_constructor(HasRef))]; }
1827 { int arr[F(__has_nothrow_constructor(HasCopy))]; }
1828 { int arr[F(__has_nothrow_constructor(HasMove))]; }
1829 { int arr[F(__has_nothrow_constructor(HasNoThrowConstructorWithArgs))]; }
1830 { int arr[F(__has_nothrow_constructor(IntRef))]; }
1831 { int arr[F(__has_nothrow_constructor(void))]; }
1832 { int arr[F(__has_nothrow_constructor(cvoid))]; }
1833 { int arr[F(__has_nothrow_constructor(HasTemplateCons))]; }
1834
1835 { int arr[F(__has_nothrow_constructor(HasMultipleDefaultConstructor1))]; }
1836 { int arr[F(__has_nothrow_constructor(HasMultipleDefaultConstructor2))]; }
1837 }
1838
has_virtual_destructor()1839 void has_virtual_destructor() {
1840 { int arr[F(__has_virtual_destructor(Int))]; }
1841 { int arr[F(__has_virtual_destructor(IntAr))]; }
1842 { int arr[F(__has_virtual_destructor(Union))]; }
1843 { int arr[F(__has_virtual_destructor(UnionAr))]; }
1844 { int arr[F(__has_virtual_destructor(POD))]; }
1845 { int arr[F(__has_virtual_destructor(Derives))]; }
1846 { int arr[F(__has_virtual_destructor(DerivesAr))]; }
1847 { int arr[F(__has_virtual_destructor(const Int))]; }
1848 { int arr[F(__has_virtual_destructor(ConstIntAr))]; }
1849 { int arr[F(__has_virtual_destructor(ConstIntArAr))]; }
1850 { int arr[F(__has_virtual_destructor(HasDest))]; }
1851 { int arr[F(__has_virtual_destructor(HasPriv))]; }
1852 { int arr[F(__has_virtual_destructor(HasCons))]; }
1853 { int arr[F(__has_virtual_destructor(HasRef))]; }
1854 { int arr[F(__has_virtual_destructor(HasCopy))]; }
1855 { int arr[F(__has_virtual_destructor(HasMove))]; }
1856 { int arr[F(__has_virtual_destructor(HasCopyAssign))]; }
1857 { int arr[F(__has_virtual_destructor(HasMoveAssign))]; }
1858 { int arr[F(__has_virtual_destructor(IntRef))]; }
1859 { int arr[F(__has_virtual_destructor(VirtAr))]; }
1860 { int arr[F(__has_virtual_destructor(ACompleteType[]))]; }
1861
1862 { int arr[F(__has_virtual_destructor(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
1863 { int arr[T(__has_virtual_destructor(HasVirtDest))]; }
1864 { int arr[T(__has_virtual_destructor(DerivedVirtDest))]; }
1865 { int arr[F(__has_virtual_destructor(VirtDestAr))]; }
1866 { int arr[F(__has_virtual_destructor(void))]; }
1867 { int arr[F(__has_virtual_destructor(cvoid))]; }
1868 { int arr[F(__has_virtual_destructor(AllPrivate))]; }
1869 }
1870
1871
1872 class Base {};
1873 class Derived : Base {};
1874 class Derived2a : Derived {};
1875 class Derived2b : Derived {};
1876 class Derived3 : virtual Derived2a, virtual Derived2b {};
1877 template<typename T> struct BaseA { T a; };
1878 template<typename T> struct DerivedB : BaseA<T> { };
1879 template<typename T> struct CrazyDerived : T { };
1880
1881
1882 class class_forward; // expected-note 2 {{forward declaration of 'class_forward'}}
1883
1884 template <typename Base, typename Derived>
isBaseOfT()1885 void isBaseOfT() {
1886 int t[T(__is_base_of(Base, Derived))];
1887 };
1888 template <typename Base, typename Derived>
isBaseOfF()1889 void isBaseOfF() {
1890 int t[F(__is_base_of(Base, Derived))];
1891 };
1892
1893 template <class T> class DerivedTemp : Base {};
1894 template <class T> class NonderivedTemp {};
1895 template <class T> class UndefinedTemp; // expected-note {{declared here}}
1896
is_base_of()1897 void is_base_of() {
1898 { int arr[T(__is_base_of(Base, Derived))]; }
1899 { int arr[T(__is_base_of(const Base, Derived))]; }
1900 { int arr[F(__is_base_of(Derived, Base))]; }
1901 { int arr[F(__is_base_of(Derived, int))]; }
1902 { int arr[T(__is_base_of(Base, Base))]; }
1903 { int arr[T(__is_base_of(Base, Derived3))]; }
1904 { int arr[T(__is_base_of(Derived, Derived3))]; }
1905 { int arr[T(__is_base_of(Derived2b, Derived3))]; }
1906 { int arr[T(__is_base_of(Derived2a, Derived3))]; }
1907 { int arr[T(__is_base_of(BaseA<int>, DerivedB<int>))]; }
1908 { int arr[F(__is_base_of(DerivedB<int>, BaseA<int>))]; }
1909 { int arr[T(__is_base_of(Base, CrazyDerived<Base>))]; }
1910 { int arr[F(__is_base_of(Union, Union))]; }
1911 { int arr[T(__is_base_of(Empty, Empty))]; }
1912 { int arr[T(__is_base_of(class_forward, class_forward))]; }
1913 { int arr[F(__is_base_of(Empty, class_forward))]; } // expected-error {{incomplete type 'class_forward' used in type trait expression}}
1914 { int arr[F(__is_base_of(Base&, Derived&))]; }
1915 int t18[F(__is_base_of(Base[10], Derived[10]))];
1916 { int arr[F(__is_base_of(int, int))]; }
1917 { int arr[F(__is_base_of(long, int))]; }
1918 { int arr[T(__is_base_of(Base, DerivedTemp<int>))]; }
1919 { int arr[F(__is_base_of(Base, NonderivedTemp<int>))]; }
1920 { int arr[F(__is_base_of(Base, UndefinedTemp<int>))]; } // expected-error {{implicit instantiation of undefined template 'UndefinedTemp<int>'}}
1921
1922 { int arr[F(__is_base_of(IncompleteUnion, IncompleteUnion))]; }
1923 { int arr[F(__is_base_of(Union, IncompleteUnion))]; }
1924 { int arr[F(__is_base_of(IncompleteUnion, Union))]; }
1925 { int arr[F(__is_base_of(IncompleteStruct, IncompleteUnion))]; }
1926 { int arr[F(__is_base_of(IncompleteUnion, IncompleteStruct))]; }
1927 { int arr[F(__is_base_of(Empty, IncompleteUnion))]; }
1928 { int arr[F(__is_base_of(IncompleteUnion, Empty))]; }
1929 { int arr[F(__is_base_of(int, IncompleteUnion))]; }
1930 { int arr[F(__is_base_of(IncompleteUnion, int))]; }
1931 { int arr[F(__is_base_of(Empty, Union))]; }
1932 { int arr[F(__is_base_of(Union, Empty))]; }
1933 { int arr[F(__is_base_of(int, Empty))]; }
1934 { int arr[F(__is_base_of(Union, int))]; }
1935
1936 isBaseOfT<Base, Derived>();
1937 isBaseOfF<Derived, Base>();
1938
1939 isBaseOfT<Base, CrazyDerived<Base> >();
1940 isBaseOfF<CrazyDerived<Base>, Base>();
1941
1942 isBaseOfT<BaseA<int>, DerivedB<int> >();
1943 isBaseOfF<DerivedB<int>, BaseA<int> >();
1944 }
1945
1946 template<class T, class U>
1947 class TemplateClass {};
1948
1949 template<class T>
1950 using TemplateAlias = TemplateClass<T, int>;
1951
1952 typedef class Base BaseTypedef;
1953
is_same()1954 void is_same()
1955 {
1956 int t01[T(__is_same(Base, Base))];
1957 int t02[T(__is_same(Base, BaseTypedef))];
1958 int t03[T(__is_same(TemplateClass<int, int>, TemplateAlias<int>))];
1959
1960 int t10[F(__is_same(Base, const Base))];
1961 int t11[F(__is_same(Base, Base&))];
1962 int t12[F(__is_same(Base, Derived))];
1963
1964 // __is_same_as is a GCC compatibility synonym for __is_same.
1965 int t20[T(__is_same_as(int, int))];
1966 int t21[F(__is_same_as(int, float))];
1967 }
1968
1969 struct IntWrapper
1970 {
1971 int value;
IntWrapperIntWrapper1972 IntWrapper(int _value) : value(_value) {}
operator intIntWrapper1973 operator int() const {
1974 return value;
1975 }
1976 };
1977
1978 struct FloatWrapper
1979 {
1980 float value;
FloatWrapperFloatWrapper1981 FloatWrapper(float _value) : value(_value) {}
FloatWrapperFloatWrapper1982 FloatWrapper(const IntWrapper& obj)
1983 : value(static_cast<float>(obj.value)) {}
operator floatFloatWrapper1984 operator float() const {
1985 return value;
1986 }
operator IntWrapperFloatWrapper1987 operator IntWrapper() const {
1988 return IntWrapper(static_cast<int>(value));
1989 }
1990 };
1991
is_convertible()1992 void is_convertible()
1993 {
1994 int t01[T(__is_convertible(IntWrapper, IntWrapper))];
1995 int t02[T(__is_convertible(IntWrapper, const IntWrapper))];
1996 int t03[T(__is_convertible(IntWrapper, int))];
1997 int t04[T(__is_convertible(int, IntWrapper))];
1998 int t05[T(__is_convertible(IntWrapper, FloatWrapper))];
1999 int t06[T(__is_convertible(FloatWrapper, IntWrapper))];
2000 int t07[T(__is_convertible(FloatWrapper, float))];
2001 int t08[T(__is_convertible(float, FloatWrapper))];
2002 }
2003
2004 struct FromInt { FromInt(int); };
2005 struct ToInt { operator int(); };
2006 typedef void Function();
2007
2008 void is_convertible_to();
2009 class PrivateCopy {
2010 PrivateCopy(const PrivateCopy&);
2011 friend void is_convertible_to();
2012 };
2013
2014 template<typename T>
2015 struct X0 {
2016 template<typename U> X0(const X0<U>&);
2017 };
2018
2019 struct Abstract { virtual void f() = 0; };
2020
is_convertible_to()2021 void is_convertible_to() {
2022 { int arr[T(__is_convertible_to(Int, Int))]; }
2023 { int arr[F(__is_convertible_to(Int, IntAr))]; }
2024 { int arr[F(__is_convertible_to(IntAr, IntAr))]; }
2025 { int arr[T(__is_convertible_to(void, void))]; }
2026 { int arr[T(__is_convertible_to(cvoid, void))]; }
2027 { int arr[T(__is_convertible_to(void, cvoid))]; }
2028 { int arr[T(__is_convertible_to(cvoid, cvoid))]; }
2029 { int arr[T(__is_convertible_to(int, FromInt))]; }
2030 { int arr[T(__is_convertible_to(long, FromInt))]; }
2031 { int arr[T(__is_convertible_to(double, FromInt))]; }
2032 { int arr[T(__is_convertible_to(const int, FromInt))]; }
2033 { int arr[T(__is_convertible_to(const int&, FromInt))]; }
2034 { int arr[T(__is_convertible_to(ToInt, int))]; }
2035 { int arr[T(__is_convertible_to(ToInt, const int&))]; }
2036 { int arr[T(__is_convertible_to(ToInt, long))]; }
2037 { int arr[F(__is_convertible_to(ToInt, int&))]; }
2038 { int arr[F(__is_convertible_to(ToInt, FromInt))]; }
2039 { int arr[T(__is_convertible_to(IntAr&, IntAr&))]; }
2040 { int arr[T(__is_convertible_to(IntAr&, const IntAr&))]; }
2041 { int arr[F(__is_convertible_to(const IntAr&, IntAr&))]; }
2042 { int arr[F(__is_convertible_to(Function, Function))]; }
2043 { int arr[F(__is_convertible_to(PrivateCopy, PrivateCopy))]; }
2044 { int arr[T(__is_convertible_to(X0<int>, X0<float>))]; }
2045 { int arr[F(__is_convertible_to(Abstract, Abstract))]; }
2046 }
2047
2048 namespace is_convertible_to_instantiate {
2049 // Make sure we don't try to instantiate the constructor.
A(int)2050 template<int x> class A { A(int) { int a[x]; } };
2051 int x = __is_convertible_to(int, A<-1>);
2052 }
2053
is_trivial()2054 void is_trivial()
2055 {
2056 { int arr[T(__is_trivial(int))]; }
2057 { int arr[T(__is_trivial(Enum))]; }
2058 { int arr[T(__is_trivial(POD))]; }
2059 { int arr[T(__is_trivial(Int))]; }
2060 { int arr[T(__is_trivial(IntAr))]; }
2061 { int arr[T(__is_trivial(IntArNB))]; }
2062 { int arr[T(__is_trivial(Statics))]; }
2063 { int arr[T(__is_trivial(Empty))]; }
2064 { int arr[T(__is_trivial(EmptyUnion))]; }
2065 { int arr[T(__is_trivial(Union))]; }
2066 { int arr[T(__is_trivial(Derives))]; }
2067 { int arr[T(__is_trivial(DerivesAr))]; }
2068 { int arr[T(__is_trivial(DerivesArNB))]; }
2069 { int arr[T(__is_trivial(DerivesEmpty))]; }
2070 { int arr[T(__is_trivial(HasFunc))]; }
2071 { int arr[T(__is_trivial(HasOp))]; }
2072 { int arr[T(__is_trivial(HasConv))]; }
2073 { int arr[T(__is_trivial(HasAssign))]; }
2074 { int arr[T(__is_trivial(HasAnonymousUnion))]; }
2075 { int arr[T(__is_trivial(HasPriv))]; }
2076 { int arr[T(__is_trivial(HasProt))]; }
2077 { int arr[T(__is_trivial(DerivesHasPriv))]; }
2078 { int arr[T(__is_trivial(DerivesHasProt))]; }
2079 { int arr[T(__is_trivial(Vector))]; }
2080 { int arr[T(__is_trivial(VectorExt))]; }
2081
2082 { int arr[F(__is_trivial(HasCons))]; }
2083 { int arr[F(__is_trivial(HasCopyAssign))]; }
2084 { int arr[F(__is_trivial(HasMoveAssign))]; }
2085 { int arr[F(__is_trivial(HasDest))]; }
2086 { int arr[F(__is_trivial(HasRef))]; }
2087 { int arr[F(__is_trivial(HasNonPOD))]; }
2088 { int arr[F(__is_trivial(HasVirt))]; }
2089 { int arr[F(__is_trivial(DerivesHasCons))]; }
2090 { int arr[F(__is_trivial(DerivesHasCopyAssign))]; }
2091 { int arr[F(__is_trivial(DerivesHasMoveAssign))]; }
2092 { int arr[F(__is_trivial(DerivesHasDest))]; }
2093 { int arr[F(__is_trivial(DerivesHasRef))]; }
2094 { int arr[F(__is_trivial(DerivesHasVirt))]; }
2095 { int arr[F(__is_trivial(void))]; }
2096 { int arr[F(__is_trivial(cvoid))]; }
2097 }
2098
2099 template<typename T> struct TriviallyConstructibleTemplate {};
2100
trivial_checks()2101 void trivial_checks()
2102 {
2103 { int arr[T(__is_trivially_copyable(int))]; }
2104 { int arr[T(__is_trivially_copyable(Enum))]; }
2105 { int arr[T(__is_trivially_copyable(POD))]; }
2106 { int arr[T(__is_trivially_copyable(Int))]; }
2107 { int arr[T(__is_trivially_copyable(IntAr))]; }
2108 { int arr[T(__is_trivially_copyable(IntArNB))]; }
2109 { int arr[T(__is_trivially_copyable(Statics))]; }
2110 { int arr[T(__is_trivially_copyable(Empty))]; }
2111 { int arr[T(__is_trivially_copyable(EmptyUnion))]; }
2112 { int arr[T(__is_trivially_copyable(Union))]; }
2113 { int arr[T(__is_trivially_copyable(Derives))]; }
2114 { int arr[T(__is_trivially_copyable(DerivesAr))]; }
2115 { int arr[T(__is_trivially_copyable(DerivesArNB))]; }
2116 { int arr[T(__is_trivially_copyable(DerivesEmpty))]; }
2117 { int arr[T(__is_trivially_copyable(HasFunc))]; }
2118 { int arr[T(__is_trivially_copyable(HasOp))]; }
2119 { int arr[T(__is_trivially_copyable(HasConv))]; }
2120 { int arr[T(__is_trivially_copyable(HasAssign))]; }
2121 { int arr[T(__is_trivially_copyable(HasAnonymousUnion))]; }
2122 { int arr[T(__is_trivially_copyable(HasPriv))]; }
2123 { int arr[T(__is_trivially_copyable(HasProt))]; }
2124 { int arr[T(__is_trivially_copyable(DerivesHasPriv))]; }
2125 { int arr[T(__is_trivially_copyable(DerivesHasProt))]; }
2126 { int arr[T(__is_trivially_copyable(Vector))]; }
2127 { int arr[T(__is_trivially_copyable(VectorExt))]; }
2128 { int arr[T(__is_trivially_copyable(HasCons))]; }
2129 { int arr[T(__is_trivially_copyable(HasRef))]; }
2130 { int arr[T(__is_trivially_copyable(HasNonPOD))]; }
2131 { int arr[T(__is_trivially_copyable(DerivesHasCons))]; }
2132 { int arr[T(__is_trivially_copyable(DerivesHasRef))]; }
2133 { int arr[T(__is_trivially_copyable(NonTrivialDefault))]; }
2134 { int arr[T(__is_trivially_copyable(NonTrivialDefault[]))]; }
2135 { int arr[T(__is_trivially_copyable(NonTrivialDefault[3]))]; }
2136
2137 { int arr[F(__is_trivially_copyable(HasCopyAssign))]; }
2138 { int arr[F(__is_trivially_copyable(HasMoveAssign))]; }
2139 { int arr[F(__is_trivially_copyable(HasDest))]; }
2140 { int arr[F(__is_trivially_copyable(HasVirt))]; }
2141 { int arr[F(__is_trivially_copyable(DerivesHasCopyAssign))]; }
2142 { int arr[F(__is_trivially_copyable(DerivesHasMoveAssign))]; }
2143 { int arr[F(__is_trivially_copyable(DerivesHasDest))]; }
2144 { int arr[F(__is_trivially_copyable(DerivesHasVirt))]; }
2145 { int arr[F(__is_trivially_copyable(void))]; }
2146 { int arr[F(__is_trivially_copyable(cvoid))]; }
2147
2148 { int arr[T((__is_trivially_constructible(int)))]; }
2149 { int arr[T((__is_trivially_constructible(int, int)))]; }
2150 { int arr[T((__is_trivially_constructible(int, float)))]; }
2151 { int arr[T((__is_trivially_constructible(int, int&)))]; }
2152 { int arr[T((__is_trivially_constructible(int, const int&)))]; }
2153 { int arr[T((__is_trivially_constructible(int, int)))]; }
2154 { int arr[T((__is_trivially_constructible(HasCopyAssign, HasCopyAssign)))]; }
2155 { int arr[T((__is_trivially_constructible(HasCopyAssign, const HasCopyAssign&)))]; }
2156 { int arr[T((__is_trivially_constructible(HasCopyAssign, HasCopyAssign&&)))]; }
2157 { int arr[T((__is_trivially_constructible(HasCopyAssign)))]; }
2158 { int arr[T((__is_trivially_constructible(NonTrivialDefault,
2159 const NonTrivialDefault&)))]; }
2160 { int arr[T((__is_trivially_constructible(NonTrivialDefault,
2161 NonTrivialDefault&&)))]; }
2162 { int arr[T((__is_trivially_constructible(AllDefaulted)))]; }
2163 { int arr[T((__is_trivially_constructible(AllDefaulted,
2164 const AllDefaulted &)))]; }
2165 { int arr[T((__is_trivially_constructible(AllDefaulted,
2166 AllDefaulted &&)))]; }
2167
2168 { int arr[F((__is_trivially_constructible(int, int*)))]; }
2169 { int arr[F((__is_trivially_constructible(NonTrivialDefault)))]; }
2170 { int arr[F((__is_trivially_constructible(ThreeArgCtor, int*, char*, int&)))]; }
2171 { int arr[F((__is_trivially_constructible(AllDeleted)))]; }
2172 { int arr[F((__is_trivially_constructible(AllDeleted,
2173 const AllDeleted &)))]; }
2174 { int arr[F((__is_trivially_constructible(AllDeleted,
2175 AllDeleted &&)))]; }
2176 { int arr[F((__is_trivially_constructible(ExtDefaulted)))]; }
2177 { int arr[F((__is_trivially_constructible(ExtDefaulted,
2178 const ExtDefaulted &)))]; }
2179 { int arr[F((__is_trivially_constructible(ExtDefaulted,
2180 ExtDefaulted &&)))]; }
2181
2182 { int arr[T((__is_trivially_constructible(TriviallyConstructibleTemplate<int>)))]; }
2183 { int arr[F((__is_trivially_constructible(class_forward)))]; } // expected-error {{incomplete type 'class_forward' used in type trait expression}}
2184 { int arr[F((__is_trivially_constructible(class_forward[])))]; }
2185 { int arr[F((__is_trivially_constructible(void)))]; }
2186
2187 { int arr[T((__is_trivially_assignable(int&, int)))]; }
2188 { int arr[T((__is_trivially_assignable(int&, int&)))]; }
2189 { int arr[T((__is_trivially_assignable(int&, int&&)))]; }
2190 { int arr[T((__is_trivially_assignable(int&, const int&)))]; }
2191 { int arr[T((__is_trivially_assignable(POD&, POD)))]; }
2192 { int arr[T((__is_trivially_assignable(POD&, POD&)))]; }
2193 { int arr[T((__is_trivially_assignable(POD&, POD&&)))]; }
2194 { int arr[T((__is_trivially_assignable(POD&, const POD&)))]; }
2195 { int arr[T((__is_trivially_assignable(int*&, int*)))]; }
2196 { int arr[T((__is_trivially_assignable(AllDefaulted,
2197 const AllDefaulted &)))]; }
2198 { int arr[T((__is_trivially_assignable(AllDefaulted,
2199 AllDefaulted &&)))]; }
2200
2201 { int arr[F((__is_trivially_assignable(int*&, float*)))]; }
2202 { int arr[F((__is_trivially_assignable(HasCopyAssign&, HasCopyAssign)))]; }
2203 { int arr[F((__is_trivially_assignable(HasCopyAssign&, HasCopyAssign&)))]; }
2204 { int arr[F((__is_trivially_assignable(HasCopyAssign&, const HasCopyAssign&)))]; }
2205 { int arr[F((__is_trivially_assignable(HasCopyAssign&, HasCopyAssign&&)))]; }
2206 { int arr[F((__is_trivially_assignable(TrivialMoveButNotCopy&,
2207 TrivialMoveButNotCopy&)))]; }
2208 { int arr[F((__is_trivially_assignable(TrivialMoveButNotCopy&,
2209 const TrivialMoveButNotCopy&)))]; }
2210 { int arr[F((__is_trivially_assignable(AllDeleted,
2211 const AllDeleted &)))]; }
2212 { int arr[F((__is_trivially_assignable(AllDeleted,
2213 AllDeleted &&)))]; }
2214 { int arr[F((__is_trivially_assignable(ExtDefaulted,
2215 const ExtDefaulted &)))]; }
2216 { int arr[F((__is_trivially_assignable(ExtDefaulted,
2217 ExtDefaulted &&)))]; }
2218
2219 { int arr[T((__is_trivially_assignable(HasDefaultTrivialCopyAssign&,
2220 HasDefaultTrivialCopyAssign&)))]; }
2221 { int arr[T((__is_trivially_assignable(HasDefaultTrivialCopyAssign&,
2222 const HasDefaultTrivialCopyAssign&)))]; }
2223 { int arr[T((__is_trivially_assignable(TrivialMoveButNotCopy&,
2224 TrivialMoveButNotCopy)))]; }
2225 { int arr[T((__is_trivially_assignable(TrivialMoveButNotCopy&,
2226 TrivialMoveButNotCopy&&)))]; }
2227 { int arr[T((__is_trivially_assignable(int&, int)))]; }
2228 { int arr[T((__is_trivially_assignable(int&, int&)))]; }
2229 { int arr[T((__is_trivially_assignable(int&, int&&)))]; }
2230 { int arr[T((__is_trivially_assignable(int&, const int&)))]; }
2231 { int arr[T((__is_trivially_assignable(POD&, POD)))]; }
2232 { int arr[T((__is_trivially_assignable(POD&, POD&)))]; }
2233 { int arr[T((__is_trivially_assignable(POD&, POD&&)))]; }
2234 { int arr[T((__is_trivially_assignable(POD&, const POD&)))]; }
2235 { int arr[T((__is_trivially_assignable(int*&, int*)))]; }
2236 { int arr[T((__is_trivially_assignable(AllDefaulted,
2237 const AllDefaulted &)))]; }
2238 { int arr[T((__is_trivially_assignable(AllDefaulted,
2239 AllDefaulted &&)))]; }
2240
2241 { int arr[F((__is_assignable(int *&, float *)))]; }
2242 { int arr[T((__is_assignable(HasCopyAssign &, HasCopyAssign)))]; }
2243 { int arr[T((__is_assignable(HasCopyAssign &, HasCopyAssign &)))]; }
2244 { int arr[T((__is_assignable(HasCopyAssign &, const HasCopyAssign &)))]; }
2245 { int arr[T((__is_assignable(HasCopyAssign &, HasCopyAssign &&)))]; }
2246 { int arr[T((__is_assignable(TrivialMoveButNotCopy &,
2247 TrivialMoveButNotCopy &)))]; }
2248 { int arr[T((__is_assignable(TrivialMoveButNotCopy &,
2249 const TrivialMoveButNotCopy &)))]; }
2250 { int arr[F((__is_assignable(AllDeleted,
2251 const AllDeleted &)))]; }
2252 { int arr[F((__is_assignable(AllDeleted,
2253 AllDeleted &&)))]; }
2254 { int arr[T((__is_assignable(ExtDefaulted,
2255 const ExtDefaulted &)))]; }
2256 { int arr[T((__is_assignable(ExtDefaulted,
2257 ExtDefaulted &&)))]; }
2258
2259 { int arr[T((__is_assignable(HasDefaultTrivialCopyAssign &,
2260 HasDefaultTrivialCopyAssign &)))]; }
2261 { int arr[T((__is_assignable(HasDefaultTrivialCopyAssign &,
2262 const HasDefaultTrivialCopyAssign &)))]; }
2263 { int arr[T((__is_assignable(TrivialMoveButNotCopy &,
2264 TrivialMoveButNotCopy)))]; }
2265 { int arr[T((__is_assignable(TrivialMoveButNotCopy &,
2266 TrivialMoveButNotCopy &&)))]; }
2267
2268 { int arr[T(__is_assignable(ACompleteType, ACompleteType))]; }
2269 { int arr[F(__is_assignable(AnIncompleteType, AnIncompleteType))]; } // expected-error {{incomplete type}}
2270 { int arr[F(__is_assignable(AnIncompleteType[], AnIncompleteType[]))]; }
2271 { int arr[F(__is_assignable(AnIncompleteType[1], AnIncompleteType[1]))]; } // expected-error {{incomplete type}}
2272 { int arr[F(__is_assignable(void, void))]; }
2273 { int arr[F(__is_assignable(const volatile void, const volatile void))]; }
2274 }
2275
constructible_checks()2276 void constructible_checks() {
2277 { int arr[T(__is_constructible(HasNoThrowConstructorWithArgs))]; }
2278 { int arr[F(__is_nothrow_constructible(HasNoThrowConstructorWithArgs))]; } // MSVC doesn't look into default args and gets this wrong.
2279
2280 { int arr[T(__is_constructible(HasNoThrowConstructorWithArgs, HasCons))]; }
2281 { int arr[T(__is_nothrow_constructible(HasNoThrowConstructorWithArgs, HasCons))]; }
2282
2283 { int arr[T(__is_constructible(NonTrivialDefault))]; }
2284 { int arr[F(__is_nothrow_constructible(NonTrivialDefault))]; }
2285
2286 { int arr[T(__is_constructible(int))]; }
2287 { int arr[T(__is_nothrow_constructible(int))]; }
2288
2289 { int arr[F(__is_constructible(NonPOD))]; }
2290 { int arr[F(__is_nothrow_constructible(NonPOD))]; }
2291
2292 { int arr[T(__is_constructible(NonPOD, int))]; }
2293 { int arr[F(__is_nothrow_constructible(NonPOD, int))]; }
2294
2295 // PR19178
2296 { int arr[F(__is_constructible(Abstract))]; }
2297 { int arr[F(__is_nothrow_constructible(Abstract))]; }
2298
2299 // PR20228
2300 { int arr[T(__is_constructible(VariadicCtor,
2301 int, int, int, int, int, int, int, int, int))]; }
2302
2303 // PR25513
2304 { int arr[F(__is_constructible(int(int)))]; }
2305 { int arr[T(__is_constructible(int const &, long))]; }
2306
2307 { int arr[T(__is_constructible(ACompleteType))]; }
2308 { int arr[T(__is_nothrow_constructible(ACompleteType))]; }
2309 { int arr[F(__is_constructible(AnIncompleteType))]; } // expected-error {{incomplete type}}
2310 { int arr[F(__is_nothrow_constructible(AnIncompleteType))]; } // expected-error {{incomplete type}}
2311 { int arr[F(__is_constructible(AnIncompleteType[]))]; }
2312 { int arr[F(__is_nothrow_constructible(AnIncompleteType[]))]; }
2313 { int arr[F(__is_constructible(AnIncompleteType[1]))]; } // expected-error {{incomplete type}}
2314 { int arr[F(__is_nothrow_constructible(AnIncompleteType[1]))]; } // expected-error {{incomplete type}}
2315 { int arr[F(__is_constructible(void))]; }
2316 { int arr[F(__is_nothrow_constructible(void))]; }
2317 { int arr[F(__is_constructible(const volatile void))]; }
2318 { int arr[F(__is_nothrow_constructible(const volatile void))]; }
2319 }
2320
2321 // Instantiation of __is_trivially_constructible
2322 template<typename T, typename ...Args>
2323 struct is_trivially_constructible {
2324 static const bool value = __is_trivially_constructible(T, Args...);
2325 };
2326
is_trivially_constructible_test()2327 void is_trivially_constructible_test() {
2328 { int arr[T((is_trivially_constructible<int>::value))]; }
2329 { int arr[T((is_trivially_constructible<int, int>::value))]; }
2330 { int arr[T((is_trivially_constructible<int, float>::value))]; }
2331 { int arr[T((is_trivially_constructible<int, int&>::value))]; }
2332 { int arr[T((is_trivially_constructible<int, const int&>::value))]; }
2333 { int arr[T((is_trivially_constructible<int, int>::value))]; }
2334 { int arr[T((is_trivially_constructible<HasCopyAssign, HasCopyAssign>::value))]; }
2335 { int arr[T((is_trivially_constructible<HasCopyAssign, const HasCopyAssign&>::value))]; }
2336 { int arr[T((is_trivially_constructible<HasCopyAssign, HasCopyAssign&&>::value))]; }
2337 { int arr[T((is_trivially_constructible<HasCopyAssign>::value))]; }
2338 { int arr[T((is_trivially_constructible<NonTrivialDefault,
2339 const NonTrivialDefault&>::value))]; }
2340 { int arr[T((is_trivially_constructible<NonTrivialDefault,
2341 NonTrivialDefault&&>::value))]; }
2342
2343 { int arr[F((is_trivially_constructible<int, int*>::value))]; }
2344 { int arr[F((is_trivially_constructible<NonTrivialDefault>::value))]; }
2345 { int arr[F((is_trivially_constructible<ThreeArgCtor, int*, char*, int&>::value))]; }
2346 { int arr[F((is_trivially_constructible<Abstract>::value))]; } // PR19178
2347
2348 { int arr[T(__is_trivially_constructible(ACompleteType))]; }
2349 { int arr[F(__is_trivially_constructible(AnIncompleteType))]; } // expected-error {{incomplete type}}
2350 { int arr[F(__is_trivially_constructible(AnIncompleteType[]))]; }
2351 { int arr[F(__is_trivially_constructible(AnIncompleteType[1]))]; } // expected-error {{incomplete type}}
2352 { int arr[F(__is_trivially_constructible(void))]; }
2353 { int arr[F(__is_trivially_constructible(const volatile void))]; }
2354 }
2355
2356 template <class T, class RefType = T &>
2357 struct ConvertsToRef {
operator RefTypeConvertsToRef2358 operator RefType() const { return static_cast<RefType>(obj); }
2359 mutable T obj = 42;
2360 };
2361
reference_binds_to_temporary_checks()2362 void reference_binds_to_temporary_checks() {
2363 { int arr[F((__reference_binds_to_temporary(int &, int &)))]; }
2364 { int arr[F((__reference_binds_to_temporary(int &, int &&)))]; }
2365
2366 { int arr[F((__reference_binds_to_temporary(int const &, int &)))]; }
2367 { int arr[F((__reference_binds_to_temporary(int const &, int const &)))]; }
2368 { int arr[F((__reference_binds_to_temporary(int const &, int &&)))]; }
2369
2370 { int arr[F((__reference_binds_to_temporary(int &, long &)))]; } // doesn't construct
2371 { int arr[T((__reference_binds_to_temporary(int const &, long &)))]; }
2372 { int arr[T((__reference_binds_to_temporary(int const &, long &&)))]; }
2373 { int arr[T((__reference_binds_to_temporary(int &&, long &)))]; }
2374
2375 using LRef = ConvertsToRef<int, int &>;
2376 using RRef = ConvertsToRef<int, int &&>;
2377 using CLRef = ConvertsToRef<int, const int &>;
2378 using LongRef = ConvertsToRef<long, long &>;
2379 { int arr[T((__is_constructible(int &, LRef)))]; }
2380 { int arr[F((__reference_binds_to_temporary(int &, LRef)))]; }
2381
2382 { int arr[T((__is_constructible(int &&, RRef)))]; }
2383 { int arr[F((__reference_binds_to_temporary(int &&, RRef)))]; }
2384
2385 { int arr[T((__is_constructible(int const &, CLRef)))]; }
2386 { int arr[F((__reference_binds_to_temporary(int &&, CLRef)))]; }
2387
2388 { int arr[T((__is_constructible(int const &, LongRef)))]; }
2389 { int arr[T((__reference_binds_to_temporary(int const &, LongRef)))]; }
2390
2391 // Test that it doesn't accept non-reference types as input.
2392 { int arr[F((__reference_binds_to_temporary(int, long)))]; }
2393
2394 { int arr[T((__reference_binds_to_temporary(const int &, long)))]; }
2395 }
2396
array_rank()2397 void array_rank() {
2398 int t01[T(__array_rank(IntAr) == 1)];
2399 int t02[T(__array_rank(ConstIntArAr) == 2)];
2400 }
2401
array_extent()2402 void array_extent() {
2403 int t01[T(__array_extent(IntAr, 0) == 10)];
2404 int t02[T(__array_extent(ConstIntArAr, 0) == 4)];
2405 int t03[T(__array_extent(ConstIntArAr, 1) == 10)];
2406 }
2407
is_destructible_test()2408 void is_destructible_test() {
2409 { int arr[T(__is_destructible(int))]; }
2410 { int arr[T(__is_destructible(int[2]))]; }
2411 { int arr[F(__is_destructible(int[]))]; }
2412 { int arr[F(__is_destructible(void))]; }
2413 { int arr[T(__is_destructible(int &))]; }
2414 { int arr[T(__is_destructible(HasDest))]; }
2415 { int arr[F(__is_destructible(AllPrivate))]; }
2416 { int arr[T(__is_destructible(SuperNonTrivialStruct))]; }
2417 { int arr[T(__is_destructible(AllDefaulted))]; }
2418 { int arr[F(__is_destructible(AllDeleted))]; }
2419 { int arr[T(__is_destructible(ThrowingDtor))]; }
2420 { int arr[T(__is_destructible(NoThrowDtor))]; }
2421
2422 { int arr[T(__is_destructible(ACompleteType))]; }
2423 { int arr[F(__is_destructible(AnIncompleteType))]; } // expected-error {{incomplete type}}
2424 { int arr[F(__is_destructible(AnIncompleteType[]))]; }
2425 { int arr[F(__is_destructible(AnIncompleteType[1]))]; } // expected-error {{incomplete type}}
2426 { int arr[F(__is_destructible(void))]; }
2427 { int arr[F(__is_destructible(const volatile void))]; }
2428 }
2429
is_nothrow_destructible_test()2430 void is_nothrow_destructible_test() {
2431 { int arr[T(__is_nothrow_destructible(int))]; }
2432 { int arr[T(__is_nothrow_destructible(int[2]))]; }
2433 { int arr[F(__is_nothrow_destructible(int[]))]; }
2434 { int arr[F(__is_nothrow_destructible(void))]; }
2435 { int arr[T(__is_nothrow_destructible(int &))]; }
2436 { int arr[T(__is_nothrow_destructible(HasDest))]; }
2437 { int arr[F(__is_nothrow_destructible(AllPrivate))]; }
2438 { int arr[T(__is_nothrow_destructible(SuperNonTrivialStruct))]; }
2439 { int arr[T(__is_nothrow_destructible(AllDefaulted))]; }
2440 { int arr[F(__is_nothrow_destructible(AllDeleted))]; }
2441 { int arr[F(__is_nothrow_destructible(ThrowingDtor))]; }
2442 { int arr[T(__is_nothrow_destructible(NoExceptDtor))]; }
2443 { int arr[T(__is_nothrow_destructible(NoThrowDtor))]; }
2444
2445 { int arr[T(__is_nothrow_destructible(ACompleteType))]; }
2446 { int arr[F(__is_nothrow_destructible(AnIncompleteType))]; } // expected-error {{incomplete type}}
2447 { int arr[F(__is_nothrow_destructible(AnIncompleteType[]))]; }
2448 { int arr[F(__is_nothrow_destructible(AnIncompleteType[1]))]; } // expected-error {{incomplete type}}
2449 { int arr[F(__is_nothrow_destructible(void))]; }
2450 { int arr[F(__is_nothrow_destructible(const volatile void))]; }
2451 }
2452
is_trivially_destructible_test()2453 void is_trivially_destructible_test() {
2454 { int arr[T(__is_trivially_destructible(int))]; }
2455 { int arr[T(__is_trivially_destructible(int[2]))]; }
2456 { int arr[F(__is_trivially_destructible(int[]))]; }
2457 { int arr[F(__is_trivially_destructible(void))]; }
2458 { int arr[T(__is_trivially_destructible(int &))]; }
2459 { int arr[F(__is_trivially_destructible(HasDest))]; }
2460 { int arr[F(__is_trivially_destructible(AllPrivate))]; }
2461 { int arr[F(__is_trivially_destructible(SuperNonTrivialStruct))]; }
2462 { int arr[T(__is_trivially_destructible(AllDefaulted))]; }
2463 { int arr[F(__is_trivially_destructible(AllDeleted))]; }
2464 { int arr[F(__is_trivially_destructible(ThrowingDtor))]; }
2465 { int arr[F(__is_trivially_destructible(NoThrowDtor))]; }
2466
2467 { int arr[T(__is_trivially_destructible(ACompleteType))]; }
2468 { int arr[F(__is_trivially_destructible(AnIncompleteType))]; } // expected-error {{incomplete type}}
2469 { int arr[F(__is_trivially_destructible(AnIncompleteType[]))]; }
2470 { int arr[F(__is_trivially_destructible(AnIncompleteType[1]))]; } // expected-error {{incomplete type}}
2471 { int arr[F(__is_trivially_destructible(void))]; }
2472 { int arr[F(__is_trivially_destructible(const volatile void))]; }
2473 }
2474
2475 // Instantiation of __has_unique_object_representations
2476 template <typename T>
2477 struct has_unique_object_representations {
2478 static const bool value = __has_unique_object_representations(T);
2479 };
2480
2481 static_assert(!has_unique_object_representations<void>::value, "void is never unique");
2482 static_assert(!has_unique_object_representations<const void>::value, "void is never unique");
2483 static_assert(!has_unique_object_representations<volatile void>::value, "void is never unique");
2484 static_assert(!has_unique_object_representations<const volatile void>::value, "void is never unique");
2485
2486 static_assert(has_unique_object_representations<int>::value, "integrals are");
2487 static_assert(has_unique_object_representations<const int>::value, "integrals are");
2488 static_assert(has_unique_object_representations<volatile int>::value, "integrals are");
2489 static_assert(has_unique_object_representations<const volatile int>::value, "integrals are");
2490
2491 static_assert(has_unique_object_representations<void *>::value, "as are pointers");
2492 static_assert(has_unique_object_representations<const void *>::value, "as are pointers");
2493 static_assert(has_unique_object_representations<volatile void *>::value, "are pointers");
2494 static_assert(has_unique_object_representations<const volatile void *>::value, "as are pointers");
2495
2496 static_assert(has_unique_object_representations<int *>::value, "as are pointers");
2497 static_assert(has_unique_object_representations<const int *>::value, "as are pointers");
2498 static_assert(has_unique_object_representations<volatile int *>::value, "as are pointers");
2499 static_assert(has_unique_object_representations<const volatile int *>::value, "as are pointers");
2500
2501 class C {};
2502 using FP = int (*)(int);
2503 using PMF = int (C::*)(int);
2504 using PMD = int C::*;
2505
2506 static_assert(has_unique_object_representations<FP>::value, "even function pointers");
2507 static_assert(has_unique_object_representations<const FP>::value, "even function pointers");
2508 static_assert(has_unique_object_representations<volatile FP>::value, "even function pointers");
2509 static_assert(has_unique_object_representations<const volatile FP>::value, "even function pointers");
2510
2511 static_assert(has_unique_object_representations<PMF>::value, "and pointer to members");
2512 static_assert(has_unique_object_representations<const PMF>::value, "and pointer to members");
2513 static_assert(has_unique_object_representations<volatile PMF>::value, "and pointer to members");
2514 static_assert(has_unique_object_representations<const volatile PMF>::value, "and pointer to members");
2515
2516 static_assert(has_unique_object_representations<PMD>::value, "and pointer to members");
2517 static_assert(has_unique_object_representations<const PMD>::value, "and pointer to members");
2518 static_assert(has_unique_object_representations<volatile PMD>::value, "and pointer to members");
2519 static_assert(has_unique_object_representations<const volatile PMD>::value, "and pointer to members");
2520
2521 static_assert(has_unique_object_representations<bool>::value, "yes, all integral types");
2522 static_assert(has_unique_object_representations<char>::value, "yes, all integral types");
2523 static_assert(has_unique_object_representations<signed char>::value, "yes, all integral types");
2524 static_assert(has_unique_object_representations<unsigned char>::value, "yes, all integral types");
2525 static_assert(has_unique_object_representations<short>::value, "yes, all integral types");
2526 static_assert(has_unique_object_representations<unsigned short>::value, "yes, all integral types");
2527 static_assert(has_unique_object_representations<int>::value, "yes, all integral types");
2528 static_assert(has_unique_object_representations<unsigned int>::value, "yes, all integral types");
2529 static_assert(has_unique_object_representations<long>::value, "yes, all integral types");
2530 static_assert(has_unique_object_representations<unsigned long>::value, "yes, all integral types");
2531 static_assert(has_unique_object_representations<long long>::value, "yes, all integral types");
2532 static_assert(has_unique_object_representations<unsigned long long>::value, "yes, all integral types");
2533 static_assert(has_unique_object_representations<wchar_t>::value, "yes, all integral types");
2534 static_assert(has_unique_object_representations<char16_t>::value, "yes, all integral types");
2535 static_assert(has_unique_object_representations<char32_t>::value, "yes, all integral types");
2536
2537 static_assert(!has_unique_object_representations<void>::value, "but not void!");
2538 static_assert(!has_unique_object_representations<decltype(nullptr)>::value, "or nullptr_t");
2539 static_assert(!has_unique_object_representations<float>::value, "definitely not Floating Point");
2540 static_assert(!has_unique_object_representations<double>::value, "definitely not Floating Point");
2541 static_assert(!has_unique_object_representations<long double>::value, "definitely not Floating Point");
2542
2543 struct NoPadding {
2544 int a;
2545 int b;
2546 };
2547
2548 static_assert(has_unique_object_representations<NoPadding>::value, "types without padding are");
2549
2550 struct InheritsFromNoPadding : NoPadding {
2551 int c;
2552 int d;
2553 };
2554
2555 static_assert(has_unique_object_representations<InheritsFromNoPadding>::value, "types without padding are");
2556
2557 struct VirtuallyInheritsFromNoPadding : virtual NoPadding {
2558 int c;
2559 int d;
2560 };
2561
2562 static_assert(!has_unique_object_representations<VirtuallyInheritsFromNoPadding>::value, "No virtual inheritance");
2563
2564 struct Padding {
2565 char a;
2566 int b;
2567 };
2568
2569 //static_assert(!has_unique_object_representations<Padding>::value, "but not with padding");
2570
2571 struct InheritsFromPadding : Padding {
2572 int c;
2573 int d;
2574 };
2575
2576 static_assert(!has_unique_object_representations<InheritsFromPadding>::value, "or its subclasses");
2577
2578 struct TailPadding {
2579 int a;
2580 char b;
2581 };
2582
2583 static_assert(!has_unique_object_representations<TailPadding>::value, "even at the end");
2584
2585 struct TinyStruct {
2586 char a;
2587 };
2588
2589 static_assert(has_unique_object_representations<TinyStruct>::value, "Should be no padding");
2590
2591 struct InheritsFromTinyStruct : TinyStruct {
2592 int b;
2593 };
2594
2595 static_assert(!has_unique_object_representations<InheritsFromTinyStruct>::value, "Inherit causes padding");
2596
2597 union NoPaddingUnion {
2598 int a;
2599 unsigned int b;
2600 };
2601
2602 static_assert(has_unique_object_representations<NoPaddingUnion>::value, "unions follow the same rules as structs");
2603
2604 union PaddingUnion {
2605 int a;
2606 long long b;
2607 };
2608
2609 static_assert(!has_unique_object_representations<PaddingUnion>::value, "unions follow the same rules as structs");
2610
2611 struct NotTriviallyCopyable {
2612 int x;
NotTriviallyCopyableNotTriviallyCopyable2613 NotTriviallyCopyable(const NotTriviallyCopyable &) {}
2614 };
2615
2616 static_assert(!has_unique_object_representations<NotTriviallyCopyable>::value, "must be trivially copyable");
2617
2618 struct HasNonUniqueMember {
2619 float x;
2620 };
2621
2622 static_assert(!has_unique_object_representations<HasNonUniqueMember>::value, "all members must be unique");
2623
2624 enum ExampleEnum { xExample,
2625 yExample };
2626 enum LLEnum : long long { xLongExample,
2627 yLongExample };
2628
2629 static_assert(has_unique_object_representations<ExampleEnum>::value, "Enums are integrals, so unique!");
2630 static_assert(has_unique_object_representations<LLEnum>::value, "Enums are integrals, so unique!");
2631
2632 enum class ExampleEnumClass { xExample,
2633 yExample };
2634 enum class LLEnumClass : long long { xLongExample,
2635 yLongExample };
2636
2637 static_assert(has_unique_object_representations<ExampleEnumClass>::value, "Enums are integrals, so unique!");
2638 static_assert(has_unique_object_representations<LLEnumClass>::value, "Enums are integrals, so unique!");
2639
2640 // because references aren't trivially copyable.
2641 static_assert(!has_unique_object_representations<int &>::value, "No references!");
2642 static_assert(!has_unique_object_representations<const int &>::value, "No references!");
2643 static_assert(!has_unique_object_representations<volatile int &>::value, "No references!");
2644 static_assert(!has_unique_object_representations<const volatile int &>::value, "No references!");
2645 static_assert(!has_unique_object_representations<Empty>::value, "No empty types!");
2646 static_assert(!has_unique_object_representations<EmptyUnion>::value, "No empty types!");
2647
2648 class Compressed : Empty {
2649 int x;
2650 };
2651
2652 static_assert(has_unique_object_representations<Compressed>::value, "But inheriting from one is ok");
2653
2654 class EmptyInheritor : Compressed {};
2655
2656 static_assert(has_unique_object_representations<EmptyInheritor>::value, "As long as the base has items, empty is ok");
2657
2658 class Dynamic {
2659 virtual void A();
2660 int i;
2661 };
2662
2663 static_assert(!has_unique_object_representations<Dynamic>::value, "Dynamic types are not valid");
2664
2665 class InheritsDynamic : Dynamic {
2666 int j;
2667 };
2668
2669 static_assert(!has_unique_object_representations<InheritsDynamic>::value, "Dynamic types are not valid");
2670
2671 static_assert(has_unique_object_representations<int[42]>::value, "Arrays are fine, as long as their value type is");
2672 static_assert(has_unique_object_representations<int[]>::value, "Arrays are fine, as long as their value type is");
2673 static_assert(has_unique_object_representations<int[][42]>::value, "Arrays are fine, as long as their value type is");
2674 static_assert(!has_unique_object_representations<double[42]>::value, "So no array of doubles!");
2675 static_assert(!has_unique_object_representations<double[]>::value, "So no array of doubles!");
2676 static_assert(!has_unique_object_representations<double[][42]>::value, "So no array of doubles!");
2677
2678 struct __attribute__((aligned(16))) WeirdAlignment {
2679 int i;
2680 };
2681 union __attribute__((aligned(16))) WeirdAlignmentUnion {
2682 int i;
2683 };
2684 static_assert(!has_unique_object_representations<WeirdAlignment>::value, "Alignment causes padding");
2685 static_assert(!has_unique_object_representations<WeirdAlignmentUnion>::value, "Alignment causes padding");
2686 static_assert(!has_unique_object_representations<WeirdAlignment[42]>::value, "Also no arrays that have padding");
2687
2688 static_assert(!has_unique_object_representations<int(int)>::value, "Functions are not unique");
2689 static_assert(!has_unique_object_representations<int(int) const>::value, "Functions are not unique");
2690 static_assert(!has_unique_object_representations<int(int) volatile>::value, "Functions are not unique");
2691 static_assert(!has_unique_object_representations<int(int) const volatile>::value, "Functions are not unique");
2692 static_assert(!has_unique_object_representations<int(int) &>::value, "Functions are not unique");
2693 static_assert(!has_unique_object_representations<int(int) const &>::value, "Functions are not unique");
2694 static_assert(!has_unique_object_representations<int(int) volatile &>::value, "Functions are not unique");
2695 static_assert(!has_unique_object_representations<int(int) const volatile &>::value, "Functions are not unique");
2696 static_assert(!has_unique_object_representations<int(int) &&>::value, "Functions are not unique");
2697 static_assert(!has_unique_object_representations<int(int) const &&>::value, "Functions are not unique");
2698 static_assert(!has_unique_object_representations<int(int) volatile &&>::value, "Functions are not unique");
2699 static_assert(!has_unique_object_representations<int(int) const volatile &&>::value, "Functions are not unique");
2700
2701 static_assert(!has_unique_object_representations<int(int, ...)>::value, "Functions are not unique");
2702 static_assert(!has_unique_object_representations<int(int, ...) const>::value, "Functions are not unique");
2703 static_assert(!has_unique_object_representations<int(int, ...) volatile>::value, "Functions are not unique");
2704 static_assert(!has_unique_object_representations<int(int, ...) const volatile>::value, "Functions are not unique");
2705 static_assert(!has_unique_object_representations<int(int, ...) &>::value, "Functions are not unique");
2706 static_assert(!has_unique_object_representations<int(int, ...) const &>::value, "Functions are not unique");
2707 static_assert(!has_unique_object_representations<int(int, ...) volatile &>::value, "Functions are not unique");
2708 static_assert(!has_unique_object_representations<int(int, ...) const volatile &>::value, "Functions are not unique");
2709 static_assert(!has_unique_object_representations<int(int, ...) &&>::value, "Functions are not unique");
2710 static_assert(!has_unique_object_representations<int(int, ...) const &&>::value, "Functions are not unique");
2711 static_assert(!has_unique_object_representations<int(int, ...) volatile &&>::value, "Functions are not unique");
2712 static_assert(!has_unique_object_representations<int(int, ...) const volatile &&>::value, "Functions are not unique");
2713
foo()2714 void foo(){
2715 static auto lambda = []() {};
2716 static_assert(!has_unique_object_representations<decltype(lambda)>::value, "Lambdas follow struct rules");
2717 int i;
2718 static auto lambda2 = [i]() {};
2719 static_assert(has_unique_object_representations<decltype(lambda2)>::value, "Lambdas follow struct rules");
2720 }
2721
2722 struct PaddedBitfield {
2723 char c : 6;
2724 char d : 1;
2725 };
2726
2727 struct UnPaddedBitfield {
2728 char c : 6;
2729 char d : 2;
2730 };
2731
2732 struct AlignedPaddedBitfield {
2733 char c : 6;
2734 __attribute__((aligned(1)))
2735 char d : 2;
2736 };
2737
2738 static_assert(!has_unique_object_representations<PaddedBitfield>::value, "Bitfield padding");
2739 static_assert(has_unique_object_representations<UnPaddedBitfield>::value, "Bitfield padding");
2740 static_assert(!has_unique_object_representations<AlignedPaddedBitfield>::value, "Bitfield padding");
2741
2742 struct BoolBitfield {
2743 bool b : 8;
2744 };
2745
2746 static_assert(has_unique_object_representations<BoolBitfield>::value, "Bitfield bool");
2747
2748 struct BoolBitfield2 {
2749 bool b : 16;
2750 };
2751
2752 static_assert(!has_unique_object_representations<BoolBitfield2>::value, "Bitfield bool");
2753
2754 struct GreaterSizeBitfield {
2755 //expected-warning@+1 {{width of bit-field 'n'}}
2756 int n : 1024;
2757 };
2758
2759 static_assert(sizeof(GreaterSizeBitfield) == 128, "Bitfield Size");
2760 static_assert(!has_unique_object_representations<GreaterSizeBitfield>::value, "Bitfield padding");
2761
2762 struct StructWithRef {
2763 int &I;
2764 };
2765
2766 static_assert(has_unique_object_representations<StructWithRef>::value, "References are still unique");
2767
2768 struct NotUniqueBecauseTailPadding {
2769 int &r;
2770 char a;
2771 };
2772 struct CanBeUniqueIfNoPadding : NotUniqueBecauseTailPadding {
2773 char b[7];
2774 };
2775
2776 static_assert(!has_unique_object_representations<NotUniqueBecauseTailPadding>::value,
2777 "non trivial");
2778 // Can be unique on Itanium, since the is child class' data is 'folded' into the
2779 // parent's tail padding.
2780 static_assert(sizeof(CanBeUniqueIfNoPadding) != 16 ||
2781 has_unique_object_representations<CanBeUniqueIfNoPadding>::value,
2782 "inherit from std layout");
2783
2784 namespace ErrorType {
2785 struct S; //expected-note{{forward declaration of 'ErrorType::S'}}
2786
2787 struct T {
2788 S t; //expected-error{{field has incomplete type 'ErrorType::S'}}
2789 };
2790 bool b = __has_unique_object_representations(T);
2791 };
2792
2793 namespace PR46209 {
2794 // Foo has both a trivial assignment operator and a non-trivial one.
2795 struct Foo {
operator =PR46209::Foo2796 Foo &operator=(const Foo &) & { return *this; }
2797 Foo &operator=(const Foo &) && = default;
2798 };
2799
2800 // Bar's copy assignment calls Foo's non-trivial assignment.
2801 struct Bar {
2802 Foo foo;
2803 };
2804
2805 static_assert(!__is_trivially_assignable(Foo &, const Foo &), "");
2806 static_assert(!__is_trivially_assignable(Bar &, const Bar &), "");
2807
2808 // Foo2 has both a trivial assignment operator and a non-trivial one.
2809 struct Foo2 {
2810 Foo2 &operator=(const Foo2 &) & = default;
operator =PR46209::Foo22811 Foo2 &operator=(const Foo2 &) && { return *this; }
2812 };
2813
2814 // Bar2's copy assignment calls Foo2's trivial assignment.
2815 struct Bar2 {
2816 Foo2 foo;
2817 };
2818
2819 static_assert(__is_trivially_assignable(Foo2 &, const Foo2 &), "");
2820 static_assert(__is_trivially_assignable(Bar2 &, const Bar2 &), "");
2821 }
2822
2823 namespace ConstClass {
2824 struct A {
2825 A &operator=(const A&) = default;
2826 };
2827 struct B {
2828 const A a;
2829 };
2830 static_assert(!__is_trivially_assignable(B&, const B&), "");
2831 }
2832
2833 namespace type_trait_expr_numargs_overflow {
2834 // Make sure that TypeTraitExpr can store 16 bits worth of arguments.
2835 #define T4(X) X,X,X,X
2836 #define T16(X) T4(X),T4(X),T4(X),T4(X)
2837 #define T64(X) T16(X),T16(X),T16(X),T16(X)
2838 #define T256(X) T64(X),T64(X),T64(X),T64(X)
2839 #define T1024(X) T256(X),T256(X),T256(X),T256(X)
2840 #define T4096(X) T1024(X),T1024(X),T1024(X),T1024(X)
2841 #define T16384(X) T4096(X),T4096(X),T4096(X),T4096(X)
2842 #define T32768(X) T16384(X),T16384(X)
test()2843 void test() { (void) __is_constructible(int, T32768(int)); }
2844 #undef T4
2845 #undef T16
2846 #undef T64
2847 #undef T256
2848 #undef T1024
2849 #undef T4096
2850 #undef T16384
2851 #undef T32768
2852 } // namespace type_trait_expr_numargs_overflow
2853