1 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted -Wno-c++17-extensions %s 2 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++14 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted -Wno-c++17-extensions %s 3 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++17 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted %s 4 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++20 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted %s 5 6 7 struct NonPOD { NonPOD(int); }; 8 typedef NonPOD NonPODAr[10]; 9 typedef NonPOD NonPODArNB[]; 10 typedef NonPOD NonPODArMB[10][2]; 11 12 // PODs 13 enum Enum { EV }; 14 enum SignedEnum : signed int { }; 15 enum UnsignedEnum : unsigned int { }; 16 enum class EnumClass { EV }; 17 enum class SignedEnumClass : signed int {}; 18 enum class UnsignedEnumClass : unsigned int {}; 19 struct POD { Enum e; int i; float f; NonPOD* p; }; 20 struct Empty {}; 21 struct IncompleteStruct; // expected-note {{forward declaration of 'IncompleteStruct'}} 22 typedef Empty EmptyAr[10]; 23 typedef Empty EmptyArNB[]; 24 typedef Empty EmptyArMB[1][2]; 25 typedef int Int; 26 typedef Int IntAr[10]; 27 typedef Int IntArNB[]; 28 typedef Int IntArZero[0]; 29 class Statics { static int priv; static NonPOD np; }; 30 union EmptyUnion {}; 31 union IncompleteUnion; // expected-note {{forward declaration of 'IncompleteUnion'}} 32 union Union { int i; float f; }; 33 struct HasFunc { void f (); }; 34 struct HasOp { void operator *(); }; 35 struct HasConv { operator int(); }; 36 struct HasAssign { void operator =(int); }; 37 38 struct HasAnonymousUnion { 39 union { 40 int i; 41 float f; 42 }; 43 }; 44 45 typedef int Vector __attribute__((vector_size(16))); 46 typedef int VectorExt __attribute__((ext_vector_type(4))); 47 48 using ComplexFloat = _Complex float; 49 using ComplexInt = _Complex int; 50 51 // Not PODs 52 typedef const void cvoid; 53 struct Derives : POD {}; 54 typedef Derives DerivesAr[10]; 55 typedef Derives DerivesArNB[]; 56 struct DerivesEmpty : Empty {}; 57 struct HasCons { HasCons(int); }; 58 struct HasDefaultCons { HasDefaultCons() = default; }; 59 struct HasExplicitDefaultCons { explicit HasExplicitDefaultCons() = default; }; 60 struct HasInheritedCons : HasDefaultCons { using HasDefaultCons::HasDefaultCons; }; 61 struct HasNoInheritedCons : HasCons {}; 62 struct HasCopyAssign { HasCopyAssign operator =(const HasCopyAssign&); }; 63 struct HasMoveAssign { HasMoveAssign operator =(const HasMoveAssign&&); }; 64 struct HasNoThrowMoveAssign { 65 HasNoThrowMoveAssign& operator=( 66 const HasNoThrowMoveAssign&&) throw(); }; 67 struct HasNoExceptNoThrowMoveAssign { 68 HasNoExceptNoThrowMoveAssign& operator=( 69 const HasNoExceptNoThrowMoveAssign&&) noexcept; 70 }; 71 struct HasThrowMoveAssign { 72 HasThrowMoveAssign& operator=(const HasThrowMoveAssign&&) 73 #if __cplusplus <= 201402L 74 throw(POD); 75 #else 76 noexcept(false); 77 #endif 78 }; 79 80 81 struct HasNoExceptFalseMoveAssign { 82 HasNoExceptFalseMoveAssign& operator=( 83 const HasNoExceptFalseMoveAssign&&) noexcept(false); }; 84 struct HasMoveCtor { HasMoveCtor(const HasMoveCtor&&); }; 85 struct HasMemberMoveCtor { HasMoveCtor member; }; 86 struct HasMemberMoveAssign { HasMoveAssign member; }; 87 struct HasStaticMemberMoveCtor { static HasMoveCtor member; }; 88 struct HasStaticMemberMoveAssign { static HasMoveAssign member; }; 89 struct HasMemberThrowMoveAssign { HasThrowMoveAssign member; }; 90 struct HasMemberNoExceptFalseMoveAssign { 91 HasNoExceptFalseMoveAssign member; }; 92 struct HasMemberNoThrowMoveAssign { HasNoThrowMoveAssign member; }; 93 struct HasMemberNoExceptNoThrowMoveAssign { 94 HasNoExceptNoThrowMoveAssign member; }; 95 96 struct HasDefaultTrivialCopyAssign { 97 HasDefaultTrivialCopyAssign &operator=( 98 const HasDefaultTrivialCopyAssign&) = default; 99 }; 100 struct TrivialMoveButNotCopy { 101 TrivialMoveButNotCopy &operator=(TrivialMoveButNotCopy&&) = default; 102 TrivialMoveButNotCopy &operator=(const TrivialMoveButNotCopy&); 103 }; 104 struct NonTrivialDefault { 105 NonTrivialDefault(); 106 }; 107 108 struct HasDest { ~HasDest(); }; 109 class HasPriv { int priv; }; 110 class HasProt { protected: int prot; }; 111 struct HasRef { int i; int& ref; HasRef() : i(0), ref(i) {} }; 112 struct HasRefAggregate { int i; int& ref; }; 113 struct HasNonPOD { NonPOD np; }; 114 struct HasVirt { virtual void Virt() {}; }; 115 typedef NonPOD NonPODAr[10]; 116 typedef HasVirt VirtAr[10]; 117 typedef NonPOD NonPODArNB[]; 118 union NonPODUnion { int i; Derives n; }; 119 struct DerivesHasCons : HasCons {}; 120 struct DerivesHasCopyAssign : HasCopyAssign {}; 121 struct DerivesHasMoveAssign : HasMoveAssign {}; 122 struct DerivesHasDest : HasDest {}; 123 struct DerivesHasPriv : HasPriv {}; 124 struct DerivesHasProt : HasProt {}; 125 struct DerivesHasRef : HasRef {}; 126 struct DerivesHasVirt : HasVirt {}; 127 struct DerivesHasMoveCtor : HasMoveCtor {}; 128 129 struct HasNoThrowCopyAssign { 130 void operator =(const HasNoThrowCopyAssign&) throw(); 131 }; 132 struct HasMultipleCopyAssign { 133 void operator =(const HasMultipleCopyAssign&) throw(); 134 void operator =(volatile HasMultipleCopyAssign&); 135 }; 136 struct HasMultipleNoThrowCopyAssign { 137 void operator =(const HasMultipleNoThrowCopyAssign&) throw(); 138 void operator =(volatile HasMultipleNoThrowCopyAssign&) throw(); 139 }; 140 141 struct HasNoThrowConstructor { HasNoThrowConstructor() throw(); }; 142 struct HasNoThrowConstructorWithArgs { 143 HasNoThrowConstructorWithArgs(HasCons i = HasCons(0)) throw(); 144 }; 145 struct HasMultipleDefaultConstructor1 { 146 HasMultipleDefaultConstructor1() throw(); 147 HasMultipleDefaultConstructor1(int i = 0); 148 }; 149 struct HasMultipleDefaultConstructor2 { 150 HasMultipleDefaultConstructor2(int i = 0); 151 HasMultipleDefaultConstructor2() throw(); 152 }; 153 154 struct HasNoThrowCopy { HasNoThrowCopy(const HasNoThrowCopy&) throw(); }; 155 struct HasMultipleCopy { 156 HasMultipleCopy(const HasMultipleCopy&) throw(); 157 HasMultipleCopy(volatile HasMultipleCopy&); 158 }; 159 struct HasMultipleNoThrowCopy { 160 HasMultipleNoThrowCopy(const HasMultipleNoThrowCopy&) throw(); 161 HasMultipleNoThrowCopy(volatile HasMultipleNoThrowCopy&) throw(); 162 }; 163 164 struct HasVirtDest { virtual ~HasVirtDest(); }; 165 struct DerivedVirtDest : HasVirtDest {}; 166 typedef HasVirtDest VirtDestAr[1]; 167 168 class AllPrivate { 169 AllPrivate() throw(); 170 AllPrivate(const AllPrivate&) throw(); 171 AllPrivate &operator=(const AllPrivate &) throw(); 172 ~AllPrivate() throw(); 173 }; 174 175 struct ThreeArgCtor { 176 ThreeArgCtor(int*, char*, int); 177 }; 178 179 struct VariadicCtor { 180 template<typename...T> VariadicCtor(T...); 181 }; 182 183 struct ThrowingDtor { 184 ~ThrowingDtor() 185 #if __cplusplus <= 201402L 186 throw(int); 187 #else 188 noexcept(false); 189 #endif 190 }; 191 192 struct NoExceptDtor { 193 ~NoExceptDtor() noexcept(true); 194 }; 195 196 struct NoThrowDtor { 197 ~NoThrowDtor() throw(); 198 }; 199 200 struct ACompleteType {}; 201 struct AnIncompleteType; // expected-note 1+ {{forward declaration of 'AnIncompleteType'}} 202 typedef AnIncompleteType AnIncompleteTypeAr[42]; 203 typedef AnIncompleteType AnIncompleteTypeArNB[]; 204 typedef AnIncompleteType AnIncompleteTypeArMB[1][10]; 205 206 struct HasInClassInit { 207 int x = 42; 208 }; 209 210 struct HasPrivateBase : private ACompleteType {}; 211 struct HasProtectedBase : protected ACompleteType {}; 212 struct HasVirtBase : virtual ACompleteType {}; 213 214 void is_pod() 215 { 216 static_assert(__is_pod(int)); 217 static_assert(__is_pod(Enum)); 218 static_assert(__is_pod(POD)); 219 static_assert(__is_pod(Int)); 220 static_assert(__is_pod(IntAr)); 221 static_assert(__is_pod(Statics)); 222 static_assert(__is_pod(Empty)); 223 static_assert(__is_pod(EmptyUnion)); 224 static_assert(__is_pod(Union)); 225 static_assert(__is_pod(HasFunc)); 226 static_assert(__is_pod(HasOp)); 227 static_assert(__is_pod(HasConv)); 228 static_assert(__is_pod(HasAssign)); 229 static_assert(__is_pod(IntArNB)); 230 static_assert(__is_pod(HasAnonymousUnion)); 231 static_assert(__is_pod(Vector)); 232 static_assert(__is_pod(VectorExt)); 233 static_assert(__is_pod(Derives)); 234 static_assert(__is_pod(DerivesAr)); 235 static_assert(__is_pod(DerivesArNB)); 236 static_assert(__is_pod(DerivesEmpty)); 237 static_assert(__is_pod(HasPriv)); 238 static_assert(__is_pod(HasProt)); 239 static_assert(__is_pod(DerivesHasPriv)); 240 static_assert(__is_pod(DerivesHasProt)); 241 242 static_assert(!__is_pod(HasCons)); 243 static_assert(!__is_pod(HasCopyAssign)); 244 static_assert(!__is_pod(HasMoveAssign)); 245 static_assert(!__is_pod(HasDest)); 246 static_assert(!__is_pod(HasRef)); 247 static_assert(!__is_pod(HasVirt)); 248 static_assert(!__is_pod(DerivesHasCons)); 249 static_assert(!__is_pod(DerivesHasCopyAssign)); 250 static_assert(!__is_pod(DerivesHasMoveAssign)); 251 static_assert(!__is_pod(DerivesHasDest)); 252 static_assert(!__is_pod(DerivesHasRef)); 253 static_assert(!__is_pod(DerivesHasVirt)); 254 static_assert(!__is_pod(NonPOD)); 255 static_assert(!__is_pod(HasNonPOD)); 256 static_assert(!__is_pod(NonPODAr)); 257 static_assert(!__is_pod(NonPODArNB)); 258 static_assert(!__is_pod(void)); 259 static_assert(!__is_pod(cvoid)); 260 // static_assert(!__is_pod(NonPODUnion)); 261 262 static_assert(__is_pod(ACompleteType)); 263 static_assert(!__is_pod(AnIncompleteType)); // expected-error {{incomplete type}} 264 static_assert(!__is_pod(AnIncompleteType[])); // expected-error {{incomplete type}} 265 static_assert(!__is_pod(AnIncompleteType[1])); // expected-error {{incomplete type}} 266 } 267 268 typedef Empty EmptyAr[10]; 269 struct Bit0 { int : 0; }; 270 struct Bit0Cons { int : 0; Bit0Cons(); }; 271 struct AnonBitOnly { int : 3; }; 272 struct BitOnly { int x : 3; }; 273 struct DerivesVirt : virtual POD {}; 274 275 void is_empty() 276 { 277 static_assert(__is_empty(Empty)); 278 static_assert(__is_empty(DerivesEmpty)); 279 static_assert(__is_empty(HasCons)); 280 static_assert(__is_empty(HasCopyAssign)); 281 static_assert(__is_empty(HasMoveAssign)); 282 static_assert(__is_empty(HasDest)); 283 static_assert(__is_empty(HasFunc)); 284 static_assert(__is_empty(HasOp)); 285 static_assert(__is_empty(HasConv)); 286 static_assert(__is_empty(HasAssign)); 287 static_assert(__is_empty(Bit0)); 288 static_assert(__is_empty(Bit0Cons)); 289 290 static_assert(!__is_empty(Int)); 291 static_assert(!__is_empty(POD)); 292 static_assert(!__is_empty(EmptyUnion)); 293 static_assert(!__is_empty(IncompleteUnion)); 294 static_assert(!__is_empty(EmptyAr)); 295 static_assert(!__is_empty(HasRef)); 296 static_assert(!__is_empty(HasVirt)); 297 static_assert(!__is_empty(AnonBitOnly)); 298 static_assert(!__is_empty(BitOnly)); 299 static_assert(!__is_empty(void)); 300 static_assert(!__is_empty(IntArNB)); 301 static_assert(!__is_empty(HasAnonymousUnion)); 302 // static_assert(!__is_empty(DerivesVirt)); 303 304 static_assert(__is_empty(ACompleteType)); 305 static_assert(!__is_empty(AnIncompleteType)); // expected-error {{incomplete type}} 306 static_assert(!__is_empty(AnIncompleteType[])); 307 static_assert(!__is_empty(AnIncompleteType[1])); 308 } 309 310 typedef Derives ClassType; 311 312 void is_class() 313 { 314 static_assert(__is_class(Derives)); 315 static_assert(__is_class(HasPriv)); 316 static_assert(__is_class(ClassType)); 317 static_assert(__is_class(HasAnonymousUnion)); 318 319 static_assert(!__is_class(int)); 320 static_assert(!__is_class(Enum)); 321 static_assert(!__is_class(Int)); 322 static_assert(!__is_class(IntAr)); 323 static_assert(!__is_class(DerivesAr)); 324 static_assert(!__is_class(Union)); 325 static_assert(!__is_class(cvoid)); 326 static_assert(!__is_class(IntArNB)); 327 } 328 329 typedef Union UnionAr[10]; 330 typedef Union UnionType; 331 332 void is_union() 333 { 334 static_assert(__is_union(Union)); 335 static_assert(__is_union(UnionType)); 336 337 static_assert(!__is_union(int)); 338 static_assert(!__is_union(Enum)); 339 static_assert(!__is_union(Int)); 340 static_assert(!__is_union(IntAr)); 341 static_assert(!__is_union(UnionAr)); 342 static_assert(!__is_union(cvoid)); 343 static_assert(!__is_union(IntArNB)); 344 static_assert(!__is_union(HasAnonymousUnion)); 345 } 346 347 typedef Enum EnumType; 348 typedef EnumClass EnumClassType; 349 350 void is_enum() 351 { 352 static_assert(__is_enum(Enum)); 353 static_assert(__is_enum(EnumType)); 354 static_assert(__is_enum(SignedEnum)); 355 static_assert(__is_enum(UnsignedEnum)); 356 357 static_assert(__is_enum(EnumClass)); 358 static_assert(__is_enum(EnumClassType)); 359 static_assert(__is_enum(SignedEnumClass)); 360 static_assert(__is_enum(UnsignedEnumClass)); 361 362 static_assert(!__is_enum(int)); 363 static_assert(!__is_enum(Union)); 364 static_assert(!__is_enum(Int)); 365 static_assert(!__is_enum(IntAr)); 366 static_assert(!__is_enum(UnionAr)); 367 static_assert(!__is_enum(Derives)); 368 static_assert(!__is_enum(ClassType)); 369 static_assert(!__is_enum(cvoid)); 370 static_assert(!__is_enum(IntArNB)); 371 static_assert(!__is_enum(HasAnonymousUnion)); 372 static_assert(!__is_enum(AnIncompleteType)); 373 static_assert(!__is_enum(AnIncompleteTypeAr)); 374 static_assert(!__is_enum(AnIncompleteTypeArMB)); 375 static_assert(!__is_enum(AnIncompleteTypeArNB)); 376 } 377 378 void is_scoped_enum() { 379 static_assert(!__is_scoped_enum(Enum)); 380 static_assert(!__is_scoped_enum(EnumType)); 381 static_assert(!__is_scoped_enum(SignedEnum)); 382 static_assert(!__is_scoped_enum(UnsignedEnum)); 383 384 static_assert(__is_scoped_enum(EnumClass)); 385 static_assert(__is_scoped_enum(EnumClassType)); 386 static_assert(__is_scoped_enum(SignedEnumClass)); 387 static_assert(__is_scoped_enum(UnsignedEnumClass)); 388 389 static_assert(!__is_scoped_enum(int)); 390 static_assert(!__is_scoped_enum(Union)); 391 static_assert(!__is_scoped_enum(Int)); 392 static_assert(!__is_scoped_enum(IntAr)); 393 static_assert(!__is_scoped_enum(UnionAr)); 394 static_assert(!__is_scoped_enum(Derives)); 395 static_assert(!__is_scoped_enum(ClassType)); 396 static_assert(!__is_scoped_enum(cvoid)); 397 static_assert(!__is_scoped_enum(IntArNB)); 398 static_assert(!__is_scoped_enum(HasAnonymousUnion)); 399 static_assert(!__is_scoped_enum(AnIncompleteType)); 400 static_assert(!__is_scoped_enum(AnIncompleteTypeAr)); 401 static_assert(!__is_scoped_enum(AnIncompleteTypeArMB)); 402 static_assert(!__is_scoped_enum(AnIncompleteTypeArNB)); 403 } 404 405 struct FinalClass final { 406 }; 407 408 template<typename T> 409 struct PotentiallyFinal { }; 410 411 template<typename T> 412 struct PotentiallyFinal<T*> final { }; 413 414 template<> 415 struct PotentiallyFinal<int> final { }; 416 417 418 419 420 421 void is_final() 422 { 423 static_assert(__is_final(FinalClass)); 424 static_assert(__is_final(PotentiallyFinal<float*>)); 425 static_assert(__is_final(PotentiallyFinal<int>)); 426 427 static_assert(!__is_final(int)); 428 static_assert(!__is_final(Union)); 429 static_assert(!__is_final(Int)); 430 static_assert(!__is_final(IntAr)); 431 static_assert(!__is_final(UnionAr)); 432 static_assert(!__is_final(Derives)); 433 static_assert(!__is_final(ClassType)); 434 static_assert(!__is_final(cvoid)); 435 static_assert(!__is_final(IntArNB)); 436 static_assert(!__is_final(HasAnonymousUnion)); 437 } 438 439 440 typedef HasVirt Polymorph; 441 struct InheritPolymorph : Polymorph {}; 442 443 void is_polymorphic() 444 { 445 static_assert(__is_polymorphic(Polymorph)); 446 static_assert(__is_polymorphic(InheritPolymorph)); 447 448 static_assert(!__is_polymorphic(int)); 449 static_assert(!__is_polymorphic(Union)); 450 static_assert(!__is_polymorphic(IncompleteUnion)); 451 static_assert(!__is_polymorphic(Int)); 452 static_assert(!__is_polymorphic(IntAr)); 453 static_assert(!__is_polymorphic(UnionAr)); 454 static_assert(!__is_polymorphic(Derives)); 455 static_assert(!__is_polymorphic(ClassType)); 456 static_assert(!__is_polymorphic(Enum)); 457 static_assert(!__is_polymorphic(cvoid)); 458 static_assert(!__is_polymorphic(IntArNB)); 459 } 460 461 void is_integral() 462 { 463 static_assert(__is_integral(bool)); 464 static_assert(__is_integral(char)); 465 static_assert(__is_integral(signed char)); 466 static_assert(__is_integral(unsigned char)); 467 //static_assert(__is_integral(char16_t)); 468 //static_assert(__is_integral(char32_t)); 469 static_assert(__is_integral(wchar_t)); 470 static_assert(__is_integral(short)); 471 static_assert(__is_integral(unsigned short)); 472 static_assert(__is_integral(int)); 473 static_assert(__is_integral(unsigned int)); 474 static_assert(__is_integral(long)); 475 static_assert(__is_integral(unsigned long)); 476 477 static_assert(!__is_integral(float)); 478 static_assert(!__is_integral(double)); 479 static_assert(!__is_integral(long double)); 480 static_assert(!__is_integral(Union)); 481 static_assert(!__is_integral(UnionAr)); 482 static_assert(!__is_integral(Derives)); 483 static_assert(!__is_integral(ClassType)); 484 static_assert(!__is_integral(Enum)); 485 static_assert(!__is_integral(void)); 486 static_assert(!__is_integral(cvoid)); 487 static_assert(!__is_integral(IntArNB)); 488 } 489 490 void is_floating_point() 491 { 492 static_assert(__is_floating_point(float)); 493 static_assert(__is_floating_point(double)); 494 static_assert(__is_floating_point(long double)); 495 496 static_assert(!__is_floating_point(bool)); 497 static_assert(!__is_floating_point(char)); 498 static_assert(!__is_floating_point(signed char)); 499 static_assert(!__is_floating_point(unsigned char)); 500 //static_assert(!__is_floating_point(char16_t)); 501 //static_assert(!__is_floating_point(char32_t)); 502 static_assert(!__is_floating_point(wchar_t)); 503 static_assert(!__is_floating_point(short)); 504 static_assert(!__is_floating_point(unsigned short)); 505 static_assert(!__is_floating_point(int)); 506 static_assert(!__is_floating_point(unsigned int)); 507 static_assert(!__is_floating_point(long)); 508 static_assert(!__is_floating_point(unsigned long)); 509 static_assert(!__is_floating_point(Union)); 510 static_assert(!__is_floating_point(UnionAr)); 511 static_assert(!__is_floating_point(Derives)); 512 static_assert(!__is_floating_point(ClassType)); 513 static_assert(!__is_floating_point(Enum)); 514 static_assert(!__is_floating_point(void)); 515 static_assert(!__is_floating_point(cvoid)); 516 static_assert(!__is_floating_point(IntArNB)); 517 } 518 519 template <class T> 520 struct AggregateTemplate { 521 T value; 522 }; 523 524 template <class T> 525 struct NonAggregateTemplate { 526 T value; 527 NonAggregateTemplate(); 528 }; 529 530 void is_aggregate() 531 { 532 constexpr bool TrueAfterCpp11 = __cplusplus > 201103L; 533 constexpr bool TrueAfterCpp14 = __cplusplus > 201402L; 534 535 __is_aggregate(AnIncompleteType); // expected-error {{incomplete type}} 536 __is_aggregate(IncompleteUnion); // expected-error {{incomplete type}} 537 538 // Valid since LWG3823 539 static_assert(__is_aggregate(AnIncompleteType[])); 540 static_assert(__is_aggregate(AnIncompleteType[1])); 541 static_assert(__is_aggregate(AnIncompleteTypeAr)); 542 static_assert(__is_aggregate(AnIncompleteTypeArNB)); 543 static_assert(__is_aggregate(AnIncompleteTypeArMB)); 544 545 static_assert(!__is_aggregate(NonPOD)); 546 static_assert(__is_aggregate(NonPODAr)); 547 static_assert(__is_aggregate(NonPODArNB)); 548 static_assert(__is_aggregate(NonPODArMB)); 549 550 static_assert(!__is_aggregate(Enum)); 551 static_assert(__is_aggregate(POD)); 552 static_assert(__is_aggregate(Empty)); 553 static_assert(__is_aggregate(EmptyAr)); 554 static_assert(__is_aggregate(EmptyArNB)); 555 static_assert(__is_aggregate(EmptyArMB)); 556 static_assert(!__is_aggregate(void)); 557 static_assert(!__is_aggregate(const volatile void)); 558 static_assert(!__is_aggregate(int)); 559 static_assert(__is_aggregate(IntAr)); 560 static_assert(__is_aggregate(IntArNB)); 561 static_assert(__is_aggregate(EmptyUnion)); 562 static_assert(__is_aggregate(Union)); 563 static_assert(__is_aggregate(Statics)); 564 static_assert(__is_aggregate(HasFunc)); 565 static_assert(__is_aggregate(HasOp)); 566 static_assert(__is_aggregate(HasAssign)); 567 static_assert(__is_aggregate(HasAnonymousUnion)); 568 569 static_assert(__is_aggregate(Derives) == TrueAfterCpp14); 570 static_assert(__is_aggregate(DerivesAr)); 571 static_assert(__is_aggregate(DerivesArNB)); 572 static_assert(!__is_aggregate(HasCons)); 573 #if __cplusplus >= 202002L 574 static_assert(!__is_aggregate(HasDefaultCons)); 575 #else 576 static_assert(__is_aggregate(HasDefaultCons)); 577 #endif 578 static_assert(!__is_aggregate(HasExplicitDefaultCons)); 579 static_assert(!__is_aggregate(HasInheritedCons)); 580 static_assert(__is_aggregate(HasNoInheritedCons) == TrueAfterCpp14); 581 static_assert(__is_aggregate(HasCopyAssign)); 582 static_assert(!__is_aggregate(NonTrivialDefault)); 583 static_assert(__is_aggregate(HasDest)); 584 static_assert(!__is_aggregate(HasPriv)); 585 static_assert(!__is_aggregate(HasProt)); 586 static_assert(__is_aggregate(HasRefAggregate)); 587 static_assert(__is_aggregate(HasNonPOD)); 588 static_assert(!__is_aggregate(HasVirt)); 589 static_assert(__is_aggregate(VirtAr)); 590 static_assert(__is_aggregate(HasInClassInit) == TrueAfterCpp11); 591 static_assert(!__is_aggregate(HasPrivateBase)); 592 static_assert(!__is_aggregate(HasProtectedBase)); 593 static_assert(!__is_aggregate(HasVirtBase)); 594 595 static_assert(__is_aggregate(AggregateTemplate<int>)); 596 static_assert(!__is_aggregate(NonAggregateTemplate<int>)); 597 598 static_assert(__is_aggregate(Vector)); // Extension supported by GCC and Clang 599 static_assert(__is_aggregate(VectorExt)); 600 static_assert(__is_aggregate(ComplexInt)); 601 static_assert(__is_aggregate(ComplexFloat)); 602 } 603 604 void is_arithmetic() 605 { 606 static_assert(__is_arithmetic(float)); 607 static_assert(__is_arithmetic(double)); 608 static_assert(__is_arithmetic(long double)); 609 static_assert(__is_arithmetic(bool)); 610 static_assert(__is_arithmetic(char)); 611 static_assert(__is_arithmetic(signed char)); 612 static_assert(__is_arithmetic(unsigned char)); 613 //static_assert(__is_arithmetic(char16_t)); 614 //static_assert(__is_arithmetic(char32_t)); 615 static_assert(__is_arithmetic(wchar_t)); 616 static_assert(__is_arithmetic(short)); 617 static_assert(__is_arithmetic(unsigned short)); 618 static_assert(__is_arithmetic(int)); 619 static_assert(__is_arithmetic(unsigned int)); 620 static_assert(__is_arithmetic(long)); 621 static_assert(__is_arithmetic(unsigned long)); 622 623 static_assert(!__is_arithmetic(Union)); 624 static_assert(!__is_arithmetic(UnionAr)); 625 static_assert(!__is_arithmetic(Derives)); 626 static_assert(!__is_arithmetic(ClassType)); 627 static_assert(!__is_arithmetic(Enum)); 628 static_assert(!__is_arithmetic(void)); 629 static_assert(!__is_arithmetic(cvoid)); 630 static_assert(!__is_arithmetic(IntArNB)); 631 } 632 633 void is_complete_type() 634 { 635 static_assert(__is_complete_type(float)); 636 static_assert(__is_complete_type(double)); 637 static_assert(__is_complete_type(long double)); 638 static_assert(__is_complete_type(bool)); 639 static_assert(__is_complete_type(char)); 640 static_assert(__is_complete_type(signed char)); 641 static_assert(__is_complete_type(unsigned char)); 642 //static_assert(__is_complete_type(char16_t)); 643 //static_assert(__is_complete_type(char32_t)); 644 static_assert(__is_complete_type(wchar_t)); 645 static_assert(__is_complete_type(short)); 646 static_assert(__is_complete_type(unsigned short)); 647 static_assert(__is_complete_type(int)); 648 static_assert(__is_complete_type(unsigned int)); 649 static_assert(__is_complete_type(long)); 650 static_assert(__is_complete_type(unsigned long)); 651 static_assert(__is_complete_type(ACompleteType)); 652 653 static_assert(!__is_complete_type(AnIncompleteType)); 654 } 655 656 void is_void() 657 { 658 static_assert(__is_void(void)); 659 static_assert(__is_void(cvoid)); 660 661 static_assert(!__is_void(float)); 662 static_assert(!__is_void(double)); 663 static_assert(!__is_void(long double)); 664 static_assert(!__is_void(bool)); 665 static_assert(!__is_void(char)); 666 static_assert(!__is_void(signed char)); 667 static_assert(!__is_void(unsigned char)); 668 static_assert(!__is_void(wchar_t)); 669 static_assert(!__is_void(short)); 670 static_assert(!__is_void(unsigned short)); 671 static_assert(!__is_void(int)); 672 static_assert(!__is_void(unsigned int)); 673 static_assert(!__is_void(long)); 674 static_assert(!__is_void(unsigned long)); 675 static_assert(!__is_void(Union)); 676 static_assert(!__is_void(UnionAr)); 677 static_assert(!__is_void(Derives)); 678 static_assert(!__is_void(ClassType)); 679 static_assert(!__is_void(Enum)); 680 static_assert(!__is_void(IntArNB)); 681 static_assert(!__is_void(void*)); 682 static_assert(!__is_void(cvoid*)); 683 } 684 685 void is_array() 686 { 687 static_assert(__is_array(IntAr)); 688 static_assert(__is_array(IntArNB)); 689 static_assert(!__is_array(IntArZero)); 690 static_assert(__is_array(UnionAr)); 691 692 static_assert(!__is_array(void)); 693 static_assert(!__is_array(cvoid)); 694 static_assert(!__is_array(float)); 695 static_assert(!__is_array(double)); 696 static_assert(!__is_array(long double)); 697 static_assert(!__is_array(bool)); 698 static_assert(!__is_array(char)); 699 static_assert(!__is_array(signed char)); 700 static_assert(!__is_array(unsigned char)); 701 static_assert(!__is_array(wchar_t)); 702 static_assert(!__is_array(short)); 703 static_assert(!__is_array(unsigned short)); 704 static_assert(!__is_array(int)); 705 static_assert(!__is_array(unsigned int)); 706 static_assert(!__is_array(long)); 707 static_assert(!__is_array(unsigned long)); 708 static_assert(!__is_array(Union)); 709 static_assert(!__is_array(Derives)); 710 static_assert(!__is_array(ClassType)); 711 static_assert(!__is_array(Enum)); 712 static_assert(!__is_array(void*)); 713 static_assert(!__is_array(cvoid*)); 714 } 715 716 void is_bounded_array(int n) { 717 static_assert(__is_bounded_array(IntAr)); 718 static_assert(!__is_bounded_array(IntArNB)); 719 static_assert(!__is_bounded_array(IntArZero)); 720 static_assert(__is_bounded_array(UnionAr)); 721 722 static_assert(!__is_bounded_array(void)); 723 static_assert(!__is_bounded_array(cvoid)); 724 static_assert(!__is_bounded_array(float)); 725 static_assert(!__is_bounded_array(double)); 726 static_assert(!__is_bounded_array(long double)); 727 static_assert(!__is_bounded_array(bool)); 728 static_assert(!__is_bounded_array(char)); 729 static_assert(!__is_bounded_array(signed char)); 730 static_assert(!__is_bounded_array(unsigned char)); 731 static_assert(!__is_bounded_array(wchar_t)); 732 static_assert(!__is_bounded_array(short)); 733 static_assert(!__is_bounded_array(unsigned short)); 734 static_assert(!__is_bounded_array(int)); 735 static_assert(!__is_bounded_array(unsigned int)); 736 static_assert(!__is_bounded_array(long)); 737 static_assert(!__is_bounded_array(unsigned long)); 738 static_assert(!__is_bounded_array(Union)); 739 static_assert(!__is_bounded_array(Derives)); 740 static_assert(!__is_bounded_array(ClassType)); 741 static_assert(!__is_bounded_array(Enum)); 742 static_assert(!__is_bounded_array(void *)); 743 static_assert(!__is_bounded_array(cvoid *)); 744 745 int t32[n]; 746 (void)__is_bounded_array(decltype(t32)); // expected-error{{variable length arrays are not supported in '__is_bounded_array'}} 747 } 748 749 void is_unbounded_array(int n) { 750 static_assert(!__is_unbounded_array(IntAr)); 751 static_assert(__is_unbounded_array(IntArNB)); 752 static_assert(!__is_unbounded_array(IntArZero)); 753 static_assert(!__is_unbounded_array(UnionAr)); 754 755 static_assert(!__is_unbounded_array(void)); 756 static_assert(!__is_unbounded_array(cvoid)); 757 static_assert(!__is_unbounded_array(float)); 758 static_assert(!__is_unbounded_array(double)); 759 static_assert(!__is_unbounded_array(long double)); 760 static_assert(!__is_unbounded_array(bool)); 761 static_assert(!__is_unbounded_array(char)); 762 static_assert(!__is_unbounded_array(signed char)); 763 static_assert(!__is_unbounded_array(unsigned char)); 764 static_assert(!__is_unbounded_array(wchar_t)); 765 static_assert(!__is_unbounded_array(short)); 766 static_assert(!__is_unbounded_array(unsigned short)); 767 static_assert(!__is_unbounded_array(int)); 768 static_assert(!__is_unbounded_array(unsigned int)); 769 static_assert(!__is_unbounded_array(long)); 770 static_assert(!__is_unbounded_array(unsigned long)); 771 static_assert(!__is_unbounded_array(Union)); 772 static_assert(!__is_unbounded_array(Derives)); 773 static_assert(!__is_unbounded_array(ClassType)); 774 static_assert(!__is_unbounded_array(Enum)); 775 static_assert(!__is_unbounded_array(void *)); 776 static_assert(!__is_unbounded_array(cvoid *)); 777 778 int t32[n]; 779 (void)__is_unbounded_array(decltype(t32)); // expected-error{{variable length arrays are not supported in '__is_unbounded_array'}} 780 } 781 782 void is_referenceable() { 783 static_assert(__is_referenceable(int)); 784 static_assert(__is_referenceable(const int)); 785 static_assert(__is_referenceable(volatile int)); 786 static_assert(__is_referenceable(const volatile int)); 787 static_assert(__is_referenceable(int *)); 788 static_assert(__is_referenceable(int &)); 789 static_assert(__is_referenceable(int &&)); 790 static_assert(__is_referenceable(int (*)())); 791 static_assert(__is_referenceable(int (&)())); 792 static_assert(__is_referenceable(int(&&)())); 793 static_assert(__is_referenceable(IntAr)); 794 static_assert(__is_referenceable(IntArNB)); 795 static_assert(__is_referenceable(decltype(nullptr))); 796 static_assert(__is_referenceable(Empty)); 797 static_assert(__is_referenceable(Union)); 798 static_assert(__is_referenceable(Derives)); 799 static_assert(__is_referenceable(Enum)); 800 static_assert(__is_referenceable(EnumClass)); 801 static_assert(__is_referenceable(int Empty::*)); 802 static_assert(__is_referenceable(int(Empty::*)())); 803 static_assert(__is_referenceable(AnIncompleteType)); 804 static_assert(__is_referenceable(struct AnIncompleteType)); 805 806 using function_type = void(int); 807 static_assert(__is_referenceable(function_type)); 808 809 static_assert(!__is_referenceable(void)); 810 } 811 812 template <typename T> void tmpl_func(T&) {} 813 814 template <typename T> struct type_wrapper { 815 typedef T type; 816 typedef T* ptrtype; 817 typedef T& reftype; 818 }; 819 820 void is_function() 821 { 822 static_assert(__is_function(type_wrapper<void(void)>::type)); 823 static_assert(__is_function(typeof(tmpl_func<int>))); 824 825 typedef void (*ptr_to_func_type)(void); 826 827 static_assert(!__is_function(void)); 828 static_assert(!__is_function(cvoid)); 829 static_assert(!__is_function(float)); 830 static_assert(!__is_function(double)); 831 static_assert(!__is_function(long double)); 832 static_assert(!__is_function(bool)); 833 static_assert(!__is_function(char)); 834 static_assert(!__is_function(signed char)); 835 static_assert(!__is_function(unsigned char)); 836 static_assert(!__is_function(wchar_t)); 837 static_assert(!__is_function(short)); 838 static_assert(!__is_function(unsigned short)); 839 static_assert(!__is_function(int)); 840 static_assert(!__is_function(unsigned int)); 841 static_assert(!__is_function(long)); 842 static_assert(!__is_function(unsigned long)); 843 static_assert(!__is_function(Union)); 844 static_assert(!__is_function(Derives)); 845 static_assert(!__is_function(ClassType)); 846 static_assert(!__is_function(Enum)); 847 static_assert(!__is_function(void*)); 848 static_assert(!__is_function(cvoid*)); 849 static_assert(!__is_function(void(*)())); 850 static_assert(!__is_function(ptr_to_func_type)); 851 static_assert(!__is_function(type_wrapper<void(void)>::ptrtype)); 852 static_assert(!__is_function(type_wrapper<void(void)>::reftype)); 853 } 854 855 void is_reference() 856 { 857 static_assert(__is_reference(int&)); 858 static_assert(__is_reference(const int&)); 859 static_assert(__is_reference(void *&)); 860 861 static_assert(!__is_reference(int)); 862 static_assert(!__is_reference(const int)); 863 static_assert(!__is_reference(void *)); 864 } 865 866 void is_lvalue_reference() 867 { 868 static_assert(__is_lvalue_reference(int&)); 869 static_assert(__is_lvalue_reference(void *&)); 870 static_assert(__is_lvalue_reference(const int&)); 871 static_assert(__is_lvalue_reference(void * const &)); 872 873 static_assert(!__is_lvalue_reference(int)); 874 static_assert(!__is_lvalue_reference(const int)); 875 static_assert(!__is_lvalue_reference(void *)); 876 } 877 878 #if __has_feature(cxx_rvalue_references) 879 880 void is_rvalue_reference() 881 { 882 static_assert(__is_rvalue_reference(const int&&)); 883 static_assert(__is_rvalue_reference(void * const &&)); 884 885 static_assert(!__is_rvalue_reference(int&)); 886 static_assert(!__is_rvalue_reference(void *&)); 887 static_assert(!__is_rvalue_reference(const int&)); 888 static_assert(!__is_rvalue_reference(void * const &)); 889 static_assert(!__is_rvalue_reference(int)); 890 static_assert(!__is_rvalue_reference(const int)); 891 static_assert(!__is_rvalue_reference(void *)); 892 } 893 894 #endif 895 896 void is_fundamental() 897 { 898 static_assert(__is_fundamental(float)); 899 static_assert(__is_fundamental(double)); 900 static_assert(__is_fundamental(long double)); 901 static_assert(__is_fundamental(bool)); 902 static_assert(__is_fundamental(char)); 903 static_assert(__is_fundamental(signed char)); 904 static_assert(__is_fundamental(unsigned char)); 905 //static_assert(__is_fundamental(char16_t)); 906 //static_assert(__is_fundamental(char32_t)); 907 static_assert(__is_fundamental(wchar_t)); 908 static_assert(__is_fundamental(short)); 909 static_assert(__is_fundamental(unsigned short)); 910 static_assert(__is_fundamental(int)); 911 static_assert(__is_fundamental(unsigned int)); 912 static_assert(__is_fundamental(long)); 913 static_assert(__is_fundamental(unsigned long)); 914 static_assert(__is_fundamental(void)); 915 static_assert(__is_fundamental(cvoid)); 916 static_assert(__is_fundamental(decltype(nullptr))); 917 918 static_assert(!__is_fundamental(Union)); 919 static_assert(!__is_fundamental(UnionAr)); 920 static_assert(!__is_fundamental(Derives)); 921 static_assert(!__is_fundamental(ClassType)); 922 static_assert(!__is_fundamental(Enum)); 923 static_assert(!__is_fundamental(IntArNB)); 924 } 925 926 void is_object() 927 { 928 static_assert(__is_object(int)); 929 static_assert(__is_object(int *)); 930 static_assert(__is_object(void *)); 931 static_assert(__is_object(Union)); 932 static_assert(__is_object(UnionAr)); 933 static_assert(__is_object(ClassType)); 934 static_assert(__is_object(Enum)); 935 936 static_assert(!__is_object(type_wrapper<void(void)>::type)); 937 static_assert(!__is_object(int&)); 938 static_assert(!__is_object(void)); 939 } 940 941 void is_scalar() 942 { 943 static_assert(__is_scalar(float)); 944 static_assert(__is_scalar(double)); 945 static_assert(__is_scalar(long double)); 946 static_assert(__is_scalar(bool)); 947 static_assert(__is_scalar(char)); 948 static_assert(__is_scalar(signed char)); 949 static_assert(__is_scalar(unsigned char)); 950 static_assert(__is_scalar(wchar_t)); 951 static_assert(__is_scalar(short)); 952 static_assert(__is_scalar(unsigned short)); 953 static_assert(__is_scalar(int)); 954 static_assert(__is_scalar(unsigned int)); 955 static_assert(__is_scalar(long)); 956 static_assert(__is_scalar(unsigned long)); 957 static_assert(__is_scalar(Enum)); 958 static_assert(__is_scalar(void*)); 959 static_assert(__is_scalar(cvoid*)); 960 961 static_assert(!__is_scalar(void)); 962 static_assert(!__is_scalar(cvoid)); 963 static_assert(!__is_scalar(Union)); 964 static_assert(!__is_scalar(UnionAr)); 965 static_assert(!__is_scalar(Derives)); 966 static_assert(!__is_scalar(ClassType)); 967 static_assert(!__is_scalar(IntArNB)); 968 } 969 970 struct StructWithMembers { 971 int member; 972 void method() {} 973 }; 974 975 void is_compound() 976 { 977 static_assert(__is_compound(void*)); 978 static_assert(__is_compound(cvoid*)); 979 static_assert(__is_compound(void (*)())); 980 static_assert(__is_compound(int StructWithMembers::*)); 981 static_assert(__is_compound(void (StructWithMembers::*)())); 982 static_assert(__is_compound(int&)); 983 static_assert(__is_compound(Union)); 984 static_assert(__is_compound(UnionAr)); 985 static_assert(__is_compound(Derives)); 986 static_assert(__is_compound(ClassType)); 987 static_assert(__is_compound(IntArNB)); 988 static_assert(__is_compound(Enum)); 989 990 static_assert(!__is_compound(float)); 991 static_assert(!__is_compound(double)); 992 static_assert(!__is_compound(long double)); 993 static_assert(!__is_compound(bool)); 994 static_assert(!__is_compound(char)); 995 static_assert(!__is_compound(signed char)); 996 static_assert(!__is_compound(unsigned char)); 997 static_assert(!__is_compound(wchar_t)); 998 static_assert(!__is_compound(short)); 999 static_assert(!__is_compound(unsigned short)); 1000 static_assert(!__is_compound(int)); 1001 static_assert(!__is_compound(unsigned int)); 1002 static_assert(!__is_compound(long)); 1003 static_assert(!__is_compound(unsigned long)); 1004 static_assert(!__is_compound(void)); 1005 static_assert(!__is_compound(cvoid)); 1006 } 1007 1008 void is_pointer() 1009 { 1010 StructWithMembers x; 1011 1012 static_assert(__is_pointer(void*)); 1013 static_assert(__is_pointer(cvoid*)); 1014 static_assert(__is_pointer(cvoid*)); 1015 static_assert(__is_pointer(char*)); 1016 static_assert(__is_pointer(int*)); 1017 static_assert(__is_pointer(int**)); 1018 static_assert(__is_pointer(ClassType*)); 1019 static_assert(__is_pointer(Derives*)); 1020 static_assert(__is_pointer(Enum*)); 1021 static_assert(__is_pointer(IntArNB*)); 1022 static_assert(__is_pointer(Union*)); 1023 static_assert(__is_pointer(UnionAr*)); 1024 static_assert(__is_pointer(StructWithMembers*)); 1025 static_assert(__is_pointer(void (*)())); 1026 1027 static_assert(!__is_pointer(void)); 1028 static_assert(!__is_pointer(cvoid)); 1029 static_assert(!__is_pointer(cvoid)); 1030 static_assert(!__is_pointer(char)); 1031 static_assert(!__is_pointer(int)); 1032 static_assert(!__is_pointer(int)); 1033 static_assert(!__is_pointer(ClassType)); 1034 static_assert(!__is_pointer(Derives)); 1035 static_assert(!__is_pointer(Enum)); 1036 static_assert(!__is_pointer(IntArNB)); 1037 static_assert(!__is_pointer(Union)); 1038 static_assert(!__is_pointer(UnionAr)); 1039 static_assert(!__is_pointer(StructWithMembers)); 1040 static_assert(!__is_pointer(int StructWithMembers::*)); 1041 static_assert(!__is_pointer(void (StructWithMembers::*) ())); 1042 } 1043 1044 void is_member_object_pointer() 1045 { 1046 StructWithMembers x; 1047 1048 static_assert(__is_member_object_pointer(int StructWithMembers::*)); 1049 1050 static_assert(!__is_member_object_pointer(void (StructWithMembers::*) ())); 1051 static_assert(!__is_member_object_pointer(void*)); 1052 static_assert(!__is_member_object_pointer(cvoid*)); 1053 static_assert(!__is_member_object_pointer(cvoid*)); 1054 static_assert(!__is_member_object_pointer(char*)); 1055 static_assert(!__is_member_object_pointer(int*)); 1056 static_assert(!__is_member_object_pointer(int**)); 1057 static_assert(!__is_member_object_pointer(ClassType*)); 1058 static_assert(!__is_member_object_pointer(Derives*)); 1059 static_assert(!__is_member_object_pointer(Enum*)); 1060 static_assert(!__is_member_object_pointer(IntArNB*)); 1061 static_assert(!__is_member_object_pointer(Union*)); 1062 static_assert(!__is_member_object_pointer(UnionAr*)); 1063 static_assert(!__is_member_object_pointer(StructWithMembers*)); 1064 static_assert(!__is_member_object_pointer(void)); 1065 static_assert(!__is_member_object_pointer(cvoid)); 1066 static_assert(!__is_member_object_pointer(cvoid)); 1067 static_assert(!__is_member_object_pointer(char)); 1068 static_assert(!__is_member_object_pointer(int)); 1069 static_assert(!__is_member_object_pointer(int)); 1070 static_assert(!__is_member_object_pointer(ClassType)); 1071 static_assert(!__is_member_object_pointer(Derives)); 1072 static_assert(!__is_member_object_pointer(Enum)); 1073 static_assert(!__is_member_object_pointer(IntArNB)); 1074 static_assert(!__is_member_object_pointer(Union)); 1075 static_assert(!__is_member_object_pointer(UnionAr)); 1076 static_assert(!__is_member_object_pointer(StructWithMembers)); 1077 static_assert(!__is_member_object_pointer(void (*)())); 1078 } 1079 1080 void is_member_function_pointer() 1081 { 1082 StructWithMembers x; 1083 1084 static_assert(__is_member_function_pointer(void (StructWithMembers::*) ())); 1085 1086 static_assert(!__is_member_function_pointer(int StructWithMembers::*)); 1087 static_assert(!__is_member_function_pointer(void*)); 1088 static_assert(!__is_member_function_pointer(cvoid*)); 1089 static_assert(!__is_member_function_pointer(cvoid*)); 1090 static_assert(!__is_member_function_pointer(char*)); 1091 static_assert(!__is_member_function_pointer(int*)); 1092 static_assert(!__is_member_function_pointer(int**)); 1093 static_assert(!__is_member_function_pointer(ClassType*)); 1094 static_assert(!__is_member_function_pointer(Derives*)); 1095 static_assert(!__is_member_function_pointer(Enum*)); 1096 static_assert(!__is_member_function_pointer(IntArNB*)); 1097 static_assert(!__is_member_function_pointer(Union*)); 1098 static_assert(!__is_member_function_pointer(UnionAr*)); 1099 static_assert(!__is_member_function_pointer(StructWithMembers*)); 1100 static_assert(!__is_member_function_pointer(void)); 1101 static_assert(!__is_member_function_pointer(cvoid)); 1102 static_assert(!__is_member_function_pointer(cvoid)); 1103 static_assert(!__is_member_function_pointer(char)); 1104 static_assert(!__is_member_function_pointer(int)); 1105 static_assert(!__is_member_function_pointer(int)); 1106 static_assert(!__is_member_function_pointer(ClassType)); 1107 static_assert(!__is_member_function_pointer(Derives)); 1108 static_assert(!__is_member_function_pointer(Enum)); 1109 static_assert(!__is_member_function_pointer(IntArNB)); 1110 static_assert(!__is_member_function_pointer(Union)); 1111 static_assert(!__is_member_function_pointer(UnionAr)); 1112 static_assert(!__is_member_function_pointer(StructWithMembers)); 1113 static_assert(!__is_member_function_pointer(void (*)())); 1114 } 1115 1116 void is_member_pointer() 1117 { 1118 StructWithMembers x; 1119 1120 static_assert(__is_member_pointer(int StructWithMembers::*)); 1121 static_assert(__is_member_pointer(void (StructWithMembers::*) ())); 1122 1123 static_assert(!__is_member_pointer(void*)); 1124 static_assert(!__is_member_pointer(cvoid*)); 1125 static_assert(!__is_member_pointer(cvoid*)); 1126 static_assert(!__is_member_pointer(char*)); 1127 static_assert(!__is_member_pointer(int*)); 1128 static_assert(!__is_member_pointer(int**)); 1129 static_assert(!__is_member_pointer(ClassType*)); 1130 static_assert(!__is_member_pointer(Derives*)); 1131 static_assert(!__is_member_pointer(Enum*)); 1132 static_assert(!__is_member_pointer(IntArNB*)); 1133 static_assert(!__is_member_pointer(Union*)); 1134 static_assert(!__is_member_pointer(UnionAr*)); 1135 static_assert(!__is_member_pointer(StructWithMembers*)); 1136 static_assert(!__is_member_pointer(void)); 1137 static_assert(!__is_member_pointer(cvoid)); 1138 static_assert(!__is_member_pointer(cvoid)); 1139 static_assert(!__is_member_pointer(char)); 1140 static_assert(!__is_member_pointer(int)); 1141 static_assert(!__is_member_pointer(int)); 1142 static_assert(!__is_member_pointer(ClassType)); 1143 static_assert(!__is_member_pointer(Derives)); 1144 static_assert(!__is_member_pointer(Enum)); 1145 static_assert(!__is_member_pointer(IntArNB)); 1146 static_assert(!__is_member_pointer(Union)); 1147 static_assert(!__is_member_pointer(UnionAr)); 1148 static_assert(!__is_member_pointer(StructWithMembers)); 1149 static_assert(!__is_member_pointer(void (*)())); 1150 } 1151 1152 void is_const() 1153 { 1154 static_assert(__is_const(cvoid)); 1155 static_assert(__is_const(const char)); 1156 static_assert(__is_const(const int)); 1157 static_assert(__is_const(const long)); 1158 static_assert(__is_const(const short)); 1159 static_assert(__is_const(const signed char)); 1160 static_assert(__is_const(const wchar_t)); 1161 static_assert(__is_const(const bool)); 1162 static_assert(__is_const(const float)); 1163 static_assert(__is_const(const double)); 1164 static_assert(__is_const(const long double)); 1165 static_assert(__is_const(const unsigned char)); 1166 static_assert(__is_const(const unsigned int)); 1167 static_assert(__is_const(const unsigned long long)); 1168 static_assert(__is_const(const unsigned long)); 1169 static_assert(__is_const(const unsigned short)); 1170 static_assert(__is_const(const void)); 1171 static_assert(__is_const(const ClassType)); 1172 static_assert(__is_const(const Derives)); 1173 static_assert(__is_const(const Enum)); 1174 static_assert(__is_const(const IntArNB)); 1175 static_assert(__is_const(const Union)); 1176 static_assert(__is_const(const UnionAr)); 1177 1178 static_assert(!__is_const(char)); 1179 static_assert(!__is_const(int)); 1180 static_assert(!__is_const(long)); 1181 static_assert(!__is_const(short)); 1182 static_assert(!__is_const(signed char)); 1183 static_assert(!__is_const(wchar_t)); 1184 static_assert(!__is_const(bool)); 1185 static_assert(!__is_const(float)); 1186 static_assert(!__is_const(double)); 1187 static_assert(!__is_const(long double)); 1188 static_assert(!__is_const(unsigned char)); 1189 static_assert(!__is_const(unsigned int)); 1190 static_assert(!__is_const(unsigned long long)); 1191 static_assert(!__is_const(unsigned long)); 1192 static_assert(!__is_const(unsigned short)); 1193 static_assert(!__is_const(void)); 1194 static_assert(!__is_const(ClassType)); 1195 static_assert(!__is_const(Derives)); 1196 static_assert(!__is_const(Enum)); 1197 static_assert(!__is_const(IntArNB)); 1198 static_assert(!__is_const(Union)); 1199 static_assert(!__is_const(UnionAr)); 1200 } 1201 1202 void is_volatile() 1203 { 1204 static_assert(__is_volatile(volatile char)); 1205 static_assert(__is_volatile(volatile int)); 1206 static_assert(__is_volatile(volatile long)); 1207 static_assert(__is_volatile(volatile short)); 1208 static_assert(__is_volatile(volatile signed char)); 1209 static_assert(__is_volatile(volatile wchar_t)); 1210 static_assert(__is_volatile(volatile bool)); 1211 static_assert(__is_volatile(volatile float)); 1212 static_assert(__is_volatile(volatile double)); 1213 static_assert(__is_volatile(volatile long double)); 1214 static_assert(__is_volatile(volatile unsigned char)); 1215 static_assert(__is_volatile(volatile unsigned int)); 1216 static_assert(__is_volatile(volatile unsigned long long)); 1217 static_assert(__is_volatile(volatile unsigned long)); 1218 static_assert(__is_volatile(volatile unsigned short)); 1219 static_assert(__is_volatile(volatile void)); 1220 static_assert(__is_volatile(volatile ClassType)); 1221 static_assert(__is_volatile(volatile Derives)); 1222 static_assert(__is_volatile(volatile Enum)); 1223 static_assert(__is_volatile(volatile IntArNB)); 1224 static_assert(__is_volatile(volatile Union)); 1225 static_assert(__is_volatile(volatile UnionAr)); 1226 1227 static_assert(!__is_volatile(char)); 1228 static_assert(!__is_volatile(int)); 1229 static_assert(!__is_volatile(long)); 1230 static_assert(!__is_volatile(short)); 1231 static_assert(!__is_volatile(signed char)); 1232 static_assert(!__is_volatile(wchar_t)); 1233 static_assert(!__is_volatile(bool)); 1234 static_assert(!__is_volatile(float)); 1235 static_assert(!__is_volatile(double)); 1236 static_assert(!__is_volatile(long double)); 1237 static_assert(!__is_volatile(unsigned char)); 1238 static_assert(!__is_volatile(unsigned int)); 1239 static_assert(!__is_volatile(unsigned long long)); 1240 static_assert(!__is_volatile(unsigned long)); 1241 static_assert(!__is_volatile(unsigned short)); 1242 static_assert(!__is_volatile(void)); 1243 static_assert(!__is_volatile(ClassType)); 1244 static_assert(!__is_volatile(Derives)); 1245 static_assert(!__is_volatile(Enum)); 1246 static_assert(!__is_volatile(IntArNB)); 1247 static_assert(!__is_volatile(Union)); 1248 static_assert(!__is_volatile(UnionAr)); 1249 } 1250 1251 struct TrivialStruct { 1252 int member; 1253 }; 1254 1255 struct NonTrivialStruct { 1256 int member; 1257 NonTrivialStruct() { 1258 member = 0; 1259 } 1260 }; 1261 1262 struct SuperNonTrivialStruct { 1263 SuperNonTrivialStruct() { } 1264 ~SuperNonTrivialStruct() { } 1265 }; 1266 1267 struct NonTCStruct { 1268 NonTCStruct(const NonTCStruct&) {} 1269 }; 1270 1271 struct AllDefaulted { 1272 AllDefaulted() = default; 1273 AllDefaulted(const AllDefaulted &) = default; 1274 AllDefaulted(AllDefaulted &&) = default; 1275 AllDefaulted &operator=(const AllDefaulted &) = default; 1276 AllDefaulted &operator=(AllDefaulted &&) = default; 1277 ~AllDefaulted() = default; 1278 }; 1279 1280 struct NoDefaultMoveAssignDueToUDCopyCtor { 1281 NoDefaultMoveAssignDueToUDCopyCtor(const NoDefaultMoveAssignDueToUDCopyCtor&); 1282 }; 1283 1284 struct NoDefaultMoveAssignDueToUDCopyAssign { 1285 NoDefaultMoveAssignDueToUDCopyAssign& operator=( 1286 const NoDefaultMoveAssignDueToUDCopyAssign&); 1287 }; 1288 1289 struct NoDefaultMoveAssignDueToDtor { 1290 ~NoDefaultMoveAssignDueToDtor(); 1291 }; 1292 1293 struct AllDeleted { 1294 AllDeleted() = delete; 1295 AllDeleted(const AllDeleted &) = delete; 1296 AllDeleted(AllDeleted &&) = delete; 1297 AllDeleted &operator=(const AllDeleted &) = delete; 1298 AllDeleted &operator=(AllDeleted &&) = delete; 1299 ~AllDeleted() = delete; 1300 }; 1301 1302 struct ExtDefaulted { 1303 ExtDefaulted(); 1304 ExtDefaulted(const ExtDefaulted &); 1305 ExtDefaulted(ExtDefaulted &&); 1306 ExtDefaulted &operator=(const ExtDefaulted &); 1307 ExtDefaulted &operator=(ExtDefaulted &&); 1308 ~ExtDefaulted(); 1309 }; 1310 1311 // Despite being defaulted, these functions are not trivial. 1312 ExtDefaulted::ExtDefaulted() = default; 1313 ExtDefaulted::ExtDefaulted(const ExtDefaulted &) = default; 1314 ExtDefaulted::ExtDefaulted(ExtDefaulted &&) = default; 1315 ExtDefaulted &ExtDefaulted::operator=(const ExtDefaulted &) = default; 1316 ExtDefaulted &ExtDefaulted::operator=(ExtDefaulted &&) = default; 1317 ExtDefaulted::~ExtDefaulted() = default; 1318 1319 void is_trivial2() 1320 { 1321 static_assert(__is_trivial(char)); 1322 static_assert(__is_trivial(int)); 1323 static_assert(__is_trivial(long)); 1324 static_assert(__is_trivial(short)); 1325 static_assert(__is_trivial(signed char)); 1326 static_assert(__is_trivial(wchar_t)); 1327 static_assert(__is_trivial(bool)); 1328 static_assert(__is_trivial(float)); 1329 static_assert(__is_trivial(double)); 1330 static_assert(__is_trivial(long double)); 1331 static_assert(__is_trivial(unsigned char)); 1332 static_assert(__is_trivial(unsigned int)); 1333 static_assert(__is_trivial(unsigned long long)); 1334 static_assert(__is_trivial(unsigned long)); 1335 static_assert(__is_trivial(unsigned short)); 1336 static_assert(__is_trivial(ClassType)); 1337 static_assert(__is_trivial(Derives)); 1338 static_assert(__is_trivial(Enum)); 1339 static_assert(__is_trivial(IntAr)); 1340 static_assert(__is_trivial(Union)); 1341 static_assert(__is_trivial(UnionAr)); 1342 static_assert(__is_trivial(TrivialStruct)); 1343 static_assert(__is_trivial(AllDefaulted)); 1344 static_assert(__is_trivial(AllDeleted)); 1345 1346 static_assert(!__is_trivial(void)); 1347 static_assert(!__is_trivial(NonTrivialStruct)); 1348 static_assert(!__is_trivial(SuperNonTrivialStruct)); 1349 static_assert(!__is_trivial(NonTCStruct)); 1350 static_assert(!__is_trivial(ExtDefaulted)); 1351 1352 static_assert(__is_trivial(ACompleteType)); 1353 static_assert(!__is_trivial(AnIncompleteType)); // expected-error {{incomplete type}} 1354 static_assert(!__is_trivial(AnIncompleteType[])); // expected-error {{incomplete type}} 1355 static_assert(!__is_trivial(AnIncompleteType[1])); // expected-error {{incomplete type}} 1356 static_assert(!__is_trivial(void)); 1357 static_assert(!__is_trivial(const volatile void)); 1358 } 1359 1360 void is_trivially_copyable2() 1361 { 1362 static_assert(__is_trivially_copyable(char)); 1363 static_assert(__is_trivially_copyable(int)); 1364 static_assert(__is_trivially_copyable(long)); 1365 static_assert(__is_trivially_copyable(short)); 1366 static_assert(__is_trivially_copyable(signed char)); 1367 static_assert(__is_trivially_copyable(wchar_t)); 1368 static_assert(__is_trivially_copyable(bool)); 1369 static_assert(__is_trivially_copyable(float)); 1370 static_assert(__is_trivially_copyable(double)); 1371 static_assert(__is_trivially_copyable(long double)); 1372 static_assert(__is_trivially_copyable(unsigned char)); 1373 static_assert(__is_trivially_copyable(unsigned int)); 1374 static_assert(__is_trivially_copyable(unsigned long long)); 1375 static_assert(__is_trivially_copyable(unsigned long)); 1376 static_assert(__is_trivially_copyable(unsigned short)); 1377 static_assert(__is_trivially_copyable(ClassType)); 1378 static_assert(__is_trivially_copyable(Derives)); 1379 static_assert(__is_trivially_copyable(Enum)); 1380 static_assert(__is_trivially_copyable(IntAr)); 1381 static_assert(__is_trivially_copyable(Union)); 1382 static_assert(__is_trivially_copyable(UnionAr)); 1383 static_assert(__is_trivially_copyable(TrivialStruct)); 1384 static_assert(__is_trivially_copyable(NonTrivialStruct)); 1385 static_assert(__is_trivially_copyable(AllDefaulted)); 1386 static_assert(__is_trivially_copyable(AllDeleted)); 1387 1388 static_assert(!__is_trivially_copyable(void)); 1389 static_assert(!__is_trivially_copyable(SuperNonTrivialStruct)); 1390 static_assert(!__is_trivially_copyable(NonTCStruct)); 1391 static_assert(!__is_trivially_copyable(ExtDefaulted)); 1392 1393 static_assert(__is_trivially_copyable(const int)); 1394 static_assert(__is_trivially_copyable(volatile int)); 1395 1396 static_assert(__is_trivially_copyable(ACompleteType)); 1397 static_assert(!__is_trivially_copyable(AnIncompleteType)); // expected-error {{incomplete type}} 1398 static_assert(!__is_trivially_copyable(AnIncompleteType[])); // expected-error {{incomplete type}} 1399 static_assert(!__is_trivially_copyable(AnIncompleteType[1])); // expected-error {{incomplete type}} 1400 static_assert(!__is_trivially_copyable(void)); 1401 static_assert(!__is_trivially_copyable(const volatile void)); 1402 } 1403 1404 struct CStruct { 1405 int one; 1406 int two; 1407 }; 1408 1409 struct CEmptyStruct {}; 1410 1411 struct CppEmptyStruct : CStruct {}; 1412 struct CppStructStandard : CEmptyStruct { 1413 int three; 1414 int four; 1415 }; 1416 struct CppStructNonStandardByBase : CStruct { 1417 int three; 1418 int four; 1419 }; 1420 struct CppStructNonStandardByVirt : CStruct { 1421 virtual void method() {} 1422 }; 1423 struct CppStructNonStandardByMemb : CStruct { 1424 CppStructNonStandardByVirt member; 1425 }; 1426 struct CppStructNonStandardByProt : CStruct { 1427 int five; 1428 protected: 1429 int six; 1430 }; 1431 struct CppStructNonStandardByVirtBase : virtual CStruct { 1432 }; 1433 struct CppStructNonStandardBySameBase : CEmptyStruct { 1434 CEmptyStruct member; 1435 }; 1436 struct CppStructNonStandardBy2ndVirtBase : CEmptyStruct { 1437 CEmptyStruct member; 1438 }; 1439 1440 void is_standard_layout() 1441 { 1442 typedef const int ConstInt; 1443 typedef ConstInt ConstIntAr[4]; 1444 typedef CppStructStandard CppStructStandardAr[4]; 1445 1446 static_assert(__is_standard_layout(int)); 1447 static_assert(__is_standard_layout(ConstInt)); 1448 static_assert(__is_standard_layout(ConstIntAr)); 1449 static_assert(__is_standard_layout(CStruct)); 1450 static_assert(__is_standard_layout(CppStructStandard)); 1451 static_assert(__is_standard_layout(CppStructStandardAr)); 1452 static_assert(__is_standard_layout(Vector)); 1453 static_assert(__is_standard_layout(VectorExt)); 1454 1455 typedef CppStructNonStandardByBase CppStructNonStandardByBaseAr[4]; 1456 1457 static_assert(!__is_standard_layout(CppStructNonStandardByVirt)); 1458 static_assert(!__is_standard_layout(CppStructNonStandardByMemb)); 1459 static_assert(!__is_standard_layout(CppStructNonStandardByProt)); 1460 static_assert(!__is_standard_layout(CppStructNonStandardByVirtBase)); 1461 static_assert(!__is_standard_layout(CppStructNonStandardByBase)); 1462 static_assert(!__is_standard_layout(CppStructNonStandardByBaseAr)); 1463 static_assert(!__is_standard_layout(CppStructNonStandardBySameBase)); 1464 static_assert(!__is_standard_layout(CppStructNonStandardBy2ndVirtBase)); 1465 1466 static_assert(__is_standard_layout(ACompleteType)); 1467 static_assert(!__is_standard_layout(AnIncompleteType)); // expected-error {{incomplete type}} 1468 static_assert(!__is_standard_layout(AnIncompleteType[])); // expected-error {{incomplete type}} 1469 static_assert(!__is_standard_layout(AnIncompleteType[1])); // expected-error {{incomplete type}} 1470 static_assert(!__is_standard_layout(void)); 1471 static_assert(!__is_standard_layout(const volatile void)); 1472 1473 struct HasAnonEmptyBitfield { int : 0; }; 1474 struct HasAnonBitfield { int : 4; }; 1475 struct DerivesFromBitfield : HasAnonBitfield {}; 1476 struct DerivesFromBitfieldWithBitfield : HasAnonBitfield { int : 5; }; 1477 struct DerivesFromBitfieldTwice : DerivesFromBitfield, HasAnonEmptyBitfield {}; 1478 1479 static_assert(__is_standard_layout(HasAnonEmptyBitfield)); 1480 static_assert(__is_standard_layout(HasAnonBitfield)); 1481 static_assert(__is_standard_layout(DerivesFromBitfield)); 1482 static_assert(!__is_standard_layout(DerivesFromBitfieldWithBitfield)); 1483 static_assert(!__is_standard_layout(DerivesFromBitfieldTwice)); 1484 1485 struct Empty {}; 1486 struct HasEmptyBase : Empty {}; 1487 struct HoldsEmptyBase { Empty e; }; 1488 struct HasRepeatedEmptyBase : Empty, HasEmptyBase {}; // expected-warning {{inaccessible}} 1489 struct HasEmptyBaseAsMember : Empty { Empty e; }; 1490 struct HasEmptyBaseAsSubobjectOfMember1 : Empty { HoldsEmptyBase e; }; 1491 struct HasEmptyBaseAsSubobjectOfMember2 : Empty { HasEmptyBase e; }; 1492 struct HasEmptyBaseAsSubobjectOfMember3 : Empty { HoldsEmptyBase e[2]; }; 1493 struct HasEmptyIndirectBaseAsMember : HasEmptyBase { Empty e; }; 1494 struct HasEmptyIndirectBaseAsSecondMember : HasEmptyBase { int n; Empty e; }; 1495 struct HasEmptyIndirectBaseAfterBitfield : HasEmptyBase { int : 4; Empty e; }; 1496 1497 static_assert(__is_standard_layout(Empty)); 1498 static_assert(__is_standard_layout(HasEmptyBase)); 1499 static_assert(!__is_standard_layout(HasRepeatedEmptyBase)); 1500 static_assert(!__is_standard_layout(HasEmptyBaseAsMember)); 1501 static_assert(!__is_standard_layout(HasEmptyBaseAsSubobjectOfMember1)); 1502 static_assert(__is_standard_layout(HasEmptyBaseAsSubobjectOfMember2)); // FIXME: standard bug? 1503 static_assert(!__is_standard_layout(HasEmptyBaseAsSubobjectOfMember3)); 1504 static_assert(!__is_standard_layout(HasEmptyIndirectBaseAsMember)); 1505 static_assert(__is_standard_layout(HasEmptyIndirectBaseAsSecondMember)); 1506 static_assert(!__is_standard_layout(HasEmptyIndirectBaseAfterBitfield)); // FIXME: standard bug? 1507 1508 struct StructWithEmptyFields { 1509 int n; 1510 HoldsEmptyBase e[3]; 1511 }; 1512 union UnionWithEmptyFields { 1513 int n; 1514 HoldsEmptyBase e[3]; 1515 }; 1516 struct HasEmptyIndirectBaseAsSecondStructMember : HasEmptyBase { 1517 StructWithEmptyFields u; 1518 }; 1519 struct HasEmptyIndirectBaseAsSecondUnionMember : HasEmptyBase { 1520 UnionWithEmptyFields u; 1521 }; 1522 1523 static_assert(__is_standard_layout(HasEmptyIndirectBaseAsSecondStructMember)); 1524 static_assert(!__is_standard_layout(HasEmptyIndirectBaseAsSecondUnionMember)); 1525 } 1526 1527 struct CStruct2 { 1528 int one; 1529 int two; 1530 }; 1531 1532 struct CEmptyStruct2 {}; 1533 1534 struct CppEmptyStruct2 : CStruct2 {}; 1535 struct CppStructStandard2 : CEmptyStruct2 { 1536 int three; 1537 int four; 1538 }; 1539 struct CppStructNonStandardByBase2 : CStruct2 { 1540 int three; 1541 int four; 1542 }; 1543 struct CppStructNonStandardByVirt2 : CStruct2 { 1544 virtual void method() {} 1545 }; 1546 struct CppStructNonStandardByMemb2 : CStruct2 { 1547 CppStructNonStandardByVirt member; 1548 }; 1549 struct CppStructNonStandardByProt2 : CStruct2 { 1550 int five; 1551 protected: 1552 int six; 1553 }; 1554 struct CppStructNonStandardByVirtBase2 : virtual CStruct2 { 1555 }; 1556 struct CppStructNonStandardBySameBase2 : CEmptyStruct2 { 1557 CEmptyStruct member; 1558 }; 1559 struct CppStructNonStandardBy2ndVirtBase2 : CEmptyStruct2 { 1560 CEmptyStruct member; 1561 }; 1562 1563 struct CStructWithQualifiers { 1564 const int one; 1565 volatile int two; 1566 }; 1567 1568 struct CStructNoUniqueAddress { 1569 int one; 1570 [[no_unique_address]] int two; 1571 }; 1572 1573 struct CStructNoUniqueAddress2 { 1574 int one; 1575 [[no_unique_address]] int two; 1576 }; 1577 1578 struct alignas(64) CStructAlignment { 1579 int one; 1580 int two; 1581 }; 1582 1583 struct CStructAlignedMembers { 1584 int one; 1585 alignas(16) int two; 1586 }; 1587 1588 enum EnumLayout : int {}; 1589 enum class EnumClassLayout {}; 1590 enum EnumForward : int; 1591 enum class EnumClassForward; 1592 1593 struct CStructIncomplete; // #CStructIncomplete 1594 1595 struct CStructNested { 1596 int a; 1597 CStruct s; 1598 int b; 1599 }; 1600 1601 struct CStructNested2 { 1602 int a2; 1603 CStruct s2; 1604 int b2; 1605 }; 1606 1607 struct CStructWithBitfelds { 1608 int a : 5; 1609 int : 0; 1610 }; 1611 1612 struct CStructWithBitfelds2 { 1613 int a : 5; 1614 int : 0; 1615 }; 1616 1617 struct CStructWithBitfelds3 { 1618 int : 0; 1619 int b : 5; 1620 }; 1621 1622 struct CStructWithBitfelds4 { 1623 EnumLayout a : 5; 1624 int : 0; 1625 }; 1626 1627 union UnionLayout { 1628 int a; 1629 double b; 1630 CStruct c; 1631 [[no_unique_address]] CEmptyStruct d; 1632 [[no_unique_address]] CEmptyStruct2 e; 1633 }; 1634 1635 union UnionLayout2 { 1636 CStruct c; 1637 int a; 1638 CEmptyStruct2 e; 1639 double b; 1640 [[no_unique_address]] CEmptyStruct d; 1641 }; 1642 1643 union UnionLayout3 { 1644 CStruct c; 1645 int a; 1646 double b; 1647 [[no_unique_address]] CEmptyStruct d; 1648 }; 1649 1650 union UnionNoOveralignedMembers { 1651 int a; 1652 double b; 1653 }; 1654 1655 union UnionWithOveralignedMembers { 1656 int a; 1657 alignas(16) double b; 1658 }; 1659 1660 struct StructWithAnonUnion { 1661 union { 1662 int a; 1663 double b; 1664 CStruct c; 1665 [[no_unique_address]] CEmptyStruct d; 1666 [[no_unique_address]] CEmptyStruct2 e; 1667 }; 1668 }; 1669 1670 struct StructWithAnonUnion2 { 1671 union { 1672 CStruct c; 1673 int a; 1674 CEmptyStruct2 e; 1675 double b; 1676 [[no_unique_address]] CEmptyStruct d; 1677 }; 1678 }; 1679 1680 struct StructWithAnonUnion3 { 1681 union { 1682 CStruct c; 1683 int a; 1684 CEmptyStruct2 e; 1685 double b; 1686 [[no_unique_address]] CEmptyStruct d; 1687 } u; 1688 }; 1689 1690 struct CStructWithArrayAtTheEnd { 1691 int a; 1692 int b[4]; 1693 }; 1694 1695 struct CStructWithFMA { 1696 int c; 1697 int d[]; 1698 }; 1699 1700 struct CStructWithFMA2 { 1701 int e; 1702 int f[]; 1703 }; 1704 1705 template<int N> 1706 struct UniqueEmpty {}; 1707 template<typename... Bases> 1708 struct D : Bases... {}; 1709 1710 void is_layout_compatible(int n) 1711 { 1712 static_assert(__is_layout_compatible(void, void)); 1713 static_assert(!__is_layout_compatible(void, int)); 1714 static_assert(__is_layout_compatible(void, const void)); 1715 static_assert(__is_layout_compatible(void, volatile void)); 1716 static_assert(__is_layout_compatible(const void, volatile void)); 1717 static_assert(__is_layout_compatible(int, int)); 1718 static_assert(__is_layout_compatible(int, const int)); 1719 static_assert(__is_layout_compatible(int, volatile int)); 1720 static_assert(__is_layout_compatible(const int, volatile int)); 1721 static_assert(__is_layout_compatible(int *, int * __restrict)); 1722 // Note: atomic qualification matters for layout compatibility. 1723 static_assert(!__is_layout_compatible(int, _Atomic int)); 1724 static_assert(__is_layout_compatible(_Atomic(int), _Atomic int)); 1725 static_assert(!__is_layout_compatible(int, unsigned int)); 1726 static_assert(!__is_layout_compatible(char, unsigned char)); 1727 static_assert(!__is_layout_compatible(char, signed char)); 1728 static_assert(!__is_layout_compatible(unsigned char, signed char)); 1729 static_assert(__is_layout_compatible(int[], int[])); 1730 static_assert(__is_layout_compatible(int[2], int[2])); 1731 static_assert(!__is_layout_compatible(int[n], int[2])); 1732 // expected-error@-1 {{variable length arrays are not supported in '__is_layout_compatible'}} 1733 static_assert(!__is_layout_compatible(int[n], int[n])); 1734 // expected-error@-1 {{variable length arrays are not supported in '__is_layout_compatible'}} 1735 // expected-error@-2 {{variable length arrays are not supported in '__is_layout_compatible'}} 1736 static_assert(__is_layout_compatible(int&, int&)); 1737 static_assert(!__is_layout_compatible(int&, char&)); 1738 static_assert(__is_layout_compatible(void(int), void(int))); 1739 static_assert(!__is_layout_compatible(void(int), void(char))); 1740 static_assert(__is_layout_compatible(void(&)(int), void(&)(int))); 1741 static_assert(!__is_layout_compatible(void(&)(int), void(&)(char))); 1742 static_assert(__is_layout_compatible(void(*)(int), void(*)(int))); 1743 static_assert(!__is_layout_compatible(void(*)(int), void(*)(char))); 1744 using function_type = void(); 1745 using function_type2 = void(char); 1746 static_assert(__is_layout_compatible(const function_type, const function_type)); 1747 // expected-warning@-1 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}} 1748 // expected-warning@-2 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}} 1749 static_assert(__is_layout_compatible(function_type, const function_type)); 1750 // expected-warning@-1 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}} 1751 static_assert(!__is_layout_compatible(const function_type, const function_type2)); 1752 // expected-warning@-1 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}} 1753 // expected-warning@-2 {{'const' qualifier on function type 'function_type2' (aka 'void (char)') has no effect}} 1754 static_assert(__is_layout_compatible(CStruct, CStruct2)); 1755 static_assert(__is_layout_compatible(CStruct, const CStruct2)); 1756 static_assert(__is_layout_compatible(CStruct, volatile CStruct2)); 1757 static_assert(__is_layout_compatible(const CStruct, volatile CStruct2)); 1758 static_assert(__is_layout_compatible(CEmptyStruct, CEmptyStruct2)); 1759 static_assert(__is_layout_compatible(CppEmptyStruct, CppEmptyStruct2)); 1760 static_assert(__is_layout_compatible(CppStructStandard, CppStructStandard2)); 1761 static_assert(!__is_layout_compatible(CppStructNonStandardByBase, CppStructNonStandardByBase2)); 1762 static_assert(!__is_layout_compatible(CppStructNonStandardByVirt, CppStructNonStandardByVirt2)); 1763 static_assert(!__is_layout_compatible(CppStructNonStandardByMemb, CppStructNonStandardByMemb2)); 1764 static_assert(!__is_layout_compatible(CppStructNonStandardByProt, CppStructNonStandardByProt2)); 1765 static_assert(!__is_layout_compatible(CppStructNonStandardByVirtBase, CppStructNonStandardByVirtBase2)); 1766 static_assert(!__is_layout_compatible(CppStructNonStandardBySameBase, CppStructNonStandardBySameBase2)); 1767 static_assert(!__is_layout_compatible(CppStructNonStandardBy2ndVirtBase, CppStructNonStandardBy2ndVirtBase2)); 1768 static_assert(__is_layout_compatible(CStruct, CStructWithQualifiers)); 1769 static_assert(__is_layout_compatible(CStruct, CStructNoUniqueAddress) != bool(__has_cpp_attribute(no_unique_address))); 1770 static_assert(__is_layout_compatible(CStructNoUniqueAddress, CStructNoUniqueAddress2) != bool(__has_cpp_attribute(no_unique_address))); 1771 static_assert(__is_layout_compatible(CStruct, CStructAlignment)); 1772 static_assert(!__is_layout_compatible(CStruct, CStructAlignedMembers)); 1773 static_assert(__is_layout_compatible(UnionNoOveralignedMembers, UnionWithOveralignedMembers)); 1774 static_assert(__is_layout_compatible(CStructWithBitfelds, CStructWithBitfelds)); 1775 static_assert(__is_layout_compatible(CStructWithBitfelds, CStructWithBitfelds2)); 1776 static_assert(!__is_layout_compatible(CStructWithBitfelds, CStructWithBitfelds3)); 1777 static_assert(!__is_layout_compatible(CStructWithBitfelds, CStructWithBitfelds4)); 1778 static_assert(__is_layout_compatible(int CStruct2::*, int CStruct2::*)); 1779 static_assert(!__is_layout_compatible(int CStruct2::*, char CStruct2::*)); 1780 static_assert(__is_layout_compatible(void(CStruct2::*)(int), void(CStruct2::*)(int))); 1781 static_assert(!__is_layout_compatible(void(CStruct2::*)(int), void(CStruct2::*)(char))); 1782 static_assert(__is_layout_compatible(CStructNested, CStructNested2)); 1783 static_assert(__is_layout_compatible(UnionLayout, UnionLayout)); 1784 static_assert(!__is_layout_compatible(UnionLayout, UnionLayout2)); 1785 static_assert(!__is_layout_compatible(UnionLayout, UnionLayout3)); 1786 static_assert(!__is_layout_compatible(StructWithAnonUnion, StructWithAnonUnion2)); 1787 static_assert(!__is_layout_compatible(StructWithAnonUnion, StructWithAnonUnion3)); 1788 static_assert(__is_layout_compatible(EnumLayout, EnumClassLayout)); 1789 static_assert(__is_layout_compatible(EnumForward, EnumForward)); 1790 static_assert(__is_layout_compatible(EnumForward, EnumClassForward)); 1791 static_assert(__is_layout_compatible(CStructIncomplete, CStructIncomplete)); 1792 // expected-error@-1 {{incomplete type 'CStructIncomplete' where a complete type is required}} 1793 // expected-note@#CStructIncomplete {{forward declaration of 'CStructIncomplete'}} 1794 // expected-error@-3 {{incomplete type 'CStructIncomplete' where a complete type is required}} 1795 // expected-note@#CStructIncomplete {{forward declaration of 'CStructIncomplete'}} 1796 static_assert(!__is_layout_compatible(CStruct, CStructIncomplete)); 1797 // expected-error@-1 {{incomplete type 'CStructIncomplete' where a complete type is required}} 1798 // expected-note@#CStructIncomplete {{forward declaration of 'CStructIncomplete'}} 1799 static_assert(__is_layout_compatible(CStructIncomplete[2], CStructIncomplete[2])); 1800 // expected-error@-1 {{incomplete type 'CStructIncomplete[2]' where a complete type is required}} 1801 // expected-note@#CStructIncomplete {{forward declaration of 'CStructIncomplete'}} 1802 // expected-error@-3 {{incomplete type 'CStructIncomplete[2]' where a complete type is required}} 1803 // expected-note@#CStructIncomplete {{forward declaration of 'CStructIncomplete'}} 1804 static_assert(__is_layout_compatible(CStructIncomplete[], CStructIncomplete[])); 1805 static_assert(!__is_layout_compatible(CStructWithArrayAtTheEnd, CStructWithFMA)); 1806 static_assert(__is_layout_compatible(CStructWithFMA, CStructWithFMA)); 1807 static_assert(__is_layout_compatible(CStructWithFMA, CStructWithFMA2)); 1808 // Layout compatibility rules for enums might be relaxed in the future. See https://github.com/cplusplus/CWG/issues/39#issuecomment-1184791364 1809 static_assert(!__is_layout_compatible(EnumLayout, int)); 1810 static_assert(!__is_layout_compatible(EnumClassLayout, int)); 1811 static_assert(!__is_layout_compatible(EnumForward, int)); 1812 static_assert(!__is_layout_compatible(EnumClassForward, int)); 1813 static_assert(__is_layout_compatible(CStruct, D<CStruct>)); 1814 static_assert(__is_layout_compatible(CStruct, D<UniqueEmpty<0>, CStruct>)); 1815 static_assert(__is_layout_compatible(CStruct, D<UniqueEmpty<0>, D<UniqueEmpty<1>, CStruct>, D<UniqueEmpty<2>>>)); 1816 static_assert(__is_layout_compatible(CStruct, D<CStructWithQualifiers>)); 1817 static_assert(__is_layout_compatible(CStruct, D<UniqueEmpty<0>, CStructWithQualifiers>)); 1818 static_assert(__is_layout_compatible(CStructWithQualifiers, D<UniqueEmpty<0>, D<UniqueEmpty<1>, CStruct>, D<UniqueEmpty<2>>>)); 1819 } 1820 1821 namespace IPIBO { 1822 struct Base {}; 1823 struct Base2 {}; 1824 struct Base3 : Base {}; 1825 struct Base3Virtual : virtual Base {}; 1826 struct Derived : Base {}; 1827 struct DerivedIndirect : Base3 {}; 1828 struct DerivedMultiple : Base, Base2 {}; 1829 struct DerivedAmbiguous : Base, Base3 {}; 1830 /* expected-warning@-1 {{direct base 'Base' is inaccessible due to ambiguity: 1831 struct IPIBO::DerivedAmbiguous -> Base 1832 struct IPIBO::DerivedAmbiguous -> Base3 -> Base}} */ 1833 struct DerivedPrivate : private Base {}; 1834 struct DerivedVirtual : virtual Base {}; 1835 1836 union Union {}; 1837 union UnionIncomplete; 1838 struct StructIncomplete; // #StructIncomplete 1839 1840 void is_pointer_interconvertible_base_of(int n) 1841 { 1842 static_assert(__is_pointer_interconvertible_base_of(Base, Derived)); 1843 static_assert(!__is_pointer_interconvertible_base_of(Base2, Derived)); 1844 static_assert(__is_pointer_interconvertible_base_of(Base, DerivedIndirect)); 1845 static_assert(__is_pointer_interconvertible_base_of(Base, DerivedMultiple)); 1846 static_assert(__is_pointer_interconvertible_base_of(Base2, DerivedMultiple)); 1847 static_assert(!__is_pointer_interconvertible_base_of(Base3, DerivedMultiple)); 1848 static_assert(!__is_pointer_interconvertible_base_of(Base, DerivedAmbiguous)); 1849 static_assert(__is_pointer_interconvertible_base_of(Base, DerivedPrivate)); 1850 static_assert(!__is_pointer_interconvertible_base_of(Base, DerivedVirtual)); 1851 static_assert(!__is_pointer_interconvertible_base_of(Union, Union)); 1852 static_assert(!__is_pointer_interconvertible_base_of(UnionIncomplete, UnionIncomplete)); 1853 static_assert(__is_pointer_interconvertible_base_of(StructIncomplete, StructIncomplete)); 1854 static_assert(__is_pointer_interconvertible_base_of(StructIncomplete, const StructIncomplete)); 1855 static_assert(__is_pointer_interconvertible_base_of(StructIncomplete, volatile StructIncomplete)); 1856 static_assert(__is_pointer_interconvertible_base_of(const StructIncomplete, volatile StructIncomplete)); 1857 static_assert(!__is_pointer_interconvertible_base_of(StructIncomplete, Derived)); 1858 static_assert(!__is_pointer_interconvertible_base_of(Base, StructIncomplete)); 1859 // expected-error@-1 {{incomplete type 'StructIncomplete' where a complete type is required}} 1860 // expected-note@#StructIncomplete {{forward declaration of 'IPIBO::StructIncomplete'}} 1861 static_assert(!__is_pointer_interconvertible_base_of(CStruct2, CppStructNonStandardByBase2)); 1862 static_assert(!__is_pointer_interconvertible_base_of(void, void)); 1863 static_assert(!__is_pointer_interconvertible_base_of(void, int)); 1864 static_assert(!__is_pointer_interconvertible_base_of(void, const void)); 1865 static_assert(!__is_pointer_interconvertible_base_of(void, volatile void)); 1866 static_assert(!__is_pointer_interconvertible_base_of(const void, volatile void)); 1867 static_assert(!__is_pointer_interconvertible_base_of(int, int)); 1868 static_assert(!__is_pointer_interconvertible_base_of(int, const int)); 1869 static_assert(!__is_pointer_interconvertible_base_of(int, volatile int)); 1870 static_assert(!__is_pointer_interconvertible_base_of(const int, volatile int)); 1871 static_assert(!__is_pointer_interconvertible_base_of(int *, int * __restrict)); 1872 static_assert(!__is_pointer_interconvertible_base_of(int, _Atomic int)); 1873 static_assert(!__is_pointer_interconvertible_base_of(_Atomic(int), _Atomic int)); 1874 static_assert(!__is_pointer_interconvertible_base_of(int, unsigned int)); 1875 static_assert(!__is_pointer_interconvertible_base_of(char, unsigned char)); 1876 static_assert(!__is_pointer_interconvertible_base_of(char, signed char)); 1877 static_assert(!__is_pointer_interconvertible_base_of(unsigned char, signed char)); 1878 using function_type = void(); 1879 using function_type2 = void(char); 1880 static_assert(!__is_pointer_interconvertible_base_of(const function_type, const function_type)); 1881 // expected-warning@-1 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}} 1882 // expected-warning@-2 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}} 1883 static_assert(!__is_pointer_interconvertible_base_of(function_type, const function_type)); 1884 // expected-warning@-1 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}} 1885 static_assert(!__is_pointer_interconvertible_base_of(const function_type, const function_type2)); 1886 // expected-warning@-1 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}} 1887 // expected-warning@-2 {{'const' qualifier on function type 'function_type2' (aka 'void (char)') has no effect}} 1888 static_assert(!__is_pointer_interconvertible_base_of(int CStruct2::*, int CStruct2::*)); 1889 static_assert(!__is_pointer_interconvertible_base_of(int CStruct2::*, char CStruct2::*)); 1890 static_assert(!__is_pointer_interconvertible_base_of(void(CStruct2::*)(int), void(CStruct2::*)(int))); 1891 static_assert(!__is_pointer_interconvertible_base_of(void(CStruct2::*)(int), void(CStruct2::*)(char))); 1892 static_assert(!__is_pointer_interconvertible_base_of(int[], int[])); 1893 static_assert(!__is_pointer_interconvertible_base_of(int[], double[])); 1894 static_assert(!__is_pointer_interconvertible_base_of(int[2], int[2])); 1895 static_assert(!__is_pointer_interconvertible_base_of(int[n], int[2])); 1896 // expected-error@-1 {{variable length arrays are not supported in '__is_pointer_interconvertible_base_of'}} 1897 static_assert(!__is_pointer_interconvertible_base_of(int[n], int[n])); 1898 // expected-error@-1 {{variable length arrays are not supported in '__is_pointer_interconvertible_base_of'}} 1899 // expected-error@-2 {{variable length arrays are not supported in '__is_pointer_interconvertible_base_of'}} 1900 static_assert(!__is_pointer_interconvertible_base_of(int&, int&)); 1901 static_assert(!__is_pointer_interconvertible_base_of(int&, char&)); 1902 static_assert(!__is_pointer_interconvertible_base_of(void(int), void(int))); 1903 static_assert(!__is_pointer_interconvertible_base_of(void(int), void(char))); 1904 static_assert(!__is_pointer_interconvertible_base_of(void(&)(int), void(&)(int))); 1905 static_assert(!__is_pointer_interconvertible_base_of(void(&)(int), void(&)(char))); 1906 static_assert(!__is_pointer_interconvertible_base_of(void(*)(int), void(*)(int))); 1907 static_assert(!__is_pointer_interconvertible_base_of(void(*)(int), void(*)(char))); 1908 } 1909 } 1910 1911 struct NoEligibleTrivialContructor { 1912 NoEligibleTrivialContructor() {}; 1913 NoEligibleTrivialContructor(const NoEligibleTrivialContructor&) {} 1914 NoEligibleTrivialContructor(NoEligibleTrivialContructor&&) {} 1915 }; 1916 1917 struct OnlyDefaultConstructorIsTrivial { 1918 OnlyDefaultConstructorIsTrivial() = default; 1919 OnlyDefaultConstructorIsTrivial(const OnlyDefaultConstructorIsTrivial&) {} 1920 OnlyDefaultConstructorIsTrivial(OnlyDefaultConstructorIsTrivial&&) {} 1921 }; 1922 1923 struct AllContstructorsAreTrivial { 1924 AllContstructorsAreTrivial() = default; 1925 AllContstructorsAreTrivial(const AllContstructorsAreTrivial&) = default; 1926 AllContstructorsAreTrivial(AllContstructorsAreTrivial&&) = default; 1927 }; 1928 1929 struct InheritedNoEligibleTrivialConstructor : NoEligibleTrivialContructor { 1930 using NoEligibleTrivialContructor::NoEligibleTrivialContructor; 1931 }; 1932 1933 struct InheritedOnlyDefaultConstructorIsTrivial : OnlyDefaultConstructorIsTrivial { 1934 using OnlyDefaultConstructorIsTrivial::OnlyDefaultConstructorIsTrivial; 1935 }; 1936 1937 struct InheritedAllContstructorsAreTrivial : AllContstructorsAreTrivial { 1938 using AllContstructorsAreTrivial::AllContstructorsAreTrivial; 1939 }; 1940 1941 struct UserDeclaredDestructor { 1942 ~UserDeclaredDestructor() = default; 1943 }; 1944 1945 struct UserProvidedDestructor { 1946 ~UserProvidedDestructor() {} 1947 }; 1948 1949 struct UserDeletedDestructorInAggregate { 1950 ~UserDeletedDestructorInAggregate() = delete; 1951 }; 1952 1953 struct UserDeletedDestructorInNonAggregate { 1954 virtual void NonAggregate(); 1955 ~UserDeletedDestructorInNonAggregate() = delete; 1956 }; 1957 1958 struct DeletedDestructorViaBaseInAggregate : UserDeletedDestructorInAggregate {}; 1959 struct DeletedDestructorViaBaseInNonAggregate : UserDeletedDestructorInNonAggregate {}; 1960 1961 #if __cplusplus >= 202002L 1962 template<bool B> 1963 struct ConstrainedUserDeclaredDefaultConstructor{ 1964 ConstrainedUserDeclaredDefaultConstructor() requires B = default; 1965 ConstrainedUserDeclaredDefaultConstructor(const ConstrainedUserDeclaredDefaultConstructor&) {} 1966 }; 1967 1968 template<bool B> 1969 struct ConstrainedUserProvidedDestructor { 1970 ~ConstrainedUserProvidedDestructor() = default; 1971 ~ConstrainedUserProvidedDestructor() requires B {} 1972 }; 1973 #endif 1974 1975 struct StructWithFAM { 1976 int a[]; 1977 }; 1978 1979 struct StructWithZeroSizedArray { 1980 int a[0]; 1981 }; 1982 1983 typedef float float4 __attribute__((ext_vector_type(4))); 1984 typedef int *align_value_int __attribute__((align_value(16))); 1985 1986 struct [[clang::enforce_read_only_placement]] EnforceReadOnlyPlacement {}; 1987 struct [[clang::type_visibility("hidden")]] TypeVisibility {}; 1988 1989 void is_implicit_lifetime(int n) { 1990 static_assert(__builtin_is_implicit_lifetime(decltype(nullptr))); 1991 static_assert(!__builtin_is_implicit_lifetime(void)); 1992 static_assert(!__builtin_is_implicit_lifetime(const void)); 1993 static_assert(!__builtin_is_implicit_lifetime(volatile void)); 1994 static_assert(__builtin_is_implicit_lifetime(int)); 1995 static_assert(!__builtin_is_implicit_lifetime(int&)); 1996 static_assert(!__builtin_is_implicit_lifetime(int&&)); 1997 static_assert(__builtin_is_implicit_lifetime(float)); 1998 static_assert(__builtin_is_implicit_lifetime(double)); 1999 static_assert(__builtin_is_implicit_lifetime(long double)); 2000 static_assert(__builtin_is_implicit_lifetime(int*)); 2001 static_assert(__builtin_is_implicit_lifetime(int[])); 2002 static_assert(__builtin_is_implicit_lifetime(int[5])); 2003 static_assert(__builtin_is_implicit_lifetime(int[n])); 2004 // expected-error@-1 {{variable length arrays are not supported in '__builtin_is_implicit_lifetime'}} 2005 static_assert(__builtin_is_implicit_lifetime(Enum)); 2006 static_assert(__builtin_is_implicit_lifetime(EnumClass)); 2007 static_assert(!__builtin_is_implicit_lifetime(void())); 2008 static_assert(!__builtin_is_implicit_lifetime(void() &)); 2009 static_assert(!__builtin_is_implicit_lifetime(void() const)); 2010 static_assert(!__builtin_is_implicit_lifetime(void(&)())); 2011 static_assert(__builtin_is_implicit_lifetime(void(*)())); 2012 static_assert(__builtin_is_implicit_lifetime(decltype(nullptr))); 2013 static_assert(__builtin_is_implicit_lifetime(int UserDeclaredDestructor::*)); 2014 static_assert(__builtin_is_implicit_lifetime(int (UserDeclaredDestructor::*)())); 2015 static_assert(__builtin_is_implicit_lifetime(int (UserDeclaredDestructor::*)() const)); 2016 static_assert(__builtin_is_implicit_lifetime(int (UserDeclaredDestructor::*)() &)); 2017 static_assert(__builtin_is_implicit_lifetime(int (UserDeclaredDestructor::*)() &&)); 2018 static_assert(!__builtin_is_implicit_lifetime(IncompleteStruct)); 2019 // expected-error@-1 {{incomplete type 'IncompleteStruct' used in type trait expression}} 2020 static_assert(__builtin_is_implicit_lifetime(IncompleteStruct[])); 2021 static_assert(__builtin_is_implicit_lifetime(IncompleteStruct[5])); 2022 static_assert(__builtin_is_implicit_lifetime(UserDeclaredDestructor)); 2023 static_assert(__builtin_is_implicit_lifetime(const UserDeclaredDestructor)); 2024 static_assert(__builtin_is_implicit_lifetime(volatile UserDeclaredDestructor)); 2025 static_assert(!__builtin_is_implicit_lifetime(UserProvidedDestructor)); 2026 static_assert(!__builtin_is_implicit_lifetime(NoEligibleTrivialContructor)); 2027 static_assert(__builtin_is_implicit_lifetime(OnlyDefaultConstructorIsTrivial)); 2028 static_assert(__builtin_is_implicit_lifetime(AllContstructorsAreTrivial)); 2029 static_assert(!__builtin_is_implicit_lifetime(InheritedNoEligibleTrivialConstructor)); 2030 static_assert(__builtin_is_implicit_lifetime(InheritedOnlyDefaultConstructorIsTrivial)); 2031 static_assert(__builtin_is_implicit_lifetime(InheritedAllContstructorsAreTrivial)); 2032 static_assert(__builtin_is_implicit_lifetime(UserDeletedDestructorInAggregate)); 2033 static_assert(!__builtin_is_implicit_lifetime(UserDeletedDestructorInNonAggregate)); 2034 static_assert(__builtin_is_implicit_lifetime(DeletedDestructorViaBaseInAggregate) == __cplusplus >= 201703L); 2035 static_assert(!__builtin_is_implicit_lifetime(DeletedDestructorViaBaseInNonAggregate)); 2036 #if __cplusplus >= 202002L 2037 static_assert(__builtin_is_implicit_lifetime(ConstrainedUserDeclaredDefaultConstructor<true>)); 2038 static_assert(!__builtin_is_implicit_lifetime(ConstrainedUserDeclaredDefaultConstructor<false>)); 2039 static_assert(!__builtin_is_implicit_lifetime(ConstrainedUserProvidedDestructor<true>)); 2040 static_assert(__builtin_is_implicit_lifetime(ConstrainedUserProvidedDestructor<false>)); 2041 #endif 2042 2043 static_assert(__builtin_is_implicit_lifetime(__int128)); 2044 static_assert(__builtin_is_implicit_lifetime(_BitInt(8))); 2045 static_assert(__builtin_is_implicit_lifetime(_BitInt(128))); 2046 static_assert(__builtin_is_implicit_lifetime(int[0])); 2047 static_assert(__builtin_is_implicit_lifetime(StructWithFAM)); 2048 static_assert(__builtin_is_implicit_lifetime(StructWithZeroSizedArray)); 2049 static_assert(__builtin_is_implicit_lifetime(__fp16)); 2050 static_assert(__builtin_is_implicit_lifetime(__bf16)); 2051 static_assert(__builtin_is_implicit_lifetime(_Complex double)); 2052 static_assert(__builtin_is_implicit_lifetime(float4)); 2053 static_assert(__builtin_is_implicit_lifetime(align_value_int)); 2054 static_assert(__builtin_is_implicit_lifetime(int[[clang::annotate_type("category2")]] *)); 2055 static_assert(__builtin_is_implicit_lifetime(EnforceReadOnlyPlacement)); 2056 static_assert(__builtin_is_implicit_lifetime(int __attribute__((noderef)) *)); 2057 static_assert(__builtin_is_implicit_lifetime(TypeVisibility)); 2058 static_assert(__builtin_is_implicit_lifetime(int * _Nonnull)); 2059 static_assert(__builtin_is_implicit_lifetime(int * _Null_unspecified)); 2060 static_assert(__builtin_is_implicit_lifetime(int * _Nullable)); 2061 static_assert(!__builtin_is_implicit_lifetime(_Atomic int)); 2062 // expected-error@-1 {{atomic types are not supported in '__builtin_is_implicit_lifetime'}} 2063 static_assert(__builtin_is_implicit_lifetime(int * __restrict)); 2064 } 2065 2066 void is_signed() 2067 { 2068 //static_assert(__is_signed(char)); 2069 static_assert(__is_signed(int)); 2070 static_assert(__is_signed(long)); 2071 static_assert(__is_signed(short)); 2072 static_assert(__is_signed(signed char)); 2073 static_assert(__is_signed(wchar_t)); 2074 static_assert(__is_signed(float)); 2075 static_assert(__is_signed(double)); 2076 static_assert(__is_signed(long double)); 2077 2078 static_assert(!__is_signed(bool)); 2079 static_assert(!__is_signed(cvoid)); 2080 static_assert(!__is_signed(unsigned char)); 2081 static_assert(!__is_signed(unsigned int)); 2082 static_assert(!__is_signed(unsigned long long)); 2083 static_assert(!__is_signed(unsigned long)); 2084 static_assert(!__is_signed(unsigned short)); 2085 static_assert(!__is_signed(void)); 2086 static_assert(!__is_signed(ClassType)); 2087 static_assert(!__is_signed(Derives)); 2088 static_assert(!__is_signed(Enum)); 2089 static_assert(!__is_signed(SignedEnum)); 2090 static_assert(!__is_signed(IntArNB)); 2091 static_assert(!__is_signed(Union)); 2092 static_assert(!__is_signed(UnionAr)); 2093 static_assert(!__is_signed(UnsignedEnum)); 2094 } 2095 2096 void is_unsigned() 2097 { 2098 static_assert(__is_unsigned(bool)); 2099 static_assert(__is_unsigned(unsigned char)); 2100 static_assert(__is_unsigned(unsigned short)); 2101 static_assert(__is_unsigned(unsigned int)); 2102 static_assert(__is_unsigned(unsigned long)); 2103 static_assert(__is_unsigned(unsigned long long)); 2104 2105 static_assert(!__is_unsigned(void)); 2106 static_assert(!__is_unsigned(cvoid)); 2107 static_assert(!__is_unsigned(float)); 2108 static_assert(!__is_unsigned(double)); 2109 static_assert(!__is_unsigned(long double)); 2110 static_assert(!__is_unsigned(char)); 2111 static_assert(!__is_unsigned(signed char)); 2112 static_assert(!__is_unsigned(wchar_t)); 2113 static_assert(!__is_unsigned(short)); 2114 static_assert(!__is_unsigned(int)); 2115 static_assert(!__is_unsigned(long)); 2116 static_assert(!__is_unsigned(Union)); 2117 static_assert(!__is_unsigned(UnionAr)); 2118 static_assert(!__is_unsigned(Derives)); 2119 static_assert(!__is_unsigned(ClassType)); 2120 static_assert(!__is_unsigned(IntArNB)); 2121 static_assert(!__is_unsigned(Enum)); 2122 static_assert(!__is_unsigned(UnsignedEnum)); 2123 static_assert(!__is_unsigned(SignedEnum)); 2124 } 2125 2126 typedef Int& IntRef; 2127 typedef const IntAr ConstIntAr; 2128 typedef ConstIntAr ConstIntArAr[4]; 2129 2130 struct HasCopy { 2131 HasCopy(HasCopy& cp); 2132 }; 2133 2134 struct HasMove { 2135 HasMove(HasMove&& cp); 2136 }; 2137 2138 struct HasTemplateCons { 2139 HasVirt Annoying; 2140 2141 template <typename T> 2142 HasTemplateCons(const T&); 2143 }; 2144 2145 void has_trivial_default_constructor() { 2146 static_assert(__has_trivial_constructor(Int)); 2147 static_assert(__has_trivial_constructor(IntAr)); 2148 static_assert(__has_trivial_constructor(Union)); 2149 static_assert(__has_trivial_constructor(UnionAr)); 2150 static_assert(__has_trivial_constructor(POD)); 2151 static_assert(__has_trivial_constructor(Derives)); 2152 static_assert(__has_trivial_constructor(DerivesAr)); 2153 static_assert(__has_trivial_constructor(ConstIntAr)); 2154 static_assert(__has_trivial_constructor(ConstIntArAr)); 2155 static_assert(__has_trivial_constructor(HasDest)); 2156 static_assert(__has_trivial_constructor(HasPriv)); 2157 static_assert(__has_trivial_constructor(HasCopyAssign)); 2158 static_assert(__has_trivial_constructor(HasMoveAssign)); 2159 static_assert(__has_trivial_constructor(const Int)); 2160 static_assert(__has_trivial_constructor(AllDefaulted)); 2161 static_assert(__has_trivial_constructor(AllDeleted)); 2162 static_assert(__has_trivial_constructor(ACompleteType[])); 2163 2164 static_assert(!__has_trivial_constructor(AnIncompleteType[])); // expected-error {{incomplete type}} 2165 static_assert(!__has_trivial_constructor(HasCons)); 2166 static_assert(!__has_trivial_constructor(HasRef)); 2167 static_assert(!__has_trivial_constructor(HasCopy)); 2168 static_assert(!__has_trivial_constructor(IntRef)); 2169 static_assert(!__has_trivial_constructor(VirtAr)); 2170 static_assert(!__has_trivial_constructor(void)); 2171 static_assert(!__has_trivial_constructor(cvoid)); 2172 static_assert(!__has_trivial_constructor(HasTemplateCons)); 2173 static_assert(!__has_trivial_constructor(AllPrivate)); 2174 static_assert(!__has_trivial_constructor(ExtDefaulted)); 2175 } 2176 2177 void has_trivial_move_constructor() { 2178 // n3376 12.8 [class.copy]/12 2179 // A copy/move constructor for class X is trivial if it is not 2180 // user-provided, its declared parameter type is the same as 2181 // if it had been implicitly declared, and if 2182 // - class X has no virtual functions (10.3) and no virtual 2183 // base classes (10.1), and 2184 // - the constructor selected to copy/move each direct base 2185 // class subobject is trivial, and 2186 // - for each non-static data member of X that is of class 2187 // type (or array thereof), the constructor selected 2188 // to copy/move that member is trivial; 2189 // otherwise the copy/move constructor is non-trivial. 2190 static_assert(__has_trivial_move_constructor(POD)); 2191 static_assert(__has_trivial_move_constructor(Union)); 2192 static_assert(__has_trivial_move_constructor(HasCons)); 2193 static_assert(__has_trivial_move_constructor(HasStaticMemberMoveCtor)); 2194 static_assert(__has_trivial_move_constructor(AllDeleted)); 2195 static_assert(__has_trivial_move_constructor(ACompleteType[])); 2196 2197 static_assert(!__has_trivial_move_constructor(AnIncompleteType[])); // expected-error {{incomplete type}} 2198 static_assert(!__has_trivial_move_constructor(HasVirt)); 2199 static_assert(!__has_trivial_move_constructor(DerivesVirt)); 2200 static_assert(!__has_trivial_move_constructor(HasMoveCtor)); 2201 static_assert(!__has_trivial_move_constructor(DerivesHasMoveCtor)); 2202 static_assert(!__has_trivial_move_constructor(HasMemberMoveCtor)); 2203 } 2204 2205 void has_trivial_copy_constructor() { 2206 static_assert(__has_trivial_copy(Int)); 2207 static_assert(__has_trivial_copy(IntAr)); 2208 static_assert(__has_trivial_copy(Union)); 2209 static_assert(__has_trivial_copy(UnionAr)); 2210 static_assert(__has_trivial_copy(POD)); 2211 static_assert(__has_trivial_copy(Derives)); 2212 static_assert(__has_trivial_copy(ConstIntAr)); 2213 static_assert(__has_trivial_copy(ConstIntArAr)); 2214 static_assert(__has_trivial_copy(HasDest)); 2215 static_assert(__has_trivial_copy(HasPriv)); 2216 static_assert(__has_trivial_copy(HasCons)); 2217 static_assert(__has_trivial_copy(HasRef)); 2218 static_assert(__has_trivial_copy(HasMove)); 2219 static_assert(__has_trivial_copy(IntRef)); 2220 static_assert(__has_trivial_copy(HasCopyAssign)); 2221 static_assert(__has_trivial_copy(HasMoveAssign)); 2222 static_assert(__has_trivial_copy(const Int)); 2223 static_assert(__has_trivial_copy(AllDefaulted)); 2224 static_assert(__has_trivial_copy(AllDeleted)); 2225 static_assert(__has_trivial_copy(DerivesAr)); 2226 static_assert(__has_trivial_copy(DerivesHasRef)); 2227 static_assert(__has_trivial_copy(ACompleteType[])); 2228 2229 static_assert(!__has_trivial_copy(AnIncompleteType[])); // expected-error {{incomplete type}} 2230 static_assert(!__has_trivial_copy(HasCopy)); 2231 static_assert(!__has_trivial_copy(HasTemplateCons)); 2232 static_assert(!__has_trivial_copy(VirtAr)); 2233 static_assert(!__has_trivial_copy(void)); 2234 static_assert(!__has_trivial_copy(cvoid)); 2235 static_assert(!__has_trivial_copy(AllPrivate)); 2236 static_assert(!__has_trivial_copy(ExtDefaulted)); 2237 } 2238 2239 void has_trivial_copy_assignment() { 2240 static_assert(__has_trivial_assign(Int)); 2241 static_assert(__has_trivial_assign(IntAr)); 2242 static_assert(__has_trivial_assign(Union)); 2243 static_assert(__has_trivial_assign(UnionAr)); 2244 static_assert(__has_trivial_assign(POD)); 2245 static_assert(__has_trivial_assign(Derives)); 2246 static_assert(__has_trivial_assign(HasDest)); 2247 static_assert(__has_trivial_assign(HasPriv)); 2248 static_assert(__has_trivial_assign(HasCons)); 2249 static_assert(__has_trivial_assign(HasRef)); 2250 static_assert(__has_trivial_assign(HasCopy)); 2251 static_assert(__has_trivial_assign(HasMove)); 2252 static_assert(__has_trivial_assign(HasMoveAssign)); 2253 static_assert(__has_trivial_assign(AllDefaulted)); 2254 static_assert(__has_trivial_assign(AllDeleted)); 2255 static_assert(__has_trivial_assign(DerivesAr)); 2256 static_assert(__has_trivial_assign(DerivesHasRef)); 2257 static_assert(__has_trivial_assign(ACompleteType[])); 2258 2259 static_assert(!__has_trivial_assign(AnIncompleteType[])); // expected-error {{incomplete type}} 2260 static_assert(!__has_trivial_assign(IntRef)); 2261 static_assert(!__has_trivial_assign(HasCopyAssign)); 2262 static_assert(!__has_trivial_assign(const Int)); 2263 static_assert(!__has_trivial_assign(ConstIntAr)); 2264 static_assert(!__has_trivial_assign(ConstIntArAr)); 2265 static_assert(!__has_trivial_assign(VirtAr)); 2266 static_assert(!__has_trivial_assign(void)); 2267 static_assert(!__has_trivial_assign(cvoid)); 2268 static_assert(!__has_trivial_assign(AllPrivate)); 2269 static_assert(!__has_trivial_assign(ExtDefaulted)); 2270 } 2271 2272 void has_trivial_destructor() { 2273 static_assert(__has_trivial_destructor(Int)); 2274 static_assert(__has_trivial_destructor(IntAr)); 2275 static_assert(__has_trivial_destructor(Union)); 2276 static_assert(__has_trivial_destructor(UnionAr)); 2277 static_assert(__has_trivial_destructor(POD)); 2278 static_assert(__has_trivial_destructor(Derives)); 2279 static_assert(__has_trivial_destructor(ConstIntAr)); 2280 static_assert(__has_trivial_destructor(ConstIntArAr)); 2281 static_assert(__has_trivial_destructor(HasPriv)); 2282 static_assert(__has_trivial_destructor(HasCons)); 2283 static_assert(__has_trivial_destructor(HasRef)); 2284 static_assert(__has_trivial_destructor(HasCopy)); 2285 static_assert(__has_trivial_destructor(HasMove)); 2286 static_assert(__has_trivial_destructor(IntRef)); 2287 static_assert(__has_trivial_destructor(HasCopyAssign)); 2288 static_assert(__has_trivial_destructor(HasMoveAssign)); 2289 static_assert(__has_trivial_destructor(const Int)); 2290 static_assert(__has_trivial_destructor(DerivesAr)); 2291 static_assert(__has_trivial_destructor(VirtAr)); 2292 static_assert(__has_trivial_destructor(AllDefaulted)); 2293 static_assert(__has_trivial_destructor(AllDeleted)); 2294 static_assert(__has_trivial_destructor(DerivesHasRef)); 2295 static_assert(__has_trivial_destructor(ACompleteType[])); 2296 2297 static_assert(!__has_trivial_destructor(HasDest)); 2298 static_assert(!__has_trivial_destructor(AnIncompleteType[])); // expected-error {{incomplete type}} 2299 static_assert(!__has_trivial_destructor(void)); 2300 static_assert(!__has_trivial_destructor(cvoid)); 2301 static_assert(!__has_trivial_destructor(AllPrivate)); 2302 static_assert(!__has_trivial_destructor(ExtDefaulted)); 2303 } 2304 2305 struct A { ~A() {} }; 2306 template<typename> struct B : A { }; 2307 2308 void f() { 2309 static_assert(!__has_trivial_destructor(A)); 2310 static_assert(!__has_trivial_destructor(B<int>)); 2311 } 2312 2313 class PR11110 { 2314 template <int> int operator=( int ); 2315 int operator=(PR11110); 2316 }; 2317 2318 class UsingAssign; 2319 2320 class UsingAssignBase { 2321 protected: 2322 UsingAssign &operator=(const UsingAssign&) throw(); 2323 }; 2324 2325 class UsingAssign : public UsingAssignBase { 2326 public: 2327 using UsingAssignBase::operator=; 2328 }; 2329 2330 void has_nothrow_assign() { 2331 static_assert(__has_nothrow_assign(Int)); 2332 static_assert(__has_nothrow_assign(IntAr)); 2333 static_assert(__has_nothrow_assign(Union)); 2334 static_assert(__has_nothrow_assign(UnionAr)); 2335 static_assert(__has_nothrow_assign(POD)); 2336 static_assert(__has_nothrow_assign(Derives)); 2337 static_assert(__has_nothrow_assign(HasDest)); 2338 static_assert(__has_nothrow_assign(HasPriv)); 2339 static_assert(__has_nothrow_assign(HasCons)); 2340 static_assert(__has_nothrow_assign(HasRef)); 2341 static_assert(__has_nothrow_assign(HasCopy)); 2342 static_assert(__has_nothrow_assign(HasMove)); 2343 static_assert(__has_nothrow_assign(HasMoveAssign)); 2344 static_assert(__has_nothrow_assign(HasNoThrowCopyAssign)); 2345 static_assert(__has_nothrow_assign(HasMultipleNoThrowCopyAssign)); 2346 static_assert(__has_nothrow_assign(HasVirtDest)); 2347 static_assert(__has_nothrow_assign(AllPrivate)); 2348 static_assert(__has_nothrow_assign(UsingAssign)); 2349 static_assert(__has_nothrow_assign(DerivesAr)); 2350 static_assert(__has_nothrow_assign(ACompleteType[])); 2351 2352 static_assert(!__has_nothrow_assign(AnIncompleteType[])); // expected-error {{incomplete type}} 2353 static_assert(!__has_nothrow_assign(IntRef)); 2354 static_assert(!__has_nothrow_assign(HasCopyAssign)); 2355 static_assert(!__has_nothrow_assign(HasMultipleCopyAssign)); 2356 static_assert(!__has_nothrow_assign(const Int)); 2357 static_assert(!__has_nothrow_assign(ConstIntAr)); 2358 static_assert(!__has_nothrow_assign(ConstIntArAr)); 2359 static_assert(!__has_nothrow_assign(VirtAr)); 2360 static_assert(!__has_nothrow_assign(void)); 2361 static_assert(!__has_nothrow_assign(cvoid)); 2362 static_assert(!__has_nothrow_assign(PR11110)); 2363 } 2364 2365 void has_nothrow_move_assign() { 2366 static_assert(__has_nothrow_move_assign(Int)); 2367 static_assert(__has_nothrow_move_assign(Enum)); 2368 static_assert(__has_nothrow_move_assign(Int*)); 2369 static_assert(__has_nothrow_move_assign(Enum POD::*)); 2370 static_assert(__has_nothrow_move_assign(POD)); 2371 static_assert(__has_nothrow_move_assign(HasPriv)); 2372 static_assert(__has_nothrow_move_assign(HasNoThrowMoveAssign)); 2373 static_assert(__has_nothrow_move_assign(HasNoExceptNoThrowMoveAssign)); 2374 static_assert(__has_nothrow_move_assign(HasMemberNoThrowMoveAssign)); 2375 static_assert(__has_nothrow_move_assign(HasMemberNoExceptNoThrowMoveAssign)); 2376 static_assert(__has_nothrow_move_assign(AllDeleted)); 2377 static_assert(__has_nothrow_move_assign(ACompleteType[])); 2378 2379 static_assert(!__has_nothrow_move_assign(AnIncompleteType[])); // expected-error {{incomplete type}} 2380 static_assert(!__has_nothrow_move_assign(HasThrowMoveAssign)); 2381 static_assert(!__has_nothrow_move_assign(HasNoExceptFalseMoveAssign)); 2382 static_assert(!__has_nothrow_move_assign(HasMemberThrowMoveAssign)); 2383 static_assert(!__has_nothrow_move_assign(HasMemberNoExceptFalseMoveAssign)); 2384 static_assert(!__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyCtor)); 2385 static_assert(!__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyAssign)); 2386 static_assert(!__has_nothrow_move_assign(NoDefaultMoveAssignDueToDtor)); 2387 2388 2389 static_assert(__is_nothrow_assignable(HasNoThrowMoveAssign, HasNoThrowMoveAssign)); 2390 static_assert(!__is_nothrow_assignable(HasThrowMoveAssign, HasThrowMoveAssign)); 2391 2392 static_assert(__is_assignable(HasNoThrowMoveAssign, HasNoThrowMoveAssign)); 2393 static_assert(__is_assignable(HasThrowMoveAssign, HasThrowMoveAssign)); 2394 } 2395 2396 void has_trivial_move_assign() { 2397 // n3376 12.8 [class.copy]/25 2398 // A copy/move assignment operator for class X is trivial if it 2399 // is not user-provided, its declared parameter type is the same 2400 // as if it had been implicitly declared, and if: 2401 // - class X has no virtual functions (10.3) and no virtual base 2402 // classes (10.1), and 2403 // - the assignment operator selected to copy/move each direct 2404 // base class subobject is trivial, and 2405 // - for each non-static data member of X that is of class type 2406 // (or array thereof), the assignment operator 2407 // selected to copy/move that member is trivial; 2408 static_assert(__has_trivial_move_assign(Int)); 2409 static_assert(__has_trivial_move_assign(HasStaticMemberMoveAssign)); 2410 static_assert(__has_trivial_move_assign(AllDeleted)); 2411 static_assert(__has_trivial_move_assign(ACompleteType[])); 2412 2413 static_assert(!__has_trivial_move_assign(AnIncompleteType[])); // expected-error {{incomplete type}} 2414 static_assert(!__has_trivial_move_assign(HasVirt)); 2415 static_assert(!__has_trivial_move_assign(DerivesVirt)); 2416 static_assert(!__has_trivial_move_assign(HasMoveAssign)); 2417 static_assert(!__has_trivial_move_assign(DerivesHasMoveAssign)); 2418 static_assert(!__has_trivial_move_assign(HasMemberMoveAssign)); 2419 static_assert(!__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyCtor)); 2420 static_assert(!__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyAssign)); 2421 } 2422 2423 void has_nothrow_copy() { 2424 static_assert(__has_nothrow_copy(Int)); 2425 static_assert(__has_nothrow_copy(IntAr)); 2426 static_assert(__has_nothrow_copy(Union)); 2427 static_assert(__has_nothrow_copy(UnionAr)); 2428 static_assert(__has_nothrow_copy(POD)); 2429 static_assert(__has_nothrow_copy(const Int)); 2430 static_assert(__has_nothrow_copy(ConstIntAr)); 2431 static_assert(__has_nothrow_copy(ConstIntArAr)); 2432 static_assert(__has_nothrow_copy(Derives)); 2433 static_assert(__has_nothrow_copy(IntRef)); 2434 static_assert(__has_nothrow_copy(HasDest)); 2435 static_assert(__has_nothrow_copy(HasPriv)); 2436 static_assert(__has_nothrow_copy(HasCons)); 2437 static_assert(__has_nothrow_copy(HasRef)); 2438 static_assert(__has_nothrow_copy(HasMove)); 2439 static_assert(__has_nothrow_copy(HasCopyAssign)); 2440 static_assert(__has_nothrow_copy(HasMoveAssign)); 2441 static_assert(__has_nothrow_copy(HasNoThrowCopy)); 2442 static_assert(__has_nothrow_copy(HasMultipleNoThrowCopy)); 2443 static_assert(__has_nothrow_copy(HasVirtDest)); 2444 static_assert(__has_nothrow_copy(HasTemplateCons)); 2445 static_assert(__has_nothrow_copy(AllPrivate)); 2446 static_assert(__has_nothrow_copy(DerivesAr)); 2447 static_assert(__has_nothrow_copy(ACompleteType[])); 2448 2449 static_assert(!__has_nothrow_copy(AnIncompleteType[])); // expected-error {{incomplete type}} 2450 static_assert(!__has_nothrow_copy(HasCopy)); 2451 static_assert(!__has_nothrow_copy(HasMultipleCopy)); 2452 static_assert(!__has_nothrow_copy(VirtAr)); 2453 static_assert(!__has_nothrow_copy(void)); 2454 static_assert(!__has_nothrow_copy(cvoid)); 2455 } 2456 2457 void has_nothrow_constructor() { 2458 static_assert(__has_nothrow_constructor(Int)); 2459 static_assert(__has_nothrow_constructor(IntAr)); 2460 static_assert(__has_nothrow_constructor(Union)); 2461 static_assert(__has_nothrow_constructor(UnionAr)); 2462 static_assert(__has_nothrow_constructor(POD)); 2463 static_assert(__has_nothrow_constructor(Derives)); 2464 static_assert(__has_nothrow_constructor(DerivesAr)); 2465 static_assert(__has_nothrow_constructor(ConstIntAr)); 2466 static_assert(__has_nothrow_constructor(ConstIntArAr)); 2467 static_assert(__has_nothrow_constructor(HasDest)); 2468 static_assert(__has_nothrow_constructor(HasPriv)); 2469 static_assert(__has_nothrow_constructor(HasCopyAssign)); 2470 static_assert(__has_nothrow_constructor(const Int)); 2471 static_assert(__has_nothrow_constructor(HasNoThrowConstructor)); 2472 static_assert(__has_nothrow_constructor(HasVirtDest)); 2473 // static_assert(__has_nothrow_constructor(VirtAr)); // not implemented 2474 static_assert(__has_nothrow_constructor(AllPrivate)); 2475 static_assert(__has_nothrow_constructor(ACompleteType[])); 2476 2477 static_assert(!__has_nothrow_constructor(AnIncompleteType[])); // expected-error {{incomplete type}} 2478 static_assert(!__has_nothrow_constructor(HasCons)); 2479 static_assert(!__has_nothrow_constructor(HasRef)); 2480 static_assert(!__has_nothrow_constructor(HasCopy)); 2481 static_assert(!__has_nothrow_constructor(HasMove)); 2482 static_assert(!__has_nothrow_constructor(HasNoThrowConstructorWithArgs)); 2483 static_assert(!__has_nothrow_constructor(IntRef)); 2484 static_assert(!__has_nothrow_constructor(void)); 2485 static_assert(!__has_nothrow_constructor(cvoid)); 2486 static_assert(!__has_nothrow_constructor(HasTemplateCons)); 2487 2488 static_assert(!__has_nothrow_constructor(HasMultipleDefaultConstructor1)); 2489 static_assert(!__has_nothrow_constructor(HasMultipleDefaultConstructor2)); 2490 } 2491 2492 void has_virtual_destructor() { 2493 static_assert(!__has_virtual_destructor(Int)); 2494 static_assert(!__has_virtual_destructor(IntAr)); 2495 static_assert(!__has_virtual_destructor(Union)); 2496 static_assert(!__has_virtual_destructor(UnionAr)); 2497 static_assert(!__has_virtual_destructor(POD)); 2498 static_assert(!__has_virtual_destructor(Derives)); 2499 static_assert(!__has_virtual_destructor(DerivesAr)); 2500 static_assert(!__has_virtual_destructor(const Int)); 2501 static_assert(!__has_virtual_destructor(ConstIntAr)); 2502 static_assert(!__has_virtual_destructor(ConstIntArAr)); 2503 static_assert(!__has_virtual_destructor(HasDest)); 2504 static_assert(!__has_virtual_destructor(HasPriv)); 2505 static_assert(!__has_virtual_destructor(HasCons)); 2506 static_assert(!__has_virtual_destructor(HasRef)); 2507 static_assert(!__has_virtual_destructor(HasCopy)); 2508 static_assert(!__has_virtual_destructor(HasMove)); 2509 static_assert(!__has_virtual_destructor(HasCopyAssign)); 2510 static_assert(!__has_virtual_destructor(HasMoveAssign)); 2511 static_assert(!__has_virtual_destructor(IntRef)); 2512 static_assert(!__has_virtual_destructor(VirtAr)); 2513 static_assert(!__has_virtual_destructor(ACompleteType[])); 2514 2515 static_assert(!__has_virtual_destructor(AnIncompleteType[])); // expected-error {{incomplete type}} 2516 static_assert(__has_virtual_destructor(HasVirtDest)); 2517 static_assert(__has_virtual_destructor(DerivedVirtDest)); 2518 static_assert(!__has_virtual_destructor(VirtDestAr)); 2519 static_assert(!__has_virtual_destructor(void)); 2520 static_assert(!__has_virtual_destructor(cvoid)); 2521 static_assert(!__has_virtual_destructor(AllPrivate)); 2522 } 2523 2524 2525 class Base {}; 2526 class Derived : Base {}; 2527 class Derived2a : Derived {}; 2528 class Derived2b : Derived {}; 2529 class Derived3 : virtual Derived2a, virtual Derived2b {}; 2530 template<typename T> struct BaseA { T a; }; 2531 template<typename T> struct DerivedB : BaseA<T> { }; 2532 template<typename T> struct CrazyDerived : T { }; 2533 2534 2535 class class_forward; // expected-note 4 {{forward declaration of 'class_forward'}} 2536 2537 template <class T> class DerivedTemp : Base {}; 2538 template <class T> class NonderivedTemp {}; 2539 template <class T> class UndefinedTemp; // expected-note 2 {{declared here}} 2540 2541 void is_base_of() { 2542 static_assert(__is_base_of(Base, Derived)); 2543 static_assert(__is_base_of(const Base, Derived)); 2544 static_assert(!__is_base_of(Derived, Base)); 2545 static_assert(!__is_base_of(Derived, int)); 2546 static_assert(__is_base_of(Base, Base)); 2547 static_assert(__is_base_of(Base, Derived3)); 2548 static_assert(__is_base_of(Derived, Derived3)); 2549 static_assert(__is_base_of(Derived2b, Derived3)); 2550 static_assert(__is_base_of(Derived2a, Derived3)); 2551 static_assert(__is_base_of(BaseA<int>, DerivedB<int>)); 2552 static_assert(!__is_base_of(DerivedB<int>, BaseA<int>)); 2553 static_assert(__is_base_of(Base, CrazyDerived<Base>)); 2554 static_assert(!__is_base_of(Union, Union)); 2555 static_assert(__is_base_of(Empty, Empty)); 2556 static_assert(__is_base_of(class_forward, class_forward)); 2557 static_assert(!__is_base_of(Empty, class_forward)); // expected-error {{incomplete type 'class_forward' used in type trait expression}} 2558 static_assert(!__is_base_of(Base&, Derived&)); 2559 static_assert(!__is_base_of(Base[10], Derived[10])); 2560 static_assert(!__is_base_of(int, int)); 2561 static_assert(!__is_base_of(long, int)); 2562 static_assert(__is_base_of(Base, DerivedTemp<int>)); 2563 static_assert(!__is_base_of(Base, NonderivedTemp<int>)); 2564 static_assert(!__is_base_of(Base, UndefinedTemp<int>)); // expected-error {{implicit instantiation of undefined template 'UndefinedTemp<int>'}} 2565 2566 static_assert(!__is_base_of(IncompleteUnion, IncompleteUnion)); 2567 static_assert(!__is_base_of(Union, IncompleteUnion)); 2568 static_assert(!__is_base_of(IncompleteUnion, Union)); 2569 static_assert(!__is_base_of(IncompleteStruct, IncompleteUnion)); 2570 static_assert(!__is_base_of(IncompleteUnion, IncompleteStruct)); 2571 static_assert(!__is_base_of(Empty, IncompleteUnion)); 2572 static_assert(!__is_base_of(IncompleteUnion, Empty)); 2573 static_assert(!__is_base_of(int, IncompleteUnion)); 2574 static_assert(!__is_base_of(IncompleteUnion, int)); 2575 static_assert(!__is_base_of(Empty, Union)); 2576 static_assert(!__is_base_of(Union, Empty)); 2577 static_assert(!__is_base_of(int, Empty)); 2578 static_assert(!__is_base_of(Union, int)); 2579 2580 static_assert(__is_base_of(Base, Derived)); 2581 static_assert(!__is_base_of(Derived, Base)); 2582 2583 static_assert(__is_base_of(Base, CrazyDerived<Base>)); 2584 static_assert(!__is_base_of(CrazyDerived<Base>, Base)); 2585 2586 static_assert(__is_base_of(BaseA<int>, DerivedB<int>)); 2587 static_assert(!__is_base_of(DerivedB<int>, BaseA<int>)); 2588 } 2589 2590 struct DerivedTransitiveViaNonVirtual : Derived3 {}; 2591 struct DerivedTransitiveViaVirtual : virtual Derived3 {}; 2592 2593 template <typename T> 2594 struct CrazyDerivedVirtual : virtual T {}; 2595 2596 struct DerivedPrivate : private virtual Base {}; 2597 struct DerivedProtected : protected virtual Base {}; 2598 struct DerivedPrivatePrivate : private DerivedPrivate {}; 2599 struct DerivedPrivateProtected : private DerivedProtected {}; 2600 struct DerivedProtectedPrivate : protected DerivedProtected {}; 2601 struct DerivedProtectedProtected : protected DerivedProtected {}; 2602 2603 void is_virtual_base_of(int n) { 2604 static_assert(!__builtin_is_virtual_base_of(Base, Derived)); 2605 static_assert(!__builtin_is_virtual_base_of(const Base, Derived)); 2606 static_assert(!__builtin_is_virtual_base_of(Derived, Base)); 2607 static_assert(!__builtin_is_virtual_base_of(Derived, int)); 2608 static_assert(!__builtin_is_virtual_base_of(Base, Base)); 2609 static_assert(!__builtin_is_virtual_base_of(Base, Derived3)); 2610 static_assert(!__builtin_is_virtual_base_of(Derived, Derived3)); 2611 static_assert(__builtin_is_virtual_base_of(Derived2b, Derived3)); 2612 static_assert(__builtin_is_virtual_base_of(Derived2a, Derived3)); 2613 static_assert(!__builtin_is_virtual_base_of(BaseA<int>, DerivedB<int>)); 2614 static_assert(!__builtin_is_virtual_base_of(DerivedB<int>, BaseA<int>)); 2615 static_assert(!__builtin_is_virtual_base_of(Union, Union)); 2616 static_assert(!__builtin_is_virtual_base_of(Empty, Empty)); 2617 static_assert(!__builtin_is_virtual_base_of(class_forward, class_forward)); // expected-error {{incomplete type 'class_forward' where a complete type is required}} 2618 static_assert(!__builtin_is_virtual_base_of(Empty, class_forward)); // expected-error {{incomplete type 'class_forward' where a complete type is required}} 2619 static_assert(!__builtin_is_virtual_base_of(class_forward, Empty)); 2620 static_assert(!__builtin_is_virtual_base_of(Base&, Derived&)); 2621 static_assert(!__builtin_is_virtual_base_of(Base[10], Derived[10])); 2622 static_assert(!__builtin_is_virtual_base_of(Base[n], Derived[n])); // expected-error 2 {{variable length arrays are not supported in '__builtin_is_virtual_base_of'}} 2623 static_assert(!__builtin_is_virtual_base_of(int, int)); 2624 static_assert(!__builtin_is_virtual_base_of(int[], int[])); 2625 static_assert(!__builtin_is_virtual_base_of(long, int)); 2626 static_assert(!__builtin_is_virtual_base_of(Base, DerivedTemp<int>)); 2627 static_assert(!__builtin_is_virtual_base_of(Base, NonderivedTemp<int>)); 2628 static_assert(!__builtin_is_virtual_base_of(Base, UndefinedTemp<int>)); // expected-error {{implicit instantiation of undefined template 'UndefinedTemp<int>'}} 2629 static_assert(__builtin_is_virtual_base_of(Base, DerivedPrivate)); 2630 static_assert(__builtin_is_virtual_base_of(Base, DerivedProtected)); 2631 static_assert(__builtin_is_virtual_base_of(Base, DerivedPrivatePrivate)); 2632 static_assert(__builtin_is_virtual_base_of(Base, DerivedPrivateProtected)); 2633 static_assert(__builtin_is_virtual_base_of(Base, DerivedProtectedPrivate)); 2634 static_assert(__builtin_is_virtual_base_of(Base, DerivedProtectedProtected)); 2635 static_assert(__builtin_is_virtual_base_of(Derived2a, DerivedTransitiveViaNonVirtual)); 2636 static_assert(__builtin_is_virtual_base_of(Derived2b, DerivedTransitiveViaNonVirtual)); 2637 static_assert(__builtin_is_virtual_base_of(Derived2a, DerivedTransitiveViaVirtual)); 2638 static_assert(__builtin_is_virtual_base_of(Derived2b, DerivedTransitiveViaVirtual)); 2639 static_assert(!__builtin_is_virtual_base_of(Base, CrazyDerived<Base>)); 2640 static_assert(!__builtin_is_virtual_base_of(CrazyDerived<Base>, Base)); 2641 static_assert(__builtin_is_virtual_base_of(Base, CrazyDerivedVirtual<Base>)); 2642 static_assert(!__builtin_is_virtual_base_of(CrazyDerivedVirtual<Base>, Base)); 2643 2644 static_assert(!__builtin_is_virtual_base_of(IncompleteUnion, IncompleteUnion)); 2645 static_assert(!__builtin_is_virtual_base_of(Union, IncompleteUnion)); 2646 static_assert(!__builtin_is_virtual_base_of(IncompleteUnion, Union)); 2647 static_assert(!__builtin_is_virtual_base_of(IncompleteStruct, IncompleteUnion)); 2648 static_assert(!__builtin_is_virtual_base_of(IncompleteUnion, IncompleteStruct)); 2649 static_assert(!__builtin_is_virtual_base_of(Empty, IncompleteUnion)); 2650 static_assert(!__builtin_is_virtual_base_of(IncompleteUnion, Empty)); 2651 static_assert(!__builtin_is_virtual_base_of(int, IncompleteUnion)); 2652 static_assert(!__builtin_is_virtual_base_of(IncompleteUnion, int)); 2653 static_assert(!__builtin_is_virtual_base_of(Empty, Union)); 2654 static_assert(!__builtin_is_virtual_base_of(Union, Empty)); 2655 static_assert(!__builtin_is_virtual_base_of(int, Empty)); 2656 static_assert(!__builtin_is_virtual_base_of(Union, int)); 2657 static_assert(!__builtin_is_virtual_base_of(IncompleteStruct, IncompleteStruct[n])); // expected-error {{variable length arrays are not supported in '__builtin_is_virtual_base_of'}} 2658 } 2659 2660 template<class T, class U> 2661 class TemplateClass {}; 2662 2663 template<class T> 2664 using TemplateAlias = TemplateClass<T, int>; 2665 2666 typedef class Base BaseTypedef; 2667 2668 void is_same() 2669 { 2670 static_assert(__is_same(Base, Base)); 2671 static_assert(__is_same(Base, BaseTypedef)); 2672 static_assert(__is_same(TemplateClass<int, int>, TemplateAlias<int>)); 2673 2674 static_assert(!__is_same(Base, const Base)); 2675 static_assert(!__is_same(Base, Base&)); 2676 static_assert(!__is_same(Base, Derived)); 2677 2678 // __is_same_as is a GCC compatibility synonym for __is_same. 2679 static_assert(__is_same_as(int, int)); 2680 static_assert(!__is_same_as(int, float)); 2681 } 2682 2683 struct IntWrapper 2684 { 2685 int value; 2686 IntWrapper(int _value) : value(_value) {} 2687 operator int() const noexcept { 2688 return value; 2689 } 2690 }; 2691 2692 struct FloatWrapper 2693 { 2694 float value; 2695 FloatWrapper(float _value) noexcept : value(_value) {} 2696 FloatWrapper(const IntWrapper& obj) 2697 : value(static_cast<float>(obj.value)) {} 2698 operator float() const { 2699 return value; 2700 } 2701 operator IntWrapper() const { 2702 return IntWrapper(static_cast<int>(value)); 2703 } 2704 }; 2705 2706 void is_convertible() 2707 { 2708 static_assert(__is_convertible(IntWrapper, IntWrapper)); 2709 static_assert(__is_convertible(IntWrapper, const IntWrapper)); 2710 static_assert(__is_convertible(IntWrapper, int)); 2711 static_assert(__is_convertible(int, IntWrapper)); 2712 static_assert(__is_convertible(IntWrapper, FloatWrapper)); 2713 static_assert(__is_convertible(FloatWrapper, IntWrapper)); 2714 static_assert(__is_convertible(FloatWrapper, float)); 2715 static_assert(__is_convertible(float, FloatWrapper)); 2716 static_assert(__is_convertible(IntWrapper, IntWrapper&&)); 2717 static_assert(__is_convertible(IntWrapper, const IntWrapper&)); 2718 static_assert(__is_convertible(IntWrapper, int&&)); 2719 static_assert(__is_convertible(IntWrapper, const int&)); 2720 static_assert(__is_convertible(int, IntWrapper&&)); 2721 static_assert(__is_convertible(int, const IntWrapper&)); 2722 static_assert(__is_convertible(IntWrapper, FloatWrapper&&)); 2723 static_assert(__is_convertible(IntWrapper, const FloatWrapper&)); 2724 static_assert(__is_convertible(FloatWrapper, IntWrapper&&)); 2725 static_assert(__is_convertible(FloatWrapper, const IntWrapper&&)); 2726 static_assert(__is_convertible(FloatWrapper, float&&)); 2727 static_assert(__is_convertible(FloatWrapper, const float&)); 2728 static_assert(__is_convertible(float, FloatWrapper&&)); 2729 static_assert(__is_convertible(float, const FloatWrapper&)); 2730 } 2731 2732 void is_nothrow_convertible() 2733 { 2734 static_assert(__is_nothrow_convertible(IntWrapper, IntWrapper)); 2735 static_assert(__is_nothrow_convertible(IntWrapper, const IntWrapper)); 2736 static_assert(__is_nothrow_convertible(IntWrapper, int)); 2737 static_assert(!__is_nothrow_convertible(int, IntWrapper)); 2738 static_assert(!__is_nothrow_convertible(IntWrapper, FloatWrapper)); 2739 static_assert(!__is_nothrow_convertible(FloatWrapper, IntWrapper)); 2740 static_assert(!__is_nothrow_convertible(FloatWrapper, float)); 2741 static_assert(__is_nothrow_convertible(float, FloatWrapper)); 2742 static_assert(__is_nothrow_convertible(IntWrapper, IntWrapper&&)); 2743 static_assert(__is_nothrow_convertible(IntWrapper, const IntWrapper&)); 2744 static_assert(__is_nothrow_convertible(IntWrapper, int&&)); 2745 static_assert(__is_nothrow_convertible(IntWrapper, const int&)); 2746 static_assert(!__is_nothrow_convertible(int, IntWrapper&&)); 2747 static_assert(!__is_nothrow_convertible(int, const IntWrapper&)); 2748 static_assert(!__is_nothrow_convertible(IntWrapper, FloatWrapper&&)); 2749 static_assert(!__is_nothrow_convertible(IntWrapper, const FloatWrapper&)); 2750 static_assert(!__is_nothrow_convertible(FloatWrapper, IntWrapper&&)); 2751 static_assert(!__is_nothrow_convertible(FloatWrapper, const IntWrapper&)); 2752 static_assert(!__is_nothrow_convertible(FloatWrapper, float&&)); 2753 static_assert(!__is_nothrow_convertible(FloatWrapper, const float&)); 2754 static_assert(__is_nothrow_convertible(float, FloatWrapper&&)); 2755 static_assert(__is_nothrow_convertible(float, const FloatWrapper&)); 2756 } 2757 2758 struct FromInt { FromInt(int); }; 2759 struct ToInt { operator int(); }; 2760 typedef void Function(); 2761 2762 void is_convertible_to(); 2763 class PrivateCopy { 2764 PrivateCopy(const PrivateCopy&); 2765 friend void is_convertible_to(); 2766 }; 2767 2768 template<typename T> 2769 struct X0 { 2770 template<typename U> X0(const X0<U>&); 2771 }; 2772 2773 struct Abstract { virtual void f() = 0; }; 2774 2775 void is_convertible_to() { 2776 static_assert(__is_convertible_to(Int, Int)); 2777 static_assert(!__is_convertible_to(Int, IntAr)); 2778 static_assert(!__is_convertible_to(IntAr, IntAr)); 2779 static_assert(__is_convertible_to(void, void)); 2780 static_assert(__is_convertible_to(cvoid, void)); 2781 static_assert(__is_convertible_to(void, cvoid)); 2782 static_assert(__is_convertible_to(cvoid, cvoid)); 2783 static_assert(__is_convertible_to(int, FromInt)); 2784 static_assert(__is_convertible_to(long, FromInt)); 2785 static_assert(__is_convertible_to(double, FromInt)); 2786 static_assert(__is_convertible_to(const int, FromInt)); 2787 static_assert(__is_convertible_to(const int&, FromInt)); 2788 static_assert(__is_convertible_to(ToInt, int)); 2789 static_assert(__is_convertible_to(ToInt, const int&)); 2790 static_assert(__is_convertible_to(ToInt, long)); 2791 static_assert(!__is_convertible_to(ToInt, int&)); 2792 static_assert(!__is_convertible_to(ToInt, FromInt)); 2793 static_assert(__is_convertible_to(IntAr&, IntAr&)); 2794 static_assert(__is_convertible_to(IntAr&, const IntAr&)); 2795 static_assert(!__is_convertible_to(const IntAr&, IntAr&)); 2796 static_assert(!__is_convertible_to(Function, Function)); 2797 static_assert(!__is_convertible_to(PrivateCopy, PrivateCopy)); 2798 static_assert(__is_convertible_to(X0<int>, X0<float>)); 2799 static_assert(!__is_convertible_to(Abstract, Abstract)); 2800 } 2801 2802 namespace is_convertible_to_instantiate { 2803 // Make sure we don't try to instantiate the constructor. 2804 template<int x> class A { A(int) { int a[x]; } }; 2805 int x = __is_convertible_to(int, A<-1>); 2806 } 2807 2808 void is_trivial() 2809 { 2810 static_assert(__is_trivial(int)); 2811 static_assert(__is_trivial(Enum)); 2812 static_assert(__is_trivial(POD)); 2813 static_assert(__is_trivial(Int)); 2814 static_assert(__is_trivial(IntAr)); 2815 static_assert(__is_trivial(IntArNB)); 2816 static_assert(__is_trivial(Statics)); 2817 static_assert(__is_trivial(Empty)); 2818 static_assert(__is_trivial(EmptyUnion)); 2819 static_assert(__is_trivial(Union)); 2820 static_assert(__is_trivial(Derives)); 2821 static_assert(__is_trivial(DerivesAr)); 2822 static_assert(__is_trivial(DerivesArNB)); 2823 static_assert(__is_trivial(DerivesEmpty)); 2824 static_assert(__is_trivial(HasFunc)); 2825 static_assert(__is_trivial(HasOp)); 2826 static_assert(__is_trivial(HasConv)); 2827 static_assert(__is_trivial(HasAssign)); 2828 static_assert(__is_trivial(HasAnonymousUnion)); 2829 static_assert(__is_trivial(HasPriv)); 2830 static_assert(__is_trivial(HasProt)); 2831 static_assert(__is_trivial(DerivesHasPriv)); 2832 static_assert(__is_trivial(DerivesHasProt)); 2833 static_assert(__is_trivial(Vector)); 2834 static_assert(__is_trivial(VectorExt)); 2835 2836 static_assert(!__is_trivial(HasCons)); 2837 static_assert(!__is_trivial(HasCopyAssign)); 2838 static_assert(!__is_trivial(HasMoveAssign)); 2839 static_assert(!__is_trivial(HasDest)); 2840 static_assert(!__is_trivial(HasRef)); 2841 static_assert(!__is_trivial(HasNonPOD)); 2842 static_assert(!__is_trivial(HasVirt)); 2843 static_assert(!__is_trivial(DerivesHasCons)); 2844 static_assert(!__is_trivial(DerivesHasCopyAssign)); 2845 static_assert(!__is_trivial(DerivesHasMoveAssign)); 2846 static_assert(!__is_trivial(DerivesHasDest)); 2847 static_assert(!__is_trivial(DerivesHasRef)); 2848 static_assert(!__is_trivial(DerivesHasVirt)); 2849 static_assert(!__is_trivial(void)); 2850 static_assert(!__is_trivial(cvoid)); 2851 } 2852 2853 template<typename T> struct TriviallyConstructibleTemplate {}; 2854 2855 void trivial_checks() 2856 { 2857 static_assert(__is_trivially_copyable(int)); 2858 static_assert(__is_trivially_copyable(Enum)); 2859 static_assert(__is_trivially_copyable(POD)); 2860 static_assert(__is_trivially_copyable(Int)); 2861 static_assert(__is_trivially_copyable(IntAr)); 2862 static_assert(__is_trivially_copyable(IntArNB)); 2863 static_assert(__is_trivially_copyable(Statics)); 2864 static_assert(__is_trivially_copyable(Empty)); 2865 static_assert(__is_trivially_copyable(EmptyUnion)); 2866 static_assert(__is_trivially_copyable(Union)); 2867 static_assert(__is_trivially_copyable(Derives)); 2868 static_assert(__is_trivially_copyable(DerivesAr)); 2869 static_assert(__is_trivially_copyable(DerivesArNB)); 2870 static_assert(__is_trivially_copyable(DerivesEmpty)); 2871 static_assert(__is_trivially_copyable(HasFunc)); 2872 static_assert(__is_trivially_copyable(HasOp)); 2873 static_assert(__is_trivially_copyable(HasConv)); 2874 static_assert(__is_trivially_copyable(HasAssign)); 2875 static_assert(__is_trivially_copyable(HasAnonymousUnion)); 2876 static_assert(__is_trivially_copyable(HasPriv)); 2877 static_assert(__is_trivially_copyable(HasProt)); 2878 static_assert(__is_trivially_copyable(DerivesHasPriv)); 2879 static_assert(__is_trivially_copyable(DerivesHasProt)); 2880 static_assert(__is_trivially_copyable(Vector)); 2881 static_assert(__is_trivially_copyable(VectorExt)); 2882 static_assert(__is_trivially_copyable(HasCons)); 2883 static_assert(__is_trivially_copyable(HasRef)); 2884 static_assert(__is_trivially_copyable(HasNonPOD)); 2885 static_assert(__is_trivially_copyable(DerivesHasCons)); 2886 static_assert(__is_trivially_copyable(DerivesHasRef)); 2887 static_assert(__is_trivially_copyable(NonTrivialDefault)); 2888 static_assert(__is_trivially_copyable(NonTrivialDefault[])); 2889 static_assert(__is_trivially_copyable(NonTrivialDefault[3])); 2890 2891 static_assert(!__is_trivially_copyable(HasCopyAssign)); 2892 static_assert(!__is_trivially_copyable(HasMoveAssign)); 2893 static_assert(!__is_trivially_copyable(HasDest)); 2894 static_assert(!__is_trivially_copyable(HasVirt)); 2895 static_assert(!__is_trivially_copyable(DerivesHasCopyAssign)); 2896 static_assert(!__is_trivially_copyable(DerivesHasMoveAssign)); 2897 static_assert(!__is_trivially_copyable(DerivesHasDest)); 2898 static_assert(!__is_trivially_copyable(DerivesHasVirt)); 2899 static_assert(!__is_trivially_copyable(void)); 2900 static_assert(!__is_trivially_copyable(cvoid)); 2901 2902 static_assert((__is_trivially_constructible(int))); 2903 static_assert((__is_trivially_constructible(int, int))); 2904 static_assert((__is_trivially_constructible(int, float))); 2905 static_assert((__is_trivially_constructible(int, int&))); 2906 static_assert((__is_trivially_constructible(int, const int&))); 2907 static_assert((__is_trivially_constructible(int, int))); 2908 static_assert((__is_trivially_constructible(HasCopyAssign, HasCopyAssign))); 2909 static_assert((__is_trivially_constructible(HasCopyAssign, const HasCopyAssign&))); 2910 static_assert((__is_trivially_constructible(HasCopyAssign, HasCopyAssign&&))); 2911 static_assert((__is_trivially_constructible(HasCopyAssign))); 2912 static_assert((__is_trivially_constructible(NonTrivialDefault, 2913 const NonTrivialDefault&))); 2914 static_assert((__is_trivially_constructible(NonTrivialDefault, 2915 NonTrivialDefault&&))); 2916 static_assert((__is_trivially_constructible(AllDefaulted))); 2917 static_assert((__is_trivially_constructible(AllDefaulted, 2918 const AllDefaulted &))); 2919 static_assert((__is_trivially_constructible(AllDefaulted, 2920 AllDefaulted &&))); 2921 2922 static_assert(!(__is_trivially_constructible(int, int*))); 2923 static_assert(!(__is_trivially_constructible(NonTrivialDefault))); 2924 static_assert(!(__is_trivially_constructible(ThreeArgCtor, int*, char*, int&))); 2925 static_assert(!(__is_trivially_constructible(AllDeleted))); 2926 static_assert(!(__is_trivially_constructible(AllDeleted, 2927 const AllDeleted &))); 2928 static_assert(!(__is_trivially_constructible(AllDeleted, 2929 AllDeleted &&))); 2930 static_assert(!(__is_trivially_constructible(ExtDefaulted))); 2931 static_assert(!(__is_trivially_constructible(ExtDefaulted, 2932 const ExtDefaulted &))); 2933 static_assert(!(__is_trivially_constructible(ExtDefaulted, 2934 ExtDefaulted &&))); 2935 2936 static_assert((__is_trivially_constructible(TriviallyConstructibleTemplate<int>))); 2937 static_assert(!(__is_trivially_constructible(class_forward))); // expected-error {{incomplete type 'class_forward' used in type trait expression}} 2938 static_assert(!(__is_trivially_constructible(class_forward[]))); 2939 static_assert(!(__is_trivially_constructible(void))); 2940 2941 static_assert((__is_trivially_assignable(int&, int))); 2942 static_assert((__is_trivially_assignable(int&, int&))); 2943 static_assert((__is_trivially_assignable(int&, int&&))); 2944 static_assert((__is_trivially_assignable(int&, const int&))); 2945 static_assert((__is_trivially_assignable(POD&, POD))); 2946 static_assert((__is_trivially_assignable(POD&, POD&))); 2947 static_assert((__is_trivially_assignable(POD&, POD&&))); 2948 static_assert((__is_trivially_assignable(POD&, const POD&))); 2949 static_assert((__is_trivially_assignable(int*&, int*))); 2950 static_assert((__is_trivially_assignable(AllDefaulted, 2951 const AllDefaulted &))); 2952 static_assert((__is_trivially_assignable(AllDefaulted, 2953 AllDefaulted &&))); 2954 2955 static_assert(!(__is_trivially_assignable(int*&, float*))); 2956 static_assert(!(__is_trivially_assignable(HasCopyAssign&, HasCopyAssign))); 2957 static_assert(!(__is_trivially_assignable(HasCopyAssign&, HasCopyAssign&))); 2958 static_assert(!(__is_trivially_assignable(HasCopyAssign&, const HasCopyAssign&))); 2959 static_assert(!(__is_trivially_assignable(HasCopyAssign&, HasCopyAssign&&))); 2960 static_assert(!(__is_trivially_assignable(TrivialMoveButNotCopy&, 2961 TrivialMoveButNotCopy&))); 2962 static_assert(!(__is_trivially_assignable(TrivialMoveButNotCopy&, 2963 const TrivialMoveButNotCopy&))); 2964 static_assert(!(__is_trivially_assignable(AllDeleted, 2965 const AllDeleted &))); 2966 static_assert(!(__is_trivially_assignable(AllDeleted, 2967 AllDeleted &&))); 2968 static_assert(!(__is_trivially_assignable(ExtDefaulted, 2969 const ExtDefaulted &))); 2970 static_assert(!(__is_trivially_assignable(ExtDefaulted, 2971 ExtDefaulted &&))); 2972 2973 static_assert((__is_trivially_assignable(HasDefaultTrivialCopyAssign&, 2974 HasDefaultTrivialCopyAssign&))); 2975 static_assert((__is_trivially_assignable(HasDefaultTrivialCopyAssign&, 2976 const HasDefaultTrivialCopyAssign&))); 2977 static_assert((__is_trivially_assignable(TrivialMoveButNotCopy&, 2978 TrivialMoveButNotCopy))); 2979 static_assert((__is_trivially_assignable(TrivialMoveButNotCopy&, 2980 TrivialMoveButNotCopy&&))); 2981 static_assert((__is_trivially_assignable(int&, int))); 2982 static_assert((__is_trivially_assignable(int&, int&))); 2983 static_assert((__is_trivially_assignable(int&, int&&))); 2984 static_assert((__is_trivially_assignable(int&, const int&))); 2985 static_assert((__is_trivially_assignable(POD&, POD))); 2986 static_assert((__is_trivially_assignable(POD&, POD&))); 2987 static_assert((__is_trivially_assignable(POD&, POD&&))); 2988 static_assert((__is_trivially_assignable(POD&, const POD&))); 2989 static_assert((__is_trivially_assignable(int*&, int*))); 2990 static_assert((__is_trivially_assignable(AllDefaulted, 2991 const AllDefaulted &))); 2992 static_assert((__is_trivially_assignable(AllDefaulted, 2993 AllDefaulted &&))); 2994 2995 static_assert(!(__is_assignable(int *&, float *))); 2996 static_assert((__is_assignable(HasCopyAssign &, HasCopyAssign))); 2997 static_assert((__is_assignable(HasCopyAssign &, HasCopyAssign &))); 2998 static_assert((__is_assignable(HasCopyAssign &, const HasCopyAssign &))); 2999 static_assert((__is_assignable(HasCopyAssign &, HasCopyAssign &&))); 3000 static_assert((__is_assignable(TrivialMoveButNotCopy &, 3001 TrivialMoveButNotCopy &))); 3002 static_assert((__is_assignable(TrivialMoveButNotCopy &, 3003 const TrivialMoveButNotCopy &))); 3004 static_assert(!(__is_assignable(AllDeleted, 3005 const AllDeleted &))); 3006 static_assert(!(__is_assignable(AllDeleted, 3007 AllDeleted &&))); 3008 static_assert((__is_assignable(ExtDefaulted, 3009 const ExtDefaulted &))); 3010 static_assert((__is_assignable(ExtDefaulted, 3011 ExtDefaulted &&))); 3012 3013 static_assert((__is_assignable(HasDefaultTrivialCopyAssign &, 3014 HasDefaultTrivialCopyAssign &))); 3015 static_assert((__is_assignable(HasDefaultTrivialCopyAssign &, 3016 const HasDefaultTrivialCopyAssign &))); 3017 static_assert((__is_assignable(TrivialMoveButNotCopy &, 3018 TrivialMoveButNotCopy))); 3019 static_assert((__is_assignable(TrivialMoveButNotCopy &, 3020 TrivialMoveButNotCopy &&))); 3021 3022 static_assert(__is_assignable(ACompleteType, ACompleteType)); 3023 static_assert(!__is_assignable(AnIncompleteType, AnIncompleteType)); // expected-error {{incomplete type}} 3024 static_assert(!__is_assignable(AnIncompleteType[], AnIncompleteType[])); 3025 static_assert(!__is_assignable(AnIncompleteType[1], AnIncompleteType[1])); // expected-error {{incomplete type}} 3026 static_assert(!__is_assignable(void, void)); 3027 static_assert(!__is_assignable(const volatile void, const volatile void)); 3028 } 3029 3030 void constructible_checks() { 3031 static_assert(__is_constructible(HasNoThrowConstructorWithArgs)); 3032 static_assert(!__is_nothrow_constructible(HasNoThrowConstructorWithArgs)); // MSVC doesn't look into default args and gets this wrong. 3033 3034 static_assert(__is_constructible(HasNoThrowConstructorWithArgs, HasCons)); 3035 static_assert(__is_nothrow_constructible(HasNoThrowConstructorWithArgs, HasCons)); 3036 3037 static_assert(__is_constructible(NonTrivialDefault)); 3038 static_assert(!__is_nothrow_constructible(NonTrivialDefault)); 3039 3040 static_assert(__is_constructible(int)); 3041 static_assert(__is_nothrow_constructible(int)); 3042 3043 static_assert(!__is_constructible(NonPOD)); 3044 static_assert(!__is_nothrow_constructible(NonPOD)); 3045 3046 static_assert(__is_constructible(NonPOD, int)); 3047 static_assert(!__is_nothrow_constructible(NonPOD, int)); 3048 3049 // PR19178 3050 static_assert(!__is_constructible(Abstract)); 3051 static_assert(!__is_nothrow_constructible(Abstract)); 3052 3053 // PR20228 3054 static_assert(__is_constructible(VariadicCtor, 3055 int, int, int, int, int, int, int, int, int)); 3056 3057 // PR25513 3058 static_assert(!__is_constructible(int(int))); 3059 static_assert(__is_constructible(int const &, long)); 3060 3061 static_assert(__is_constructible(ACompleteType)); 3062 static_assert(__is_nothrow_constructible(ACompleteType)); 3063 static_assert(!__is_constructible(AnIncompleteType)); // expected-error {{incomplete type}} 3064 static_assert(!__is_nothrow_constructible(AnIncompleteType)); // expected-error {{incomplete type}} 3065 static_assert(!__is_constructible(AnIncompleteType[])); 3066 static_assert(!__is_nothrow_constructible(AnIncompleteType[])); 3067 static_assert(!__is_constructible(AnIncompleteType[1])); // expected-error {{incomplete type}} 3068 static_assert(!__is_nothrow_constructible(AnIncompleteType[1])); // expected-error {{incomplete type}} 3069 static_assert(!__is_constructible(void)); 3070 static_assert(!__is_nothrow_constructible(void)); 3071 static_assert(!__is_constructible(const volatile void)); 3072 static_assert(!__is_nothrow_constructible(const volatile void)); 3073 } 3074 3075 // Instantiation of __is_trivially_constructible 3076 template<typename T, typename ...Args> 3077 struct is_trivially_constructible { 3078 static const bool value = __is_trivially_constructible(T, Args...); 3079 }; 3080 3081 void is_trivially_constructible_test() { 3082 static_assert((is_trivially_constructible<int>::value)); 3083 static_assert((is_trivially_constructible<int, int>::value)); 3084 static_assert((is_trivially_constructible<int, float>::value)); 3085 static_assert((is_trivially_constructible<int, int&>::value)); 3086 static_assert((is_trivially_constructible<int, const int&>::value)); 3087 static_assert((is_trivially_constructible<int, int>::value)); 3088 static_assert((is_trivially_constructible<HasCopyAssign, HasCopyAssign>::value)); 3089 static_assert((is_trivially_constructible<HasCopyAssign, const HasCopyAssign&>::value)); 3090 static_assert((is_trivially_constructible<HasCopyAssign, HasCopyAssign&&>::value)); 3091 static_assert((is_trivially_constructible<HasCopyAssign>::value)); 3092 static_assert((is_trivially_constructible<NonTrivialDefault, 3093 const NonTrivialDefault&>::value)); 3094 static_assert((is_trivially_constructible<NonTrivialDefault, 3095 NonTrivialDefault&&>::value)); 3096 3097 static_assert(!(is_trivially_constructible<int, int*>::value)); 3098 static_assert(!(is_trivially_constructible<NonTrivialDefault>::value)); 3099 static_assert(!(is_trivially_constructible<ThreeArgCtor, int*, char*, int&>::value)); 3100 static_assert(!(is_trivially_constructible<Abstract>::value)); // PR19178 3101 3102 static_assert(__is_trivially_constructible(ACompleteType)); 3103 static_assert(!__is_trivially_constructible(AnIncompleteType)); // expected-error {{incomplete type}} 3104 static_assert(!__is_trivially_constructible(AnIncompleteType[])); 3105 static_assert(!__is_trivially_constructible(AnIncompleteType[1])); // expected-error {{incomplete type}} 3106 static_assert(!__is_trivially_constructible(void)); 3107 static_assert(!__is_trivially_constructible(const volatile void)); 3108 } 3109 3110 template <class T, class RefType = T &> 3111 struct ConvertsToRef { 3112 operator RefType() const { return static_cast<RefType>(obj); } 3113 mutable T obj = 42; 3114 }; 3115 template <class T, class RefType = T &> 3116 class ConvertsToRefPrivate { 3117 operator RefType() const { return static_cast<RefType>(obj); } 3118 mutable T obj = 42; 3119 }; 3120 3121 3122 void reference_binds_to_temporary_checks() { 3123 static_assert(!(__reference_binds_to_temporary(int &, int &))); 3124 static_assert(!(__reference_binds_to_temporary(int &, int &&))); 3125 3126 static_assert(!(__reference_binds_to_temporary(int const &, int &))); 3127 static_assert(!(__reference_binds_to_temporary(int const &, int const &))); 3128 static_assert(!(__reference_binds_to_temporary(int const &, int &&))); 3129 3130 static_assert(!(__reference_binds_to_temporary(int &, long &))); // doesn't construct 3131 static_assert((__reference_binds_to_temporary(int const &, long &))); 3132 static_assert((__reference_binds_to_temporary(int const &, long &&))); 3133 static_assert((__reference_binds_to_temporary(int &&, long &))); 3134 3135 using LRef = ConvertsToRef<int, int &>; 3136 using RRef = ConvertsToRef<int, int &&>; 3137 using CLRef = ConvertsToRef<int, const int &>; 3138 using LongRef = ConvertsToRef<long, long &>; 3139 static_assert((__is_constructible(int &, LRef))); 3140 static_assert(!(__reference_binds_to_temporary(int &, LRef))); 3141 3142 static_assert((__is_constructible(int &&, RRef))); 3143 static_assert(!(__reference_binds_to_temporary(int &&, RRef))); 3144 3145 static_assert((__is_constructible(int const &, CLRef))); 3146 static_assert(!(__reference_binds_to_temporary(int &&, CLRef))); 3147 3148 static_assert((__is_constructible(int const &, LongRef))); 3149 static_assert((__reference_binds_to_temporary(int const &, LongRef))); 3150 static_assert(!__reference_binds_to_temporary(int const &, ConvertsToRefPrivate<long, long &>)); 3151 3152 3153 // Test that it doesn't accept non-reference types as input. 3154 static_assert(!(__reference_binds_to_temporary(int, long))); 3155 3156 static_assert((__reference_binds_to_temporary(const int &, long))); 3157 } 3158 3159 3160 struct ExplicitConversionRvalueRef { 3161 operator int(); 3162 explicit operator int&&(); 3163 }; 3164 3165 struct ExplicitConversionRef { 3166 operator int(); 3167 explicit operator int&(); 3168 }; 3169 3170 void reference_constructs_from_temporary_checks() { 3171 static_assert(!__reference_constructs_from_temporary(int &, int &)); 3172 static_assert(!__reference_constructs_from_temporary(int &, int &&)); 3173 3174 static_assert(!__reference_constructs_from_temporary(int const &, int &)); 3175 static_assert(!__reference_constructs_from_temporary(int const &, int const &)); 3176 static_assert(!__reference_constructs_from_temporary(int const &, int &&)); 3177 3178 static_assert(!__reference_constructs_from_temporary(int &, long &)); // doesn't construct 3179 3180 static_assert(__reference_constructs_from_temporary(int const &, long &)); 3181 static_assert(__reference_constructs_from_temporary(int const &, long &&)); 3182 static_assert(__reference_constructs_from_temporary(int &&, long &)); 3183 3184 using LRef = ConvertsToRef<int, int &>; 3185 using RRef = ConvertsToRef<int, int &&>; 3186 using CLRef = ConvertsToRef<int, const int &>; 3187 using LongRef = ConvertsToRef<long, long &>; 3188 static_assert(__is_constructible(int &, LRef)); 3189 static_assert(!__reference_constructs_from_temporary(int &, LRef)); 3190 3191 static_assert(__is_constructible(int &&, RRef)); 3192 static_assert(!__reference_constructs_from_temporary(int &&, RRef)); 3193 3194 static_assert(__is_constructible(int const &, CLRef)); 3195 static_assert(!__reference_constructs_from_temporary(int &&, CLRef)); 3196 3197 static_assert(__is_constructible(int const &, LongRef)); 3198 static_assert(__reference_constructs_from_temporary(int const &, LongRef)); 3199 static_assert(!__reference_constructs_from_temporary(int const &, ConvertsToRefPrivate<long, long &>)); 3200 3201 3202 // Test that it doesn't accept non-reference types as input. 3203 static_assert(!__reference_constructs_from_temporary(int, long)); 3204 3205 static_assert(__reference_constructs_from_temporary(const int &, long)); 3206 3207 // Additional checks 3208 static_assert(__reference_constructs_from_temporary(POD const&, Derives)); 3209 static_assert(__reference_constructs_from_temporary(int&&, int)); 3210 static_assert(__reference_constructs_from_temporary(const int&, int)); 3211 static_assert(!__reference_constructs_from_temporary(int&&, int&&)); 3212 static_assert(!__reference_constructs_from_temporary(const int&, int&&)); 3213 static_assert(__reference_constructs_from_temporary(int&&, long&&)); 3214 static_assert(__reference_constructs_from_temporary(int&&, long)); 3215 3216 3217 static_assert(!__reference_constructs_from_temporary(int&, ExplicitConversionRef)); 3218 static_assert(!__reference_constructs_from_temporary(const int&, ExplicitConversionRef)); 3219 static_assert(!__reference_constructs_from_temporary(int&&, ExplicitConversionRvalueRef)); 3220 3221 3222 } 3223 3224 void reference_converts_from_temporary_checks() { 3225 static_assert(!__reference_converts_from_temporary(int &, int &)); 3226 static_assert(!__reference_converts_from_temporary(int &, int &&)); 3227 3228 static_assert(!__reference_converts_from_temporary(int const &, int &)); 3229 static_assert(!__reference_converts_from_temporary(int const &, int const &)); 3230 static_assert(!__reference_converts_from_temporary(int const &, int &&)); 3231 3232 static_assert(!__reference_converts_from_temporary(int &, long &)); // doesn't construct 3233 3234 static_assert(__reference_converts_from_temporary(int const &, long &)); 3235 static_assert(__reference_converts_from_temporary(int const &, long &&)); 3236 static_assert(__reference_converts_from_temporary(int &&, long &)); 3237 3238 using LRef = ConvertsToRef<int, int &>; 3239 using RRef = ConvertsToRef<int, int &&>; 3240 using CLRef = ConvertsToRef<int, const int &>; 3241 using LongRef = ConvertsToRef<long, long &>; 3242 static_assert(__is_constructible(int &, LRef)); 3243 static_assert(!__reference_converts_from_temporary(int &, LRef)); 3244 3245 static_assert(__is_constructible(int &&, RRef)); 3246 static_assert(!__reference_converts_from_temporary(int &&, RRef)); 3247 3248 static_assert(__is_constructible(int const &, CLRef)); 3249 static_assert(!__reference_converts_from_temporary(int &&, CLRef)); 3250 3251 static_assert(__is_constructible(int const &, LongRef)); 3252 static_assert(__reference_converts_from_temporary(int const &, LongRef)); 3253 static_assert(!__reference_converts_from_temporary(int const &, ConvertsToRefPrivate<long, long &>)); 3254 3255 3256 // Test that it doesn't accept non-reference types as input. 3257 static_assert(!__reference_converts_from_temporary(int, long)); 3258 3259 static_assert(__reference_converts_from_temporary(const int &, long)); 3260 3261 // Additional checks 3262 static_assert(__reference_converts_from_temporary(POD const&, Derives)); 3263 static_assert(__reference_converts_from_temporary(int&&, int)); 3264 static_assert(__reference_converts_from_temporary(const int&, int)); 3265 static_assert(!__reference_converts_from_temporary(int&&, int&&)); 3266 static_assert(!__reference_converts_from_temporary(const int&, int&&)); 3267 static_assert(__reference_converts_from_temporary(int&&, long&&)); 3268 static_assert(__reference_converts_from_temporary(int&&, long)); 3269 3270 static_assert(!__reference_converts_from_temporary(int&, ExplicitConversionRef)); 3271 static_assert(__reference_converts_from_temporary(const int&, ExplicitConversionRef)); 3272 static_assert(__reference_converts_from_temporary(int&&, ExplicitConversionRvalueRef)); 3273 3274 } 3275 3276 void array_rank() { 3277 static_assert(__array_rank(IntAr) == 1); 3278 static_assert(__array_rank(ConstIntArAr) == 2); 3279 } 3280 3281 void array_extent() { 3282 static_assert(__array_extent(IntAr, 0) == 10); 3283 static_assert(__array_extent(ConstIntArAr, 0) == 4); 3284 static_assert(__array_extent(ConstIntArAr, 1) == 10); 3285 } 3286 3287 void is_destructible_test() { 3288 static_assert(__is_destructible(int)); 3289 static_assert(__is_destructible(int[2])); 3290 static_assert(!__is_destructible(int[])); 3291 static_assert(!__is_destructible(void)); 3292 static_assert(__is_destructible(int &)); 3293 static_assert(__is_destructible(HasDest)); 3294 static_assert(!__is_destructible(AllPrivate)); 3295 static_assert(__is_destructible(SuperNonTrivialStruct)); 3296 static_assert(__is_destructible(AllDefaulted)); 3297 static_assert(!__is_destructible(AllDeleted)); 3298 static_assert(__is_destructible(ThrowingDtor)); 3299 static_assert(__is_destructible(NoThrowDtor)); 3300 3301 static_assert(__is_destructible(ACompleteType)); 3302 static_assert(!__is_destructible(AnIncompleteType)); // expected-error {{incomplete type}} 3303 static_assert(!__is_destructible(AnIncompleteType[])); 3304 static_assert(!__is_destructible(AnIncompleteType[1])); // expected-error {{incomplete type}} 3305 static_assert(!__is_destructible(void)); 3306 static_assert(!__is_destructible(const volatile void)); 3307 } 3308 3309 void is_nothrow_destructible_test() { 3310 static_assert(__is_nothrow_destructible(int)); 3311 static_assert(__is_nothrow_destructible(int[2])); 3312 static_assert(!__is_nothrow_destructible(int[])); 3313 static_assert(!__is_nothrow_destructible(void)); 3314 static_assert(__is_nothrow_destructible(int &)); 3315 static_assert(__is_nothrow_destructible(HasDest)); 3316 static_assert(!__is_nothrow_destructible(AllPrivate)); 3317 static_assert(__is_nothrow_destructible(SuperNonTrivialStruct)); 3318 static_assert(__is_nothrow_destructible(AllDefaulted)); 3319 static_assert(!__is_nothrow_destructible(AllDeleted)); 3320 static_assert(!__is_nothrow_destructible(ThrowingDtor)); 3321 static_assert(__is_nothrow_destructible(NoExceptDtor)); 3322 static_assert(__is_nothrow_destructible(NoThrowDtor)); 3323 3324 static_assert(__is_nothrow_destructible(ACompleteType)); 3325 static_assert(!__is_nothrow_destructible(AnIncompleteType)); // expected-error {{incomplete type}} 3326 static_assert(!__is_nothrow_destructible(AnIncompleteType[])); 3327 static_assert(!__is_nothrow_destructible(AnIncompleteType[1])); // expected-error {{incomplete type}} 3328 static_assert(!__is_nothrow_destructible(void)); 3329 static_assert(!__is_nothrow_destructible(const volatile void)); 3330 } 3331 3332 void is_trivially_destructible_test() { 3333 static_assert(__is_trivially_destructible(int)); 3334 static_assert(__is_trivially_destructible(int[2])); 3335 static_assert(!__is_trivially_destructible(int[])); 3336 static_assert(!__is_trivially_destructible(void)); 3337 static_assert(__is_trivially_destructible(int &)); 3338 static_assert(!__is_trivially_destructible(HasDest)); 3339 static_assert(!__is_trivially_destructible(AllPrivate)); 3340 static_assert(!__is_trivially_destructible(SuperNonTrivialStruct)); 3341 static_assert(__is_trivially_destructible(AllDefaulted)); 3342 static_assert(!__is_trivially_destructible(AllDeleted)); 3343 static_assert(!__is_trivially_destructible(ThrowingDtor)); 3344 static_assert(!__is_trivially_destructible(NoThrowDtor)); 3345 3346 static_assert(__is_trivially_destructible(ACompleteType)); 3347 static_assert(!__is_trivially_destructible(AnIncompleteType)); // expected-error {{incomplete type}} 3348 static_assert(!__is_trivially_destructible(AnIncompleteType[])); 3349 static_assert(!__is_trivially_destructible(AnIncompleteType[1])); // expected-error {{incomplete type}} 3350 static_assert(!__is_trivially_destructible(void)); 3351 static_assert(!__is_trivially_destructible(const volatile void)); 3352 } 3353 3354 static_assert(!__has_unique_object_representations(void), "void is never unique"); 3355 static_assert(!__has_unique_object_representations(const void), "void is never unique"); 3356 static_assert(!__has_unique_object_representations(volatile void), "void is never unique"); 3357 static_assert(!__has_unique_object_representations(const volatile void), "void is never unique"); 3358 3359 static_assert(__has_unique_object_representations(int), "integrals are"); 3360 static_assert(__has_unique_object_representations(const int), "integrals are"); 3361 static_assert(__has_unique_object_representations(volatile int), "integrals are"); 3362 static_assert(__has_unique_object_representations(const volatile int), "integrals are"); 3363 3364 static_assert(__has_unique_object_representations(void *), "as are pointers"); 3365 static_assert(__has_unique_object_representations(const void *), "as are pointers"); 3366 static_assert(__has_unique_object_representations(volatile void *), "are pointers"); 3367 static_assert(__has_unique_object_representations(const volatile void *), "as are pointers"); 3368 3369 static_assert(__has_unique_object_representations(int *), "as are pointers"); 3370 static_assert(__has_unique_object_representations(const int *), "as are pointers"); 3371 static_assert(__has_unique_object_representations(volatile int *), "as are pointers"); 3372 static_assert(__has_unique_object_representations(const volatile int *), "as are pointers"); 3373 3374 class C {}; 3375 using FP = int (*)(int); 3376 using PMF = int (C::*)(int); 3377 using PMD = int C::*; 3378 3379 static_assert(__has_unique_object_representations(FP), "even function pointers"); 3380 static_assert(__has_unique_object_representations(const FP), "even function pointers"); 3381 static_assert(__has_unique_object_representations(volatile FP), "even function pointers"); 3382 static_assert(__has_unique_object_representations(const volatile FP), "even function pointers"); 3383 3384 static_assert(__has_unique_object_representations(PMF), "and pointer to members"); 3385 static_assert(__has_unique_object_representations(const PMF), "and pointer to members"); 3386 static_assert(__has_unique_object_representations(volatile PMF), "and pointer to members"); 3387 static_assert(__has_unique_object_representations(const volatile PMF), "and pointer to members"); 3388 3389 static_assert(__has_unique_object_representations(PMD), "and pointer to members"); 3390 static_assert(__has_unique_object_representations(const PMD), "and pointer to members"); 3391 static_assert(__has_unique_object_representations(volatile PMD), "and pointer to members"); 3392 static_assert(__has_unique_object_representations(const volatile PMD), "and pointer to members"); 3393 3394 static_assert(__has_unique_object_representations(bool), "yes, all integral types"); 3395 static_assert(__has_unique_object_representations(char), "yes, all integral types"); 3396 static_assert(__has_unique_object_representations(signed char), "yes, all integral types"); 3397 static_assert(__has_unique_object_representations(unsigned char), "yes, all integral types"); 3398 static_assert(__has_unique_object_representations(short), "yes, all integral types"); 3399 static_assert(__has_unique_object_representations(unsigned short), "yes, all integral types"); 3400 static_assert(__has_unique_object_representations(int), "yes, all integral types"); 3401 static_assert(__has_unique_object_representations(unsigned int), "yes, all integral types"); 3402 static_assert(__has_unique_object_representations(long), "yes, all integral types"); 3403 static_assert(__has_unique_object_representations(unsigned long), "yes, all integral types"); 3404 static_assert(__has_unique_object_representations(long long), "yes, all integral types"); 3405 static_assert(__has_unique_object_representations(unsigned long long), "yes, all integral types"); 3406 static_assert(__has_unique_object_representations(wchar_t), "yes, all integral types"); 3407 static_assert(__has_unique_object_representations(char16_t), "yes, all integral types"); 3408 static_assert(__has_unique_object_representations(char32_t), "yes, all integral types"); 3409 3410 static_assert(!__has_unique_object_representations(void), "but not void!"); 3411 static_assert(!__has_unique_object_representations(decltype(nullptr)), "or nullptr_t"); 3412 static_assert(!__has_unique_object_representations(float), "definitely not Floating Point"); 3413 static_assert(!__has_unique_object_representations(double), "definitely not Floating Point"); 3414 static_assert(!__has_unique_object_representations(long double), "definitely not Floating Point"); 3415 3416 struct NoPadding { 3417 int a; 3418 int b; 3419 }; 3420 3421 static_assert(__has_unique_object_representations(NoPadding), "types without padding are"); 3422 3423 struct InheritsFromNoPadding : NoPadding { 3424 int c; 3425 int d; 3426 }; 3427 3428 static_assert(__has_unique_object_representations(InheritsFromNoPadding), "types without padding are"); 3429 3430 struct VirtuallyInheritsFromNoPadding : virtual NoPadding { 3431 int c; 3432 int d; 3433 }; 3434 3435 static_assert(!__has_unique_object_representations(VirtuallyInheritsFromNoPadding), "No virtual inheritance"); 3436 3437 struct Padding { 3438 char a; 3439 int b; 3440 }; 3441 3442 //static_assert(!__has_unique_object_representations(Padding), "but not with padding"); 3443 3444 struct InheritsFromPadding : Padding { 3445 int c; 3446 int d; 3447 }; 3448 3449 static_assert(!__has_unique_object_representations(InheritsFromPadding), "or its subclasses"); 3450 3451 struct TailPadding { 3452 int a; 3453 char b; 3454 }; 3455 3456 static_assert(!__has_unique_object_representations(TailPadding), "even at the end"); 3457 3458 struct TinyStruct { 3459 char a; 3460 }; 3461 3462 static_assert(__has_unique_object_representations(TinyStruct), "Should be no padding"); 3463 3464 struct InheritsFromTinyStruct : TinyStruct { 3465 int b; 3466 }; 3467 3468 static_assert(!__has_unique_object_representations(InheritsFromTinyStruct), "Inherit causes padding"); 3469 3470 union NoPaddingUnion { 3471 int a; 3472 unsigned int b; 3473 }; 3474 3475 static_assert(__has_unique_object_representations(NoPaddingUnion), "unions follow the same rules as structs"); 3476 3477 union PaddingUnion { 3478 int a; 3479 long long b; 3480 }; 3481 3482 static_assert(!__has_unique_object_representations(PaddingUnion), "unions follow the same rules as structs"); 3483 3484 struct NotTriviallyCopyable { 3485 int x; 3486 NotTriviallyCopyable(const NotTriviallyCopyable &) {} 3487 }; 3488 3489 static_assert(!__has_unique_object_representations(NotTriviallyCopyable), "must be trivially copyable"); 3490 3491 struct HasNonUniqueMember { 3492 float x; 3493 }; 3494 3495 static_assert(!__has_unique_object_representations(HasNonUniqueMember), "all members must be unique"); 3496 3497 enum ExampleEnum { xExample, 3498 yExample }; 3499 enum LLEnum : long long { xLongExample, 3500 yLongExample }; 3501 3502 static_assert(__has_unique_object_representations(ExampleEnum), "Enums are integrals, so unique!"); 3503 static_assert(__has_unique_object_representations(LLEnum), "Enums are integrals, so unique!"); 3504 3505 enum class ExampleEnumClass { xExample, 3506 yExample }; 3507 enum class LLEnumClass : long long { xLongExample, 3508 yLongExample }; 3509 3510 static_assert(__has_unique_object_representations(ExampleEnumClass), "Enums are integrals, so unique!"); 3511 static_assert(__has_unique_object_representations(LLEnumClass), "Enums are integrals, so unique!"); 3512 3513 // because references aren't trivially copyable. 3514 static_assert(!__has_unique_object_representations(int &), "No references!"); 3515 static_assert(!__has_unique_object_representations(const int &), "No references!"); 3516 static_assert(!__has_unique_object_representations(volatile int &), "No references!"); 3517 static_assert(!__has_unique_object_representations(const volatile int &), "No references!"); 3518 static_assert(!__has_unique_object_representations(Empty), "No empty types!"); 3519 static_assert(!__has_unique_object_representations(EmptyUnion), "No empty types!"); 3520 3521 class Compressed : Empty { 3522 int x; 3523 }; 3524 3525 static_assert(__has_unique_object_representations(Compressed), "But inheriting from one is ok"); 3526 3527 class EmptyInheritor : Compressed {}; 3528 3529 static_assert(__has_unique_object_representations(EmptyInheritor), "As long as the base has items, empty is ok"); 3530 3531 class Dynamic { 3532 virtual void A(); 3533 int i; 3534 }; 3535 3536 static_assert(!__has_unique_object_representations(Dynamic), "Dynamic types are not valid"); 3537 3538 class InheritsDynamic : Dynamic { 3539 int j; 3540 }; 3541 3542 static_assert(!__has_unique_object_representations(InheritsDynamic), "Dynamic types are not valid"); 3543 3544 static_assert(__has_unique_object_representations(int[42]), "Arrays are fine, as long as their value type is"); 3545 static_assert(__has_unique_object_representations(int[]), "Arrays are fine, as long as their value type is"); 3546 static_assert(__has_unique_object_representations(int[][42]), "Arrays are fine, as long as their value type is"); 3547 static_assert(!__has_unique_object_representations(double[42]), "So no array of doubles!"); 3548 static_assert(!__has_unique_object_representations(double[]), "So no array of doubles!"); 3549 static_assert(!__has_unique_object_representations(double[][42]), "So no array of doubles!"); 3550 3551 struct __attribute__((aligned(16))) WeirdAlignment { 3552 int i; 3553 }; 3554 union __attribute__((aligned(16))) WeirdAlignmentUnion { 3555 int i; 3556 }; 3557 static_assert(!__has_unique_object_representations(WeirdAlignment), "Alignment causes padding"); 3558 static_assert(!__has_unique_object_representations(WeirdAlignmentUnion), "Alignment causes padding"); 3559 static_assert(!__has_unique_object_representations(WeirdAlignment[42]), "Also no arrays that have padding"); 3560 3561 struct __attribute__((packed)) PackedNoPadding1 { 3562 short i; 3563 int j; 3564 }; 3565 struct __attribute__((packed)) PackedNoPadding2 { 3566 int j; 3567 short i; 3568 }; 3569 static_assert(__has_unique_object_representations(PackedNoPadding1), "Packed structs have no padding"); 3570 static_assert(__has_unique_object_representations(PackedNoPadding2), "Packed structs have no padding"); 3571 3572 static_assert(!__has_unique_object_representations(int(int)), "Functions are not unique"); 3573 static_assert(!__has_unique_object_representations(int(int) const), "Functions are not unique"); 3574 static_assert(!__has_unique_object_representations(int(int) volatile), "Functions are not unique"); 3575 static_assert(!__has_unique_object_representations(int(int) const volatile), "Functions are not unique"); 3576 static_assert(!__has_unique_object_representations(int(int) &), "Functions are not unique"); 3577 static_assert(!__has_unique_object_representations(int(int) const &), "Functions are not unique"); 3578 static_assert(!__has_unique_object_representations(int(int) volatile &), "Functions are not unique"); 3579 static_assert(!__has_unique_object_representations(int(int) const volatile &), "Functions are not unique"); 3580 static_assert(!__has_unique_object_representations(int(int) &&), "Functions are not unique"); 3581 static_assert(!__has_unique_object_representations(int(int) const &&), "Functions are not unique"); 3582 static_assert(!__has_unique_object_representations(int(int) volatile &&), "Functions are not unique"); 3583 static_assert(!__has_unique_object_representations(int(int) const volatile &&), "Functions are not unique"); 3584 3585 static_assert(!__has_unique_object_representations(int(int, ...)), "Functions are not unique"); 3586 static_assert(!__has_unique_object_representations(int(int, ...) const), "Functions are not unique"); 3587 static_assert(!__has_unique_object_representations(int(int, ...) volatile), "Functions are not unique"); 3588 static_assert(!__has_unique_object_representations(int(int, ...) const volatile), "Functions are not unique"); 3589 static_assert(!__has_unique_object_representations(int(int, ...) &), "Functions are not unique"); 3590 static_assert(!__has_unique_object_representations(int(int, ...) const &), "Functions are not unique"); 3591 static_assert(!__has_unique_object_representations(int(int, ...) volatile &), "Functions are not unique"); 3592 static_assert(!__has_unique_object_representations(int(int, ...) const volatile &), "Functions are not unique"); 3593 static_assert(!__has_unique_object_representations(int(int, ...) &&), "Functions are not unique"); 3594 static_assert(!__has_unique_object_representations(int(int, ...) const &&), "Functions are not unique"); 3595 static_assert(!__has_unique_object_representations(int(int, ...) volatile &&), "Functions are not unique"); 3596 static_assert(!__has_unique_object_representations(int(int, ...) const volatile &&), "Functions are not unique"); 3597 3598 void foo(){ 3599 static auto lambda = []() {}; 3600 static_assert(!__has_unique_object_representations(decltype(lambda)), "Lambdas follow struct rules"); 3601 int i; 3602 static auto lambda2 = [i]() {}; 3603 static_assert(__has_unique_object_representations(decltype(lambda2)), "Lambdas follow struct rules"); 3604 } 3605 3606 struct PaddedBitfield { 3607 char c : 6; 3608 char d : 1; 3609 }; 3610 3611 struct UnPaddedBitfield { 3612 char c : 6; 3613 char d : 2; 3614 }; 3615 3616 struct AlignedPaddedBitfield { 3617 char c : 6; 3618 __attribute__((aligned(1))) 3619 char d : 2; 3620 }; 3621 3622 struct UnnamedBitfield { 3623 int named : 8; 3624 int : 24; 3625 }; 3626 3627 struct __attribute__((packed)) UnnamedBitfieldPacked { 3628 int named : 8; 3629 int : 24; 3630 }; 3631 3632 struct UnnamedEmptyBitfield { 3633 int named; 3634 int : 0; 3635 }; 3636 3637 struct UnnamedEmptyBitfieldSplit { 3638 short named; 3639 int : 0; 3640 short also_named; 3641 }; 3642 3643 static_assert(!__has_unique_object_representations(PaddedBitfield), "Bitfield padding"); 3644 static_assert(__has_unique_object_representations(UnPaddedBitfield), "Bitfield padding"); 3645 static_assert(!__has_unique_object_representations(AlignedPaddedBitfield), "Bitfield padding"); 3646 static_assert(!__has_unique_object_representations(UnnamedBitfield), "Bitfield padding"); 3647 static_assert(!__has_unique_object_representations(UnnamedBitfieldPacked), "Bitfield padding"); 3648 static_assert(__has_unique_object_representations(UnnamedEmptyBitfield), "Bitfield padding"); 3649 static_assert(sizeof(UnnamedEmptyBitfieldSplit) != (sizeof(short) * 2), "Wrong size"); 3650 static_assert(!__has_unique_object_representations(UnnamedEmptyBitfieldSplit), "Bitfield padding"); 3651 3652 struct BoolBitfield { 3653 bool b : 8; 3654 }; 3655 3656 static_assert(__has_unique_object_representations(BoolBitfield), "Bitfield bool"); 3657 3658 struct BoolBitfield2 { 3659 bool b : 16; 3660 }; 3661 3662 static_assert(!__has_unique_object_representations(BoolBitfield2), "Bitfield bool"); 3663 3664 struct GreaterSizeBitfield { 3665 //expected-warning@+1 {{width of bit-field 'n'}} 3666 int n : 1024; 3667 }; 3668 3669 static_assert(sizeof(GreaterSizeBitfield) == 128, "Bitfield Size"); 3670 static_assert(!__has_unique_object_representations(GreaterSizeBitfield), "Bitfield padding"); 3671 3672 struct StructWithRef { 3673 int &I; 3674 }; 3675 3676 static_assert(__has_unique_object_representations(StructWithRef), "References are still unique"); 3677 3678 struct NotUniqueBecauseTailPadding { 3679 int &r; 3680 char a; 3681 }; 3682 struct CanBeUniqueIfNoPadding : NotUniqueBecauseTailPadding { 3683 char b[7]; 3684 }; 3685 3686 static_assert(!__has_unique_object_representations(NotUniqueBecauseTailPadding), 3687 "non trivial"); 3688 // Can be unique on Itanium, since the is child class' data is 'folded' into the 3689 // parent's tail padding. 3690 static_assert(sizeof(CanBeUniqueIfNoPadding) != 16 || 3691 __has_unique_object_representations(CanBeUniqueIfNoPadding), 3692 "inherit from std layout"); 3693 3694 namespace ErrorType { 3695 struct S; //expected-note{{forward declaration of 'ErrorType::S'}} 3696 3697 struct T { 3698 S t; //expected-error{{field has incomplete type 'S'}} 3699 }; 3700 bool b = __has_unique_object_representations(T); 3701 }; 3702 3703 static_assert(!__has_unique_object_representations(_BitInt(7)), "BitInt:"); 3704 static_assert(__has_unique_object_representations(_BitInt(8)), "BitInt:"); 3705 static_assert(!__has_unique_object_representations(_BitInt(127)), "BitInt:"); 3706 static_assert(__has_unique_object_representations(_BitInt(128)), "BitInt:"); 3707 3708 namespace GH95311 { 3709 3710 template <int> 3711 class Foo { 3712 int x; 3713 }; 3714 static_assert(__has_unique_object_representations(Foo<0>[])); 3715 class Bar; // expected-note {{forward declaration of 'GH95311::Bar'}} 3716 static_assert(__has_unique_object_representations(Bar[])); // expected-error {{incomplete type}} 3717 3718 } 3719 3720 namespace PR46209 { 3721 // Foo has both a trivial assignment operator and a non-trivial one. 3722 struct Foo { 3723 Foo &operator=(const Foo &) & { return *this; } 3724 Foo &operator=(const Foo &) && = default; 3725 }; 3726 3727 // Bar's copy assignment calls Foo's non-trivial assignment. 3728 struct Bar { 3729 Foo foo; 3730 }; 3731 3732 static_assert(!__is_trivially_assignable(Foo &, const Foo &)); 3733 static_assert(!__is_trivially_assignable(Bar &, const Bar &)); 3734 3735 // Foo2 has both a trivial assignment operator and a non-trivial one. 3736 struct Foo2 { 3737 Foo2 &operator=(const Foo2 &) & = default; 3738 Foo2 &operator=(const Foo2 &) && { return *this; } 3739 }; 3740 3741 // Bar2's copy assignment calls Foo2's trivial assignment. 3742 struct Bar2 { 3743 Foo2 foo; 3744 }; 3745 3746 static_assert(__is_trivially_assignable(Foo2 &, const Foo2 &)); 3747 static_assert(__is_trivially_assignable(Bar2 &, const Bar2 &)); 3748 } 3749 3750 namespace ConstClass { 3751 struct A { 3752 A &operator=(const A&) = default; 3753 }; 3754 struct B { 3755 const A a; 3756 }; 3757 static_assert(!__is_trivially_assignable(B&, const B&)); 3758 } 3759 3760 namespace type_trait_expr_numargs_overflow { 3761 // Make sure that TypeTraitExpr can store 16 bits worth of arguments. 3762 #define T4(X) X,X,X,X 3763 #define T16(X) T4(X),T4(X),T4(X),T4(X) 3764 #define T64(X) T16(X),T16(X),T16(X),T16(X) 3765 #define T256(X) T64(X),T64(X),T64(X),T64(X) 3766 #define T1024(X) T256(X),T256(X),T256(X),T256(X) 3767 #define T4096(X) T1024(X),T1024(X),T1024(X),T1024(X) 3768 #define T16384(X) T4096(X),T4096(X),T4096(X),T4096(X) 3769 #define T32768(X) T16384(X),T16384(X) 3770 void test() { (void) __is_constructible(int, T32768(int)); } 3771 #undef T4 3772 #undef T16 3773 #undef T64 3774 #undef T256 3775 #undef T1024 3776 #undef T4096 3777 #undef T16384 3778 #undef T32768 3779 } // namespace type_trait_expr_numargs_overflow 3780 3781 namespace is_trivially_relocatable { 3782 3783 static_assert(!__is_trivially_relocatable(void)); 3784 static_assert(__is_trivially_relocatable(int)); 3785 static_assert(__is_trivially_relocatable(int[])); 3786 static_assert(__is_trivially_relocatable(const int)); 3787 static_assert(__is_trivially_relocatable(volatile int)); 3788 3789 enum Enum {}; 3790 static_assert(__is_trivially_relocatable(Enum)); 3791 static_assert(__is_trivially_relocatable(Enum[])); 3792 3793 union Union {int x;}; 3794 static_assert(__is_trivially_relocatable(Union)); 3795 static_assert(__is_trivially_relocatable(Union[])); 3796 3797 struct Trivial {}; 3798 static_assert(__is_trivially_relocatable(Trivial)); 3799 static_assert(__is_trivially_relocatable(const Trivial)); 3800 static_assert(__is_trivially_relocatable(volatile Trivial)); 3801 3802 static_assert(__is_trivially_relocatable(Trivial[])); 3803 static_assert(__is_trivially_relocatable(const Trivial[])); 3804 static_assert(__is_trivially_relocatable(volatile Trivial[])); 3805 3806 static_assert(__is_trivially_relocatable(int[10])); 3807 static_assert(__is_trivially_relocatable(const int[10])); 3808 static_assert(__is_trivially_relocatable(volatile int[10])); 3809 3810 static_assert(__is_trivially_relocatable(int[10][10])); 3811 static_assert(__is_trivially_relocatable(const int[10][10])); 3812 static_assert(__is_trivially_relocatable(volatile int[10][10])); 3813 3814 static_assert(__is_trivially_relocatable(int[])); 3815 static_assert(__is_trivially_relocatable(const int[])); 3816 static_assert(__is_trivially_relocatable(volatile int[])); 3817 3818 static_assert(__is_trivially_relocatable(int[][10])); 3819 static_assert(__is_trivially_relocatable(const int[][10])); 3820 static_assert(__is_trivially_relocatable(volatile int[][10])); 3821 3822 struct Incomplete; // expected-note {{forward declaration of 'is_trivially_relocatable::Incomplete'}} 3823 bool unused = __is_trivially_relocatable(Incomplete); // expected-error {{incomplete type}} 3824 3825 struct NontrivialDtor { 3826 ~NontrivialDtor() {} 3827 }; 3828 static_assert(!__is_trivially_relocatable(NontrivialDtor)); 3829 static_assert(!__is_trivially_relocatable(NontrivialDtor[])); 3830 static_assert(!__is_trivially_relocatable(const NontrivialDtor)); 3831 static_assert(!__is_trivially_relocatable(volatile NontrivialDtor)); 3832 3833 struct NontrivialCopyCtor { 3834 NontrivialCopyCtor(const NontrivialCopyCtor&) {} 3835 }; 3836 static_assert(!__is_trivially_relocatable(NontrivialCopyCtor)); 3837 static_assert(!__is_trivially_relocatable(NontrivialCopyCtor[])); 3838 3839 struct NontrivialMoveCtor { 3840 NontrivialMoveCtor(NontrivialMoveCtor&&) {} 3841 }; 3842 static_assert(!__is_trivially_relocatable(NontrivialMoveCtor)); 3843 static_assert(!__is_trivially_relocatable(NontrivialMoveCtor[])); 3844 3845 struct [[clang::trivial_abi]] TrivialAbiNontrivialDtor { 3846 ~TrivialAbiNontrivialDtor() {} 3847 }; 3848 static_assert(__is_trivially_relocatable(TrivialAbiNontrivialDtor)); 3849 static_assert(__is_trivially_relocatable(TrivialAbiNontrivialDtor[])); 3850 static_assert(__is_trivially_relocatable(const TrivialAbiNontrivialDtor)); 3851 static_assert(__is_trivially_relocatable(volatile TrivialAbiNontrivialDtor)); 3852 3853 struct [[clang::trivial_abi]] TrivialAbiNontrivialCopyCtor { 3854 TrivialAbiNontrivialCopyCtor(const TrivialAbiNontrivialCopyCtor&) {} 3855 }; 3856 static_assert(__is_trivially_relocatable(TrivialAbiNontrivialCopyCtor)); 3857 static_assert(__is_trivially_relocatable(TrivialAbiNontrivialCopyCtor[])); 3858 static_assert(__is_trivially_relocatable(const TrivialAbiNontrivialCopyCtor)); 3859 static_assert(__is_trivially_relocatable(volatile TrivialAbiNontrivialCopyCtor)); 3860 3861 // A more complete set of tests for the behavior of trivial_abi can be found in 3862 // clang/test/SemaCXX/attr-trivial-abi.cpp 3863 struct [[clang::trivial_abi]] TrivialAbiNontrivialMoveCtor { 3864 TrivialAbiNontrivialMoveCtor(TrivialAbiNontrivialMoveCtor&&) {} 3865 }; 3866 static_assert(__is_trivially_relocatable(TrivialAbiNontrivialMoveCtor)); 3867 static_assert(__is_trivially_relocatable(TrivialAbiNontrivialMoveCtor[])); 3868 static_assert(__is_trivially_relocatable(const TrivialAbiNontrivialMoveCtor)); 3869 static_assert(__is_trivially_relocatable(volatile TrivialAbiNontrivialMoveCtor)); 3870 3871 } // namespace is_trivially_relocatable 3872 3873 namespace is_trivially_equality_comparable { 3874 struct ForwardDeclared; // expected-note {{forward declaration of 'is_trivially_equality_comparable::ForwardDeclared'}} 3875 static_assert(!__is_trivially_equality_comparable(ForwardDeclared)); // expected-error {{incomplete type 'ForwardDeclared' used in type trait expression}} 3876 3877 static_assert(!__is_trivially_equality_comparable(void)); 3878 static_assert(__is_trivially_equality_comparable(int)); 3879 static_assert(!__is_trivially_equality_comparable(int[])); 3880 static_assert(!__is_trivially_equality_comparable(int[3])); 3881 static_assert(!__is_trivially_equality_comparable(float)); 3882 static_assert(!__is_trivially_equality_comparable(double)); 3883 static_assert(!__is_trivially_equality_comparable(long double)); 3884 3885 struct NonTriviallyEqualityComparableNoComparator { 3886 int i; 3887 int j; 3888 }; 3889 static_assert(!__is_trivially_equality_comparable(NonTriviallyEqualityComparableNoComparator)); 3890 3891 struct NonTriviallyEqualityComparableConvertibleToBuiltin { 3892 int i; 3893 operator unsigned() const; 3894 }; 3895 static_assert(!__is_trivially_equality_comparable(NonTriviallyEqualityComparableConvertibleToBuiltin)); 3896 3897 struct NonTriviallyEqualityComparableNonDefaultedComparator { 3898 int i; 3899 int j; 3900 bool operator==(const NonTriviallyEqualityComparableNonDefaultedComparator&); 3901 }; 3902 static_assert(!__is_trivially_equality_comparable(NonTriviallyEqualityComparableNonDefaultedComparator)); 3903 3904 #if __cplusplus >= 202002L 3905 3906 struct TriviallyEqualityComparable { 3907 int i; 3908 int j; 3909 3910 void func(); 3911 bool operator==(int) const { return false; } 3912 3913 bool operator==(const TriviallyEqualityComparable&) const = default; 3914 }; 3915 static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable)); 3916 3917 struct TriviallyEqualityComparableContainsArray { 3918 int a[4]; 3919 3920 bool operator==(const TriviallyEqualityComparableContainsArray&) const = default; 3921 }; 3922 static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparableContainsArray)); 3923 3924 struct TriviallyEqualityComparableContainsMultiDimensionArray { 3925 int a[4][4]; 3926 3927 bool operator==(const TriviallyEqualityComparableContainsMultiDimensionArray&) const = default; 3928 }; 3929 static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparableContainsMultiDimensionArray)); 3930 3931 auto GetNonCapturingLambda() { return [](){ return 42; }; } 3932 3933 struct TriviallyEqualityComparableContainsLambda { 3934 [[no_unique_address]] decltype(GetNonCapturingLambda()) l; 3935 int i; 3936 3937 bool operator==(const TriviallyEqualityComparableContainsLambda&) const = default; 3938 }; 3939 static_assert(!__is_trivially_equality_comparable(decltype(GetNonCapturingLambda()))); // padding 3940 static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparableContainsLambda)); 3941 3942 struct TriviallyEqualityComparableNonTriviallyCopyable { 3943 TriviallyEqualityComparableNonTriviallyCopyable(const TriviallyEqualityComparableNonTriviallyCopyable&); 3944 ~TriviallyEqualityComparableNonTriviallyCopyable(); 3945 bool operator==(const TriviallyEqualityComparableNonTriviallyCopyable&) const = default; 3946 int i; 3947 }; 3948 static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparableNonTriviallyCopyable)); 3949 3950 struct NotTriviallyEqualityComparableHasPadding { 3951 short i; 3952 int j; 3953 3954 bool operator==(const NotTriviallyEqualityComparableHasPadding&) const = default; 3955 }; 3956 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasPadding)); 3957 3958 struct NotTriviallyEqualityComparableHasFloat { 3959 float i; 3960 int j; 3961 3962 bool operator==(const NotTriviallyEqualityComparableHasFloat&) const = default; 3963 }; 3964 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasFloat)); 3965 3966 struct NotTriviallyEqualityComparableHasTailPadding { 3967 int i; 3968 char j; 3969 3970 bool operator==(const NotTriviallyEqualityComparableHasTailPadding&) const = default; 3971 }; 3972 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasTailPadding)); 3973 3974 struct NotTriviallyEqualityComparableBase : NotTriviallyEqualityComparableHasTailPadding { 3975 char j; 3976 3977 bool operator==(const NotTriviallyEqualityComparableBase&) const = default; 3978 }; 3979 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBase)); 3980 3981 class TriviallyEqualityComparablePaddedOutBase { 3982 int i; 3983 char c; 3984 3985 public: 3986 bool operator==(const TriviallyEqualityComparablePaddedOutBase&) const = default; 3987 }; 3988 static_assert(!__is_trivially_equality_comparable(TriviallyEqualityComparablePaddedOutBase)); 3989 3990 struct TriviallyEqualityComparablePaddedOut : TriviallyEqualityComparablePaddedOutBase { 3991 char j[3]; 3992 3993 bool operator==(const TriviallyEqualityComparablePaddedOut&) const = default; 3994 }; 3995 static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparablePaddedOut)); 3996 3997 struct TriviallyEqualityComparable1 { 3998 char i; 3999 4000 bool operator==(const TriviallyEqualityComparable1&) const = default; 4001 }; 4002 static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable1)); 4003 4004 struct TriviallyEqualityComparable2 { 4005 int i; 4006 4007 bool operator==(const TriviallyEqualityComparable2&) const = default; 4008 }; 4009 static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable2)); 4010 4011 struct NotTriviallyEqualityComparableTriviallyEqualityComparableBases 4012 : TriviallyEqualityComparable1, TriviallyEqualityComparable2 { 4013 bool operator==(const NotTriviallyEqualityComparableTriviallyEqualityComparableBases&) const = default; 4014 }; 4015 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableTriviallyEqualityComparableBases)); 4016 4017 struct NotTriviallyEqualityComparableBitfield { 4018 int i : 1; 4019 4020 bool operator==(const NotTriviallyEqualityComparableBitfield&) const = default; 4021 }; 4022 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBitfield)); 4023 4024 // TODO: This is trivially equality comparable 4025 struct NotTriviallyEqualityComparableBitfieldFilled { 4026 char i : __CHAR_BIT__; 4027 4028 bool operator==(const NotTriviallyEqualityComparableBitfieldFilled&) const = default; 4029 }; 4030 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBitfield)); 4031 4032 union U { 4033 int i; 4034 4035 bool operator==(const U&) const = default; 4036 }; 4037 4038 struct NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion { 4039 U u; 4040 4041 bool operator==(const NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion&) const = default; 4042 }; 4043 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion)); 4044 4045 struct NotTriviallyEqualityComparableExplicitlyDeleted { 4046 int i; 4047 4048 bool operator==(const NotTriviallyEqualityComparableExplicitlyDeleted&) const = delete; 4049 }; 4050 4051 struct NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct { 4052 NotTriviallyEqualityComparableExplicitlyDeleted u; 4053 4054 bool operator==(const NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct&) const = default; 4055 }; 4056 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct)); 4057 4058 struct NotTriviallyEqualityComparableHasReferenceMember { 4059 int& i; 4060 4061 bool operator==(const NotTriviallyEqualityComparableHasReferenceMember&) const = default; 4062 }; 4063 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasReferenceMember)); 4064 4065 struct NotTriviallyEqualityComparableNonTriviallyComparableBaseBase { 4066 int i; 4067 4068 bool operator==(const NotTriviallyEqualityComparableNonTriviallyComparableBaseBase&) const { 4069 return true; 4070 } 4071 }; 4072 4073 struct NotTriviallyEqualityComparableNonTriviallyComparableBase : NotTriviallyEqualityComparableNonTriviallyComparableBaseBase { 4074 int i; 4075 4076 bool operator==(const NotTriviallyEqualityComparableNonTriviallyComparableBase&) const = default; 4077 }; 4078 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableNonTriviallyComparableBase)); 4079 4080 enum E { 4081 a, 4082 b 4083 }; 4084 bool operator==(E, E) { return false; } 4085 static_assert(!__is_trivially_equality_comparable(E)); 4086 4087 struct NotTriviallyEqualityComparableHasEnum { 4088 E e; 4089 bool operator==(const NotTriviallyEqualityComparableHasEnum&) const = default; 4090 }; 4091 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasEnum)); 4092 4093 struct NotTriviallyEqualityComparableNonTriviallyEqualityComparableArrs { 4094 E e[1]; 4095 4096 bool operator==(const NotTriviallyEqualityComparableNonTriviallyEqualityComparableArrs&) const = default; 4097 }; 4098 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableNonTriviallyEqualityComparableArrs)); 4099 4100 struct NotTriviallyEqualityComparableNonTriviallyEqualityComparableArrs2 { 4101 E e[1][1]; 4102 4103 bool operator==(const NotTriviallyEqualityComparableNonTriviallyEqualityComparableArrs2&) const = default; 4104 }; 4105 4106 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableNonTriviallyEqualityComparableArrs2)); 4107 4108 template<bool B> 4109 struct MaybeTriviallyEqualityComparable { 4110 int i; 4111 bool operator==(const MaybeTriviallyEqualityComparable&) const requires B = default; 4112 bool operator==(const MaybeTriviallyEqualityComparable& rhs) const { return (i % 3) == (rhs.i % 3); } 4113 }; 4114 static_assert(__is_trivially_equality_comparable(MaybeTriviallyEqualityComparable<true>)); 4115 static_assert(!__is_trivially_equality_comparable(MaybeTriviallyEqualityComparable<false>)); 4116 4117 struct NotTriviallyEqualityComparableMoreConstrainedExternalOp { 4118 int i; 4119 bool operator==(const NotTriviallyEqualityComparableMoreConstrainedExternalOp&) const = default; 4120 }; 4121 4122 bool operator==(const NotTriviallyEqualityComparableMoreConstrainedExternalOp&, 4123 const NotTriviallyEqualityComparableMoreConstrainedExternalOp&) __attribute__((enable_if(true, ""))) {} 4124 4125 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableMoreConstrainedExternalOp)); 4126 4127 struct TriviallyEqualityComparableExternalDefaultedOp { 4128 int i; 4129 friend bool operator==(TriviallyEqualityComparableExternalDefaultedOp, TriviallyEqualityComparableExternalDefaultedOp); 4130 }; 4131 bool operator==(TriviallyEqualityComparableExternalDefaultedOp, TriviallyEqualityComparableExternalDefaultedOp) = default; 4132 4133 static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparableExternalDefaultedOp)); 4134 4135 struct EqualityComparableBase { 4136 bool operator==(const EqualityComparableBase&) const = default; 4137 }; 4138 4139 struct ComparingBaseOnly : EqualityComparableBase { 4140 int j_ = 0; 4141 }; 4142 static_assert(!__is_trivially_equality_comparable(ComparingBaseOnly)); 4143 4144 template <class> 4145 class Template {}; 4146 4147 // Make sure we don't crash when instantiating a type 4148 static_assert(!__is_trivially_equality_comparable(Template<Template<int>>)); 4149 4150 4151 struct S operator==(S, S); 4152 4153 template <class> struct basic_string_view {}; 4154 4155 struct basic_string { 4156 operator basic_string_view<int>() const; 4157 }; 4158 4159 template <class T> 4160 const bool is_trivially_equality_comparable = __is_trivially_equality_comparable(T); 4161 4162 template <int = is_trivially_equality_comparable<basic_string> > 4163 void find(); 4164 4165 void func() { find(); } 4166 4167 4168 namespace hidden_friend { 4169 4170 struct TriviallyEqualityComparable { 4171 int i; 4172 int j; 4173 4174 void func(); 4175 bool operator==(int) const { return false; } 4176 4177 friend bool operator==(const TriviallyEqualityComparable&, const TriviallyEqualityComparable&) = default; 4178 }; 4179 static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable)); 4180 4181 struct TriviallyEqualityComparableNonTriviallyCopyable { 4182 TriviallyEqualityComparableNonTriviallyCopyable(const TriviallyEqualityComparableNonTriviallyCopyable&); 4183 ~TriviallyEqualityComparableNonTriviallyCopyable(); 4184 friend bool operator==(const TriviallyEqualityComparableNonTriviallyCopyable&, const TriviallyEqualityComparableNonTriviallyCopyable&) = default; 4185 int i; 4186 }; 4187 static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparableNonTriviallyCopyable)); 4188 4189 struct NotTriviallyEqualityComparableHasPadding { 4190 short i; 4191 int j; 4192 4193 friend bool operator==(const NotTriviallyEqualityComparableHasPadding&, const NotTriviallyEqualityComparableHasPadding&) = default; 4194 }; 4195 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasPadding)); 4196 4197 struct NotTriviallyEqualityComparableHasFloat { 4198 float i; 4199 int j; 4200 4201 friend bool operator==(const NotTriviallyEqualityComparableHasFloat&, const NotTriviallyEqualityComparableHasFloat&) = default; 4202 }; 4203 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasFloat)); 4204 4205 struct NotTriviallyEqualityComparableHasTailPadding { 4206 int i; 4207 char j; 4208 4209 friend bool operator==(const NotTriviallyEqualityComparableHasTailPadding&, const NotTriviallyEqualityComparableHasTailPadding&) = default; 4210 }; 4211 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasTailPadding)); 4212 4213 struct NotTriviallyEqualityComparableBase : NotTriviallyEqualityComparableHasTailPadding { 4214 char j; 4215 4216 friend bool operator==(const NotTriviallyEqualityComparableBase&, const NotTriviallyEqualityComparableBase&) = default; 4217 }; 4218 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBase)); 4219 4220 class TriviallyEqualityComparablePaddedOutBase { 4221 int i; 4222 char c; 4223 4224 public: 4225 friend bool operator==(const TriviallyEqualityComparablePaddedOutBase&, const TriviallyEqualityComparablePaddedOutBase&) = default; 4226 }; 4227 static_assert(!__is_trivially_equality_comparable(TriviallyEqualityComparablePaddedOutBase)); 4228 4229 struct TriviallyEqualityComparablePaddedOut : TriviallyEqualityComparablePaddedOutBase { 4230 char j[3]; 4231 4232 friend bool operator==(const TriviallyEqualityComparablePaddedOut&, const TriviallyEqualityComparablePaddedOut&) = default; 4233 }; 4234 static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparablePaddedOut)); 4235 4236 struct TriviallyEqualityComparable1 { 4237 char i; 4238 4239 friend bool operator==(const TriviallyEqualityComparable1&, const TriviallyEqualityComparable1&) = default; 4240 }; 4241 static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable1)); 4242 4243 struct TriviallyEqualityComparable2 { 4244 int i; 4245 4246 friend bool operator==(const TriviallyEqualityComparable2&, const TriviallyEqualityComparable2&) = default; 4247 }; 4248 static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable2)); 4249 4250 struct NotTriviallyEqualityComparableTriviallyEqualityComparableBases 4251 : TriviallyEqualityComparable1, TriviallyEqualityComparable2 { 4252 friend bool operator==(const NotTriviallyEqualityComparableTriviallyEqualityComparableBases&, const NotTriviallyEqualityComparableTriviallyEqualityComparableBases&) = default; 4253 }; 4254 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableTriviallyEqualityComparableBases)); 4255 4256 struct NotTriviallyEqualityComparableBitfield { 4257 int i : 1; 4258 4259 friend bool operator==(const NotTriviallyEqualityComparableBitfield&, const NotTriviallyEqualityComparableBitfield&) = default; 4260 }; 4261 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBitfield)); 4262 4263 // TODO: This is trivially equality comparable 4264 struct NotTriviallyEqualityComparableBitfieldFilled { 4265 char i : __CHAR_BIT__; 4266 4267 friend bool operator==(const NotTriviallyEqualityComparableBitfieldFilled&, const NotTriviallyEqualityComparableBitfieldFilled&) = default; 4268 }; 4269 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBitfield)); 4270 4271 union U { 4272 int i; 4273 4274 friend bool operator==(const U&, const U&) = default; 4275 }; 4276 4277 struct NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion { 4278 U u; 4279 4280 friend bool operator==(const NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion&, const NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion&) = default; 4281 }; 4282 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion)); 4283 4284 struct NotTriviallyEqualityComparableExplicitlyDeleted { 4285 int i; 4286 4287 friend bool operator==(const NotTriviallyEqualityComparableExplicitlyDeleted&, const NotTriviallyEqualityComparableExplicitlyDeleted&) = delete; 4288 }; 4289 4290 struct NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct { 4291 NotTriviallyEqualityComparableExplicitlyDeleted u; 4292 4293 friend bool operator==(const NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct&, const NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct&) = default; 4294 }; 4295 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct)); 4296 4297 struct NotTriviallyEqualityComparableHasReferenceMember { 4298 int& i; 4299 4300 friend bool operator==(const NotTriviallyEqualityComparableHasReferenceMember&, const NotTriviallyEqualityComparableHasReferenceMember&) = default; 4301 }; 4302 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasReferenceMember)); 4303 4304 enum E { 4305 a, 4306 b 4307 }; 4308 bool operator==(E, E) { return false; } 4309 static_assert(!__is_trivially_equality_comparable(E)); 4310 4311 struct NotTriviallyEqualityComparableHasEnum { 4312 E e; 4313 friend bool operator==(const NotTriviallyEqualityComparableHasEnum&, const NotTriviallyEqualityComparableHasEnum&) = default; 4314 }; 4315 static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasEnum)); 4316 4317 struct NonTriviallyEqualityComparableValueComparisonNonTriviallyCopyable { 4318 int i; 4319 NonTriviallyEqualityComparableValueComparisonNonTriviallyCopyable(const NonTriviallyEqualityComparableValueComparisonNonTriviallyCopyable&); 4320 4321 friend bool operator==(NonTriviallyEqualityComparableValueComparisonNonTriviallyCopyable, NonTriviallyEqualityComparableValueComparisonNonTriviallyCopyable) = default; 4322 }; 4323 static_assert(!__is_trivially_equality_comparable(NonTriviallyEqualityComparableValueComparisonNonTriviallyCopyable)); 4324 4325 struct TriviallyEqualityComparableRefComparisonNonTriviallyCopyable { 4326 int i; 4327 TriviallyEqualityComparableRefComparisonNonTriviallyCopyable(const TriviallyEqualityComparableRefComparisonNonTriviallyCopyable&); 4328 4329 friend bool operator==(const TriviallyEqualityComparableRefComparisonNonTriviallyCopyable&, const TriviallyEqualityComparableRefComparisonNonTriviallyCopyable&) = default; 4330 }; 4331 static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparableRefComparisonNonTriviallyCopyable)); 4332 } 4333 4334 #endif // __cplusplus >= 202002L 4335 }; 4336 4337 namespace can_pass_in_regs { 4338 4339 struct A { }; 4340 4341 struct B { 4342 ~B(); 4343 }; 4344 4345 struct C; // expected-note {{forward declaration}} 4346 4347 union D { 4348 int x; 4349 }; 4350 4351 static_assert(__can_pass_in_regs(A)); 4352 static_assert(__can_pass_in_regs(A)); 4353 static_assert(!__can_pass_in_regs(B)); 4354 static_assert(__can_pass_in_regs(D)); 4355 4356 void test_errors() { 4357 (void)__can_pass_in_regs(const A); // expected-error {{not an unqualified class type}} 4358 (void)__can_pass_in_regs(A&); // expected-error {{not an unqualified class type}} 4359 (void)__can_pass_in_regs(A&&); // expected-error {{not an unqualified class type}} 4360 (void)__can_pass_in_regs(const A&); // expected-error {{not an unqualified class type}} 4361 (void)__can_pass_in_regs(C); // expected-error {{incomplete type}} 4362 (void)__can_pass_in_regs(int); // expected-error {{not an unqualified class type}} 4363 (void)__can_pass_in_regs(int&); // expected-error {{not an unqualified class type}} 4364 } 4365 } 4366 4367 struct S {}; 4368 template <class T> using remove_const_t = __remove_const(T); 4369 4370 void check_remove_const() { 4371 static_assert(__is_same(remove_const_t<void>, void)); 4372 static_assert(__is_same(remove_const_t<const void>, void)); 4373 static_assert(__is_same(remove_const_t<int>, int)); 4374 static_assert(__is_same(remove_const_t<const int>, int)); 4375 static_assert(__is_same(remove_const_t<volatile int>, volatile int)); 4376 static_assert(__is_same(remove_const_t<const volatile int>, volatile int)); 4377 static_assert(__is_same(remove_const_t<int *>, int *)); 4378 static_assert(__is_same(remove_const_t<int *const>, int *)); 4379 static_assert(__is_same(remove_const_t<int const *const>, int const *)); 4380 static_assert(__is_same(remove_const_t<int const *const __restrict>, int const *__restrict)); 4381 static_assert(__is_same(remove_const_t<int &>, int &)); 4382 static_assert(__is_same(remove_const_t<int const &>, int const &)); 4383 static_assert(__is_same(remove_const_t<int &&>, int &&)); 4384 static_assert(__is_same(remove_const_t<int const &&>, int const &&)); 4385 static_assert(__is_same(remove_const_t<int()>, int())); 4386 static_assert(__is_same(remove_const_t<int (*const)()>, int (*)())); 4387 static_assert(__is_same(remove_const_t<int (&)()>, int (&)())); 4388 4389 static_assert(__is_same(remove_const_t<S>, S)); 4390 static_assert(__is_same(remove_const_t<const S>, S)); 4391 static_assert(__is_same(remove_const_t<volatile S>, volatile S)); 4392 static_assert(__is_same(remove_const_t<S *__restrict>, S *__restrict)); 4393 static_assert(__is_same(remove_const_t<const volatile S>, volatile S)); 4394 static_assert(__is_same(remove_const_t<S *const volatile __restrict>, S *volatile __restrict)); 4395 static_assert(__is_same(remove_const_t<int S::*const>, int S::*)); 4396 static_assert(__is_same(remove_const_t<int (S::*const)()>, int(S::*)())); 4397 } 4398 4399 template <class T> using remove_restrict_t = __remove_restrict(T); 4400 4401 void check_remove_restrict() { 4402 static_assert(__is_same(remove_restrict_t<void>, void)); 4403 static_assert(__is_same(remove_restrict_t<int>, int)); 4404 static_assert(__is_same(remove_restrict_t<const int>, const int)); 4405 static_assert(__is_same(remove_restrict_t<volatile int>, volatile int)); 4406 static_assert(__is_same(remove_restrict_t<int *__restrict>, int *)); 4407 static_assert(__is_same(remove_restrict_t<int *const volatile __restrict>, int *const volatile)); 4408 static_assert(__is_same(remove_restrict_t<int *>, int *)); 4409 static_assert(__is_same(remove_restrict_t<int *__restrict>, int *)); 4410 static_assert(__is_same(remove_restrict_t<int &>, int &)); 4411 static_assert(__is_same(remove_restrict_t<int &__restrict>, int &)); 4412 static_assert(__is_same(remove_restrict_t<int &&>, int &&)); 4413 static_assert(__is_same(remove_restrict_t<int &&__restrict>, int &&)); 4414 static_assert(__is_same(remove_restrict_t<int()>, int())); 4415 static_assert(__is_same(remove_restrict_t<int (*const volatile)()>, int (*const volatile)())); 4416 static_assert(__is_same(remove_restrict_t<int (&)()>, int (&)())); 4417 4418 static_assert(__is_same(remove_restrict_t<S>, S)); 4419 static_assert(__is_same(remove_restrict_t<const S>, const S)); 4420 static_assert(__is_same(remove_restrict_t<volatile S>, volatile S)); 4421 static_assert(__is_same(remove_restrict_t<S *__restrict>, S *)); 4422 static_assert(__is_same(remove_restrict_t<S *const volatile __restrict>, S *const volatile)); 4423 static_assert(__is_same(remove_restrict_t<int S::*__restrict>, int S::*)); 4424 static_assert(__is_same(remove_restrict_t<int (S::*const volatile)()>, int(S::*const volatile)())); 4425 } 4426 4427 template <class T> using remove_volatile_t = __remove_volatile(T); 4428 4429 void check_remove_volatile() { 4430 static_assert(__is_same(remove_volatile_t<void>, void)); 4431 static_assert(__is_same(remove_volatile_t<volatile void>, void)); 4432 static_assert(__is_same(remove_volatile_t<int>, int)); 4433 static_assert(__is_same(remove_volatile_t<const int>, const int)); 4434 static_assert(__is_same(remove_volatile_t<volatile int>, int)); 4435 static_assert(__is_same(remove_volatile_t<int *__restrict>, int *__restrict)); 4436 static_assert(__is_same(remove_volatile_t<const volatile int>, const int)); 4437 static_assert(__is_same(remove_volatile_t<int *const volatile __restrict>, int *const __restrict)); 4438 static_assert(__is_same(remove_volatile_t<int *>, int *)); 4439 static_assert(__is_same(remove_volatile_t<int *volatile>, int *)); 4440 static_assert(__is_same(remove_volatile_t<int volatile *volatile>, int volatile *)); 4441 static_assert(__is_same(remove_volatile_t<int &>, int &)); 4442 static_assert(__is_same(remove_volatile_t<int volatile &>, int volatile &)); 4443 static_assert(__is_same(remove_volatile_t<int &&>, int &&)); 4444 static_assert(__is_same(remove_volatile_t<int volatile &&>, int volatile &&)); 4445 static_assert(__is_same(remove_volatile_t<int()>, int())); 4446 static_assert(__is_same(remove_volatile_t<int (*volatile)()>, int (*)())); 4447 static_assert(__is_same(remove_volatile_t<int (&)()>, int (&)())); 4448 4449 static_assert(__is_same(remove_volatile_t<S>, S)); 4450 static_assert(__is_same(remove_volatile_t<const S>, const S)); 4451 static_assert(__is_same(remove_volatile_t<volatile S>, S)); 4452 static_assert(__is_same(remove_volatile_t<const volatile S>, const S)); 4453 static_assert(__is_same(remove_volatile_t<int S::*volatile>, int S::*)); 4454 static_assert(__is_same(remove_volatile_t<int (S::*volatile)()>, int(S::*)())); 4455 } 4456 4457 template <class T> using remove_cv_t = __remove_cv(T); 4458 4459 void check_remove_cv() { 4460 static_assert(__is_same(remove_cv_t<void>, void)); 4461 static_assert(__is_same(remove_cv_t<const volatile void>, void)); 4462 static_assert(__is_same(remove_cv_t<int>, int)); 4463 static_assert(__is_same(remove_cv_t<const int>, int)); 4464 static_assert(__is_same(remove_cv_t<volatile int>, int)); 4465 static_assert(__is_same(remove_cv_t<const volatile int>, int)); 4466 static_assert(__is_same(remove_cv_t<int *>, int *)); 4467 static_assert(__is_same(remove_cv_t<int *const volatile>, int *)); 4468 static_assert(__is_same(remove_cv_t<int const *const volatile>, int const *)); 4469 static_assert(__is_same(remove_cv_t<int const *const volatile __restrict>, int const *__restrict)); 4470 static_assert(__is_same(remove_cv_t<int const *const volatile _Nonnull>, int const *_Nonnull)); 4471 static_assert(__is_same(remove_cv_t<int &>, int &)); 4472 static_assert(__is_same(remove_cv_t<int const volatile &>, int const volatile &)); 4473 static_assert(__is_same(remove_cv_t<int &&>, int &&)); 4474 static_assert(__is_same(remove_cv_t<int const volatile &&>, int const volatile &&)); 4475 static_assert(__is_same(remove_cv_t<int()>, int())); 4476 static_assert(__is_same(remove_cv_t<int (*const volatile)()>, int (*)())); 4477 static_assert(__is_same(remove_cv_t<int (&)()>, int (&)())); 4478 4479 static_assert(__is_same(remove_cv_t<S>, S)); 4480 static_assert(__is_same(remove_cv_t<const S>, S)); 4481 static_assert(__is_same(remove_cv_t<volatile S>, S)); 4482 static_assert(__is_same(remove_cv_t<const volatile S>, S)); 4483 static_assert(__is_same(remove_cv_t<int S::*const volatile>, int S::*)); 4484 static_assert(__is_same(remove_cv_t<int (S::*const volatile)()>, int(S::*)())); 4485 } 4486 4487 template <class T> using add_pointer_t = __add_pointer(T); 4488 4489 void add_pointer() { 4490 static_assert(__is_same(add_pointer_t<void>, void *)); 4491 static_assert(__is_same(add_pointer_t<const void>, const void *)); 4492 static_assert(__is_same(add_pointer_t<volatile void>, volatile void *)); 4493 static_assert(__is_same(add_pointer_t<const volatile void>, const volatile void *)); 4494 static_assert(__is_same(add_pointer_t<int>, int *)); 4495 static_assert(__is_same(add_pointer_t<const int>, const int *)); 4496 static_assert(__is_same(add_pointer_t<volatile int>, volatile int *)); 4497 static_assert(__is_same(add_pointer_t<const volatile int>, const volatile int *)); 4498 static_assert(__is_same(add_pointer_t<int *>, int **)); 4499 static_assert(__is_same(add_pointer_t<int &>, int *)); 4500 static_assert(__is_same(add_pointer_t<int &&>, int *)); 4501 static_assert(__is_same(add_pointer_t<int()>, int (*)())); 4502 static_assert(__is_same(add_pointer_t<int (*)()>, int (**)())); 4503 static_assert(__is_same(add_pointer_t<int (&)()>, int (*)())); 4504 4505 static_assert(__is_same(add_pointer_t<S>, S *)); 4506 static_assert(__is_same(add_pointer_t<const S>, const S *)); 4507 static_assert(__is_same(add_pointer_t<volatile S>, volatile S *)); 4508 static_assert(__is_same(add_pointer_t<const volatile S>, const volatile S *)); 4509 static_assert(__is_same(add_pointer_t<int S::*>, int S::**)); 4510 static_assert(__is_same(add_pointer_t<int (S::*)()>, int(S::**)())); 4511 4512 static_assert(__is_same(add_pointer_t<int __attribute__((address_space(1)))>, int __attribute__((address_space(1))) *)); 4513 static_assert(__is_same(add_pointer_t<S __attribute__((address_space(2)))>, S __attribute__((address_space(2))) *)); 4514 } 4515 4516 template <class T> using remove_pointer_t = __remove_pointer(T); 4517 4518 void remove_pointer() { 4519 static_assert(__is_same(remove_pointer_t<void>, void)); 4520 static_assert(__is_same(remove_pointer_t<const void>, const void)); 4521 static_assert(__is_same(remove_pointer_t<volatile void>, volatile void)); 4522 static_assert(__is_same(remove_pointer_t<const volatile void>, const volatile void)); 4523 static_assert(__is_same(remove_pointer_t<int>, int)); 4524 static_assert(__is_same(remove_pointer_t<const int>, const int)); 4525 static_assert(__is_same(remove_pointer_t<volatile int>, volatile int)); 4526 static_assert(__is_same(remove_pointer_t<const volatile int>, const volatile int)); 4527 static_assert(__is_same(remove_pointer_t<int *>, int)); 4528 static_assert(__is_same(remove_pointer_t<const int *>, const int)); 4529 static_assert(__is_same(remove_pointer_t<volatile int *>, volatile int)); 4530 static_assert(__is_same(remove_pointer_t<const volatile int *>, const volatile int)); 4531 static_assert(__is_same(remove_pointer_t<int *const>, int)); 4532 static_assert(__is_same(remove_pointer_t<int *volatile>, int)); 4533 static_assert(__is_same(remove_pointer_t<int *const volatile>, int)); 4534 static_assert(__is_same(remove_pointer_t<int &>, int &)); 4535 static_assert(__is_same(remove_pointer_t<int &&>, int &&)); 4536 static_assert(__is_same(remove_pointer_t<int()>, int())); 4537 static_assert(__is_same(remove_pointer_t<int (*)()>, int())); 4538 static_assert(__is_same(remove_pointer_t<int (&)()>, int (&)())); 4539 4540 static_assert(__is_same(remove_pointer_t<S>, S)); 4541 static_assert(__is_same(remove_pointer_t<const S>, const S)); 4542 static_assert(__is_same(remove_pointer_t<volatile S>, volatile S)); 4543 static_assert(__is_same(remove_pointer_t<const volatile S>, const volatile S)); 4544 static_assert(__is_same(remove_pointer_t<int S::*>, int S::*)); 4545 static_assert(__is_same(remove_pointer_t<int (S::*)()>, int(S::*)())); 4546 4547 static_assert(__is_same(remove_pointer_t<int __attribute__((address_space(1))) *>, int __attribute__((address_space(1))))); 4548 static_assert(__is_same(remove_pointer_t<S __attribute__((address_space(2))) *>, S __attribute__((address_space(2))))); 4549 4550 static_assert(__is_same(remove_pointer_t<int (^)(char)>, int (^)(char))); 4551 } 4552 4553 template <class T> using add_lvalue_reference_t = __add_lvalue_reference(T); 4554 4555 void add_lvalue_reference() { 4556 static_assert(__is_same(add_lvalue_reference_t<void>, void)); 4557 static_assert(__is_same(add_lvalue_reference_t<const void>, const void)); 4558 static_assert(__is_same(add_lvalue_reference_t<volatile void>, volatile void)); 4559 static_assert(__is_same(add_lvalue_reference_t<const volatile void>, const volatile void)); 4560 static_assert(__is_same(add_lvalue_reference_t<int>, int &)); 4561 static_assert(__is_same(add_lvalue_reference_t<const int>, const int &)); 4562 static_assert(__is_same(add_lvalue_reference_t<volatile int>, volatile int &)); 4563 static_assert(__is_same(add_lvalue_reference_t<const volatile int>, const volatile int &)); 4564 static_assert(__is_same(add_lvalue_reference_t<int *>, int *&)); 4565 static_assert(__is_same(add_lvalue_reference_t<int &>, int &)); 4566 static_assert(__is_same(add_lvalue_reference_t<int &&>, int &)); // reference collapsing 4567 static_assert(__is_same(add_lvalue_reference_t<int()>, int (&)())); 4568 static_assert(__is_same(add_lvalue_reference_t<int (*)()>, int (*&)())); 4569 static_assert(__is_same(add_lvalue_reference_t<int (&)()>, int (&)())); 4570 4571 static_assert(__is_same(add_lvalue_reference_t<S>, S &)); 4572 static_assert(__is_same(add_lvalue_reference_t<const S>, const S &)); 4573 static_assert(__is_same(add_lvalue_reference_t<volatile S>, volatile S &)); 4574 static_assert(__is_same(add_lvalue_reference_t<const volatile S>, const volatile S &)); 4575 static_assert(__is_same(add_lvalue_reference_t<int S::*>, int S::*&)); 4576 static_assert(__is_same(add_lvalue_reference_t<int (S::*)()>, int(S::*&)())); 4577 } 4578 4579 template <class T> using add_rvalue_reference_t = __add_rvalue_reference(T); 4580 4581 void add_rvalue_reference() { 4582 static_assert(__is_same(add_rvalue_reference_t<void>, void)); 4583 static_assert(__is_same(add_rvalue_reference_t<const void>, const void)); 4584 static_assert(__is_same(add_rvalue_reference_t<volatile void>, volatile void)); 4585 static_assert(__is_same(add_rvalue_reference_t<const volatile void>, const volatile void)); 4586 static_assert(__is_same(add_rvalue_reference_t<int>, int &&)); 4587 static_assert(__is_same(add_rvalue_reference_t<const int>, const int &&)); 4588 static_assert(__is_same(add_rvalue_reference_t<volatile int>, volatile int &&)); 4589 static_assert(__is_same(add_rvalue_reference_t<const volatile int>, const volatile int &&)); 4590 static_assert(__is_same(add_rvalue_reference_t<int *>, int *&&)); 4591 static_assert(__is_same(add_rvalue_reference_t<int &>, int &)); // reference collapsing 4592 static_assert(__is_same(add_rvalue_reference_t<int &&>, int &&)); 4593 static_assert(__is_same(add_rvalue_reference_t<int()>, int(&&)())); 4594 static_assert(__is_same(add_rvalue_reference_t<int (*)()>, int (*&&)())); 4595 static_assert(__is_same(add_rvalue_reference_t<int (&)()>, int (&)())); // reference collapsing 4596 4597 static_assert(__is_same(add_rvalue_reference_t<S>, S &&)); 4598 static_assert(__is_same(add_rvalue_reference_t<const S>, const S &&)); 4599 static_assert(__is_same(add_rvalue_reference_t<volatile S>, volatile S &&)); 4600 static_assert(__is_same(add_rvalue_reference_t<const volatile S>, const volatile S &&)); 4601 static_assert(__is_same(add_rvalue_reference_t<int S::*>, int S::*&&)); 4602 static_assert(__is_same(add_rvalue_reference_t<int (S::*)()>, int(S::* &&)())); 4603 } 4604 4605 template <class T> using remove_reference_t = __remove_reference_t(T); 4606 4607 void check_remove_reference() { 4608 static_assert(__is_same(remove_reference_t<void>, void)); 4609 static_assert(__is_same(remove_reference_t<const volatile void>, const volatile void)); 4610 static_assert(__is_same(remove_reference_t<int>, int)); 4611 static_assert(__is_same(remove_reference_t<const int>, const int)); 4612 static_assert(__is_same(remove_reference_t<volatile int>, volatile int)); 4613 static_assert(__is_same(remove_reference_t<const volatile int>, const volatile int)); 4614 static_assert(__is_same(remove_reference_t<int *>, int *)); 4615 static_assert(__is_same(remove_reference_t<int *const volatile>, int *const volatile)); 4616 static_assert(__is_same(remove_reference_t<int const *const volatile>, int const *const volatile)); 4617 static_assert(__is_same(remove_reference_t<int &>, int)); 4618 static_assert(__is_same(remove_reference_t<int const volatile &>, int const volatile)); 4619 static_assert(__is_same(remove_reference_t<int &&>, int)); 4620 static_assert(__is_same(remove_reference_t<int const volatile &&>, int const volatile)); 4621 static_assert(__is_same(remove_reference_t<int()>, int())); 4622 static_assert(__is_same(remove_reference_t<int (*const volatile)()>, int (*const volatile)())); 4623 static_assert(__is_same(remove_reference_t<int (&)()>, int())); 4624 4625 static_assert(__is_same(remove_reference_t<S>, S)); 4626 static_assert(__is_same(remove_reference_t<S &>, S)); 4627 static_assert(__is_same(remove_reference_t<S &&>, S)); 4628 static_assert(__is_same(remove_reference_t<const S>, const S)); 4629 static_assert(__is_same(remove_reference_t<const S &>, const S)); 4630 static_assert(__is_same(remove_reference_t<const S &&>, const S)); 4631 static_assert(__is_same(remove_reference_t<volatile S>, volatile S)); 4632 static_assert(__is_same(remove_reference_t<volatile S &>, volatile S)); 4633 static_assert(__is_same(remove_reference_t<volatile S &&>, volatile S)); 4634 static_assert(__is_same(remove_reference_t<const volatile S>, const volatile S)); 4635 static_assert(__is_same(remove_reference_t<const volatile S &>, const volatile S)); 4636 static_assert(__is_same(remove_reference_t<const volatile S &&>, const volatile S)); 4637 static_assert(__is_same(remove_reference_t<int S::*const volatile &>, int S::*const volatile)); 4638 static_assert(__is_same(remove_reference_t<int (S::*const volatile &)()>, int(S::*const volatile)())); 4639 static_assert(__is_same(remove_reference_t<int (S::*const volatile &&)() &>, int(S::*const volatile)() &)); 4640 } 4641 4642 template <class T> using remove_cvref_t = __remove_cvref(T); 4643 4644 void check_remove_cvref() { 4645 static_assert(__is_same(remove_cvref_t<void>, void)); 4646 static_assert(__is_same(remove_cvref_t<const volatile void>, void)); 4647 static_assert(__is_same(remove_cvref_t<int>, int)); 4648 static_assert(__is_same(remove_cvref_t<const int>, int)); 4649 static_assert(__is_same(remove_cvref_t<volatile int>, int)); 4650 static_assert(__is_same(remove_cvref_t<const volatile int>, int)); 4651 static_assert(__is_same(remove_cvref_t<int *>, int *)); 4652 static_assert(__is_same(remove_cvref_t<int *const volatile>, int *)); 4653 static_assert(__is_same(remove_cvref_t<int const *const volatile>, int const *)); 4654 static_assert(__is_same(remove_cvref_t<int const *const volatile __restrict>, int const *__restrict)); 4655 static_assert(__is_same(remove_cvref_t<int const *const volatile _Nonnull>, int const *_Nonnull)); 4656 static_assert(__is_same(remove_cvref_t<int &>, int)); 4657 static_assert(__is_same(remove_cvref_t<int const volatile &>, int)); 4658 static_assert(__is_same(remove_cvref_t<int &&>, int)); 4659 static_assert(__is_same(remove_cvref_t<int const volatile &&>, int)); 4660 static_assert(__is_same(remove_cvref_t<int()>, int())); 4661 static_assert(__is_same(remove_cvref_t<int (*const volatile)()>, int (*)())); 4662 static_assert(__is_same(remove_cvref_t<int (&)()>, int())); 4663 4664 static_assert(__is_same(remove_cvref_t<S>, S)); 4665 static_assert(__is_same(remove_cvref_t<S &>, S)); 4666 static_assert(__is_same(remove_cvref_t<S &&>, S)); 4667 static_assert(__is_same(remove_cvref_t<const S>, S)); 4668 static_assert(__is_same(remove_cvref_t<const S &>, S)); 4669 static_assert(__is_same(remove_cvref_t<const S &&>, S)); 4670 static_assert(__is_same(remove_cvref_t<volatile S>, S)); 4671 static_assert(__is_same(remove_cvref_t<volatile S &>, S)); 4672 static_assert(__is_same(remove_cvref_t<volatile S &&>, S)); 4673 static_assert(__is_same(remove_cvref_t<const volatile S>, S)); 4674 static_assert(__is_same(remove_cvref_t<const volatile S &>, S)); 4675 static_assert(__is_same(remove_cvref_t<const volatile S &&>, S)); 4676 static_assert(__is_same(remove_cvref_t<int S::*const volatile>, int S::*)); 4677 static_assert(__is_same(remove_cvref_t<int (S::*const volatile)()>, int(S::*)())); 4678 static_assert(__is_same(remove_cvref_t<int (S::*const volatile)() &>, int(S::*)() &)); 4679 static_assert(__is_same(remove_cvref_t<int (S::*const volatile)() &&>, int(S::*)() &&)); 4680 } 4681 4682 template <class T> using decay_t = __decay(T); 4683 4684 void check_decay() { 4685 static_assert(__is_same(decay_t<void>, void)); 4686 static_assert(__is_same(decay_t<const volatile void>, void)); 4687 static_assert(__is_same(decay_t<int>, int)); 4688 static_assert(__is_same(decay_t<const int>, int)); 4689 static_assert(__is_same(decay_t<volatile int>, int)); 4690 static_assert(__is_same(decay_t<const volatile int>, int)); 4691 static_assert(__is_same(decay_t<int *>, int *)); 4692 static_assert(__is_same(decay_t<int *const volatile>, int *)); 4693 static_assert(__is_same(decay_t<int *const volatile __restrict>, int *)); 4694 static_assert(__is_same(decay_t<int const *const volatile>, int const *)); 4695 static_assert(__is_same(decay_t<int const *const volatile _Nonnull>, int const *)); 4696 static_assert(__is_same(decay_t<int &>, int)); 4697 static_assert(__is_same(decay_t<int const volatile &>, int)); 4698 static_assert(__is_same(decay_t<int &&>, int)); 4699 static_assert(__is_same(decay_t<int const volatile &&>, int)); 4700 static_assert(__is_same(decay_t<int()>, int (*)())); 4701 static_assert(__is_same(decay_t<int (*)()>, int (*)())); 4702 static_assert(__is_same(decay_t<int (*const)()>, int (*)())); 4703 static_assert(__is_same(decay_t<int (*volatile)()>, int (*)())); 4704 static_assert(__is_same(decay_t<int (*const volatile)()>, int (*)())); 4705 static_assert(__is_same(decay_t<int (&)()>, int (*)())); 4706 static_assert(__is_same(decay_t<IntAr>, int *)); 4707 static_assert(__is_same(decay_t<IntArNB>, int *)); 4708 4709 static_assert(__is_same(decay_t<S>, S)); 4710 static_assert(__is_same(decay_t<S &>, S)); 4711 static_assert(__is_same(decay_t<S &&>, S)); 4712 static_assert(__is_same(decay_t<const S>, S)); 4713 static_assert(__is_same(decay_t<const S &>, S)); 4714 static_assert(__is_same(decay_t<const S &&>, S)); 4715 static_assert(__is_same(decay_t<volatile S>, S)); 4716 static_assert(__is_same(decay_t<volatile S &>, S)); 4717 static_assert(__is_same(decay_t<volatile S &&>, S)); 4718 static_assert(__is_same(decay_t<const volatile S>, S)); 4719 static_assert(__is_same(decay_t<const volatile S &>, S)); 4720 static_assert(__is_same(decay_t<const volatile S &&>, S)); 4721 static_assert(__is_same(decay_t<int S::*const volatile>, int S::*)); 4722 static_assert(__is_same(decay_t<int (S::*const volatile)()>, int(S::*)())); 4723 static_assert(__is_same(decay_t<int S::*const volatile &>, int S::*)); 4724 static_assert(__is_same(decay_t<int (S::*const volatile &)()>, int(S::*)())); 4725 static_assert(__is_same(decay_t<int S::*const volatile &&>, int S::*)); 4726 } 4727 4728 template <class T> struct CheckAbominableFunction {}; 4729 template <class M> 4730 struct CheckAbominableFunction<M S::*> { 4731 static void checks() { 4732 static_assert(__is_same(add_lvalue_reference_t<M>, M)); 4733 static_assert(__is_same(add_pointer_t<M>, M)); 4734 static_assert(__is_same(add_rvalue_reference_t<M>, M)); 4735 static_assert(__is_same(decay_t<M>, M)); 4736 static_assert(__is_same(remove_const_t<M>, M)); 4737 static_assert(__is_same(remove_volatile_t<M>, M)); 4738 static_assert(__is_same(remove_cv_t<M>, M)); 4739 static_assert(__is_same(remove_cvref_t<M>, M)); 4740 static_assert(__is_same(remove_pointer_t<M>, M)); 4741 static_assert(__is_same(remove_reference_t<M>, M)); 4742 4743 static_assert(!__is_referenceable(M)); 4744 } 4745 }; 4746 4747 void check_abominable_function() { 4748 { CheckAbominableFunction<int (S::*)() &> x; } 4749 { CheckAbominableFunction<int (S::*)() &&> x; } 4750 { CheckAbominableFunction<int (S::*)() const> x; } 4751 { CheckAbominableFunction<int (S::*)() const &> x; } 4752 { CheckAbominableFunction<int (S::*)() const &&> x; } 4753 { CheckAbominableFunction<int (S::*)() volatile> x; } 4754 { CheckAbominableFunction<int (S::*)() volatile &> x; } 4755 { CheckAbominableFunction<int (S::*)() volatile &&> x; } 4756 { CheckAbominableFunction<int (S::*)() const volatile> x; } 4757 { CheckAbominableFunction<int (S::*)() const volatile &> x; } 4758 { CheckAbominableFunction<int (S::*)() const volatile &&> x; } 4759 } 4760 4761 template <class T> using make_signed_t = __make_signed(T); 4762 template <class T, class Expected> 4763 void check_make_signed() { 4764 static_assert(__is_same(make_signed_t<T>, Expected)); 4765 static_assert(__is_same(make_signed_t<const T>, const Expected)); 4766 static_assert(__is_same(make_signed_t<volatile T>, volatile Expected)); 4767 static_assert(__is_same(make_signed_t<const volatile T>, const volatile Expected)); 4768 } 4769 4770 #if defined(__ILP32__) || defined(__LLP64__) 4771 using Int64 = long long; 4772 using UInt64 = unsigned long long; 4773 #elif defined(__LP64__) || defined(__ILP64__) || defined(__SILP64__) 4774 using Int64 = long; 4775 using UInt64 = unsigned long; 4776 #else 4777 #error Programming model currently unsupported; please add a new entry. 4778 #endif 4779 4780 enum UnscopedBool : bool {}; // deliberately char 4781 enum class ScopedBool : bool {}; // deliberately char 4782 enum UnscopedChar : char {}; // deliberately char 4783 enum class ScopedChar : char {}; // deliberately char 4784 enum UnscopedUChar : unsigned char {}; 4785 enum class ScopedUChar : unsigned char {}; 4786 enum UnscopedLongLong : long long {}; 4787 enum UnscopedULongLong : unsigned long long {}; 4788 enum class ScopedLongLong : long long {}; 4789 enum class ScopedULongLong : unsigned long long {}; 4790 enum class UnscopedInt128 : __int128 {}; 4791 enum class ScopedInt128 : __int128 {}; 4792 enum class UnscopedUInt128 : unsigned __int128 {}; 4793 enum class ScopedUInt128 : unsigned __int128 {}; 4794 4795 void make_signed() { 4796 check_make_signed<char, signed char>(); 4797 check_make_signed<signed char, signed char>(); 4798 check_make_signed<unsigned char, signed char>(); 4799 check_make_signed<short, short>(); 4800 check_make_signed<unsigned short, short>(); 4801 check_make_signed<int, int>(); 4802 check_make_signed<unsigned int, int>(); 4803 check_make_signed<long, long>(); 4804 check_make_signed<unsigned long, long>(); 4805 check_make_signed<long long, long long>(); 4806 check_make_signed<unsigned long long, long long>(); 4807 check_make_signed<__int128, __int128>(); 4808 check_make_signed<__uint128_t, __int128>(); 4809 check_make_signed<_BitInt(65), _BitInt(65)>(); 4810 check_make_signed<unsigned _BitInt(65), _BitInt(65)>(); 4811 4812 check_make_signed<wchar_t, int>(); 4813 #if __cplusplus >= 202002L 4814 check_make_signed<char8_t, signed char>(); 4815 #endif 4816 #if __cplusplus >= 201103L 4817 check_make_signed<char16_t, short>(); 4818 check_make_signed<char32_t, int>(); 4819 #endif 4820 4821 check_make_signed<UnscopedChar, signed char>(); 4822 check_make_signed<ScopedChar, signed char>(); 4823 check_make_signed<UnscopedUChar, signed char>(); 4824 check_make_signed<ScopedUChar, signed char>(); 4825 4826 check_make_signed<UnscopedLongLong, Int64>(); 4827 check_make_signed<UnscopedULongLong, Int64>(); 4828 check_make_signed<ScopedLongLong, Int64>(); 4829 check_make_signed<ScopedULongLong, Int64>(); 4830 4831 check_make_signed<UnscopedInt128, __int128>(); 4832 check_make_signed<ScopedInt128, __int128>(); 4833 check_make_signed<UnscopedUInt128, __int128>(); 4834 check_make_signed<ScopedUInt128, __int128>(); 4835 4836 { using ExpectedError = __make_signed(bool); } 4837 // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'bool'}} 4838 { using ExpectedError = __make_signed(UnscopedBool); } 4839 // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'UnscopedBool' whose underlying type is 'bool'}} 4840 { using ExpectedError = __make_signed(ScopedBool); } 4841 // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'ScopedBool' whose underlying type is 'bool'}} 4842 { using ExpectedError = __make_signed(unsigned _BitInt(1)); } 4843 // expected-error@*:*{{'make_signed' is only compatible with non-_BitInt(1) integers and enum types, but was given 'unsigned _BitInt(1)'}} 4844 { using ExpectedError = __make_signed(int[]); } 4845 // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int[]'}} 4846 { using ExpectedError = __make_signed(int[5]); } 4847 // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int[5]'}} 4848 { using ExpectedError = __make_signed(void); } 4849 // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'void'}} 4850 { using ExpectedError = __make_signed(int *); } 4851 // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int *'}} 4852 { using ExpectedError = __make_signed(int &); } 4853 // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int &'}} 4854 { using ExpectedError = __make_signed(int &&); } 4855 // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int &&'}} 4856 { using ExpectedError = __make_signed(float); } 4857 // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'float'}} 4858 { using ExpectedError = __make_signed(double); } 4859 // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'double'}} 4860 { using ExpectedError = __make_signed(long double); } 4861 // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'long double'}} 4862 { using ExpectedError = __make_signed(S); } 4863 // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'S'}} 4864 { using ExpectedError = __make_signed(S *); } 4865 // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'S *'}} 4866 { using ExpectedError = __make_signed(int S::*); } 4867 // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int S::*'}} 4868 { using ExpectedError = __make_signed(int(S::*)()); } 4869 // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int (S::*)()'}} 4870 } 4871 4872 template <class T> 4873 using make_unsigned_t = __make_unsigned(T); 4874 4875 template <class T, class Expected> 4876 void check_make_unsigned() { 4877 static_assert(__is_same(make_unsigned_t<T>, Expected)); 4878 static_assert(__is_same(make_unsigned_t<const T>, const Expected)); 4879 static_assert(__is_same(make_unsigned_t<volatile T>, volatile Expected)); 4880 static_assert(__is_same(make_unsigned_t<const volatile T>, const volatile Expected)); 4881 } 4882 4883 void make_unsigned() { 4884 check_make_unsigned<char, unsigned char>(); 4885 check_make_unsigned<signed char, unsigned char>(); 4886 check_make_unsigned<unsigned char, unsigned char>(); 4887 check_make_unsigned<short, unsigned short>(); 4888 check_make_unsigned<unsigned short, unsigned short>(); 4889 check_make_unsigned<int, unsigned int>(); 4890 check_make_unsigned<unsigned int, unsigned int>(); 4891 check_make_unsigned<long, unsigned long>(); 4892 check_make_unsigned<unsigned long, unsigned long>(); 4893 check_make_unsigned<long long, unsigned long long>(); 4894 check_make_unsigned<unsigned long long, unsigned long long>(); 4895 check_make_unsigned<__int128, __uint128_t>(); 4896 check_make_unsigned<__uint128_t, __uint128_t>(); 4897 check_make_unsigned<_BitInt(65), unsigned _BitInt(65)>(); 4898 check_make_unsigned<unsigned _BitInt(65), unsigned _BitInt(65)>(); 4899 4900 check_make_unsigned<wchar_t, unsigned int>(); 4901 #if __cplusplus >= 202002L 4902 check_make_unsigned<char8_t, unsigned char>(); 4903 #endif 4904 #if __cplusplus >= 201103L 4905 check_make_unsigned<char16_t, unsigned short>(); 4906 check_make_unsigned<char32_t, unsigned int>(); 4907 #endif 4908 4909 check_make_unsigned<UnscopedChar, unsigned char>(); 4910 check_make_unsigned<ScopedChar, unsigned char>(); 4911 check_make_unsigned<UnscopedUChar, unsigned char>(); 4912 check_make_unsigned<ScopedUChar, unsigned char>(); 4913 4914 check_make_unsigned<UnscopedLongLong, UInt64>(); 4915 check_make_unsigned<UnscopedULongLong, UInt64>(); 4916 check_make_unsigned<ScopedLongLong, UInt64>(); 4917 check_make_unsigned<ScopedULongLong, UInt64>(); 4918 4919 check_make_unsigned<UnscopedInt128, unsigned __int128>(); 4920 check_make_unsigned<ScopedInt128, unsigned __int128>(); 4921 check_make_unsigned<UnscopedUInt128, unsigned __int128>(); 4922 check_make_unsigned<ScopedUInt128, unsigned __int128>(); 4923 4924 { using ExpectedError = __make_unsigned(bool); } 4925 // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'bool'}} 4926 { using ExpectedError = __make_unsigned(UnscopedBool); } 4927 // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'UnscopedBool' whose underlying type is 'bool'}} 4928 { using ExpectedError = __make_unsigned(ScopedBool); } 4929 // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'ScopedBool' whose underlying type is 'bool'}} 4930 { using ExpectedError = __make_unsigned(unsigned _BitInt(1)); } 4931 // expected-error@*:*{{'make_unsigned' is only compatible with non-_BitInt(1) integers and enum types, but was given 'unsigned _BitInt(1)'}} 4932 { using ExpectedError = __make_unsigned(int[]); } 4933 // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int[]'}} 4934 { using ExpectedError = __make_unsigned(int[5]); } 4935 // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int[5]'}} 4936 { using ExpectedError = __make_unsigned(void); } 4937 // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'void'}} 4938 { using ExpectedError = __make_unsigned(int *); } 4939 // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int *'}} 4940 { using ExpectedError = __make_unsigned(int &); } 4941 // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int &'}} 4942 { using ExpectedError = __make_unsigned(int &&); } 4943 // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int &&'}} 4944 { using ExpectedError = __make_unsigned(float); } 4945 // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'float'}} 4946 { using ExpectedError = __make_unsigned(double); } 4947 // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'double'}} 4948 { using ExpectedError = __make_unsigned(long double); } 4949 // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'long double'}} 4950 { using ExpectedError = __make_unsigned(S); } 4951 // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'S'}} 4952 { using ExpectedError = __make_unsigned(S *); } 4953 // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'S *'}} 4954 { using ExpectedError = __make_unsigned(int S::*); } 4955 // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int S::*'}} 4956 { using ExpectedError = __make_unsigned(int(S::*)()); } 4957 // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int (S::*)()'}} 4958 } 4959 4960 template <class T> using remove_extent_t = __remove_extent(T); 4961 4962 void remove_extent() { 4963 static_assert(__is_same(remove_extent_t<void>, void)); 4964 static_assert(__is_same(remove_extent_t<int>, int)); 4965 static_assert(__is_same(remove_extent_t<int[]>, int)); 4966 static_assert(__is_same(remove_extent_t<int[1]>, int)); 4967 static_assert(__is_same(remove_extent_t<int[1][2]>, int[2])); 4968 static_assert(__is_same(remove_extent_t<int[][2]>, int[2])); 4969 static_assert(__is_same(remove_extent_t<const int[]>, const int)); 4970 static_assert(__is_same(remove_extent_t<const int[1]>, const int)); 4971 static_assert(__is_same(remove_extent_t<const int[1][2]>, const int[2])); 4972 static_assert(__is_same(remove_extent_t<const int[][2]>, const int[2])); 4973 static_assert(__is_same(remove_extent_t<volatile int[]>, volatile int)); 4974 static_assert(__is_same(remove_extent_t<volatile int[1]>, volatile int)); 4975 static_assert(__is_same(remove_extent_t<volatile int[1][2]>, volatile int[2])); 4976 static_assert(__is_same(remove_extent_t<volatile int[][2]>, volatile int[2])); 4977 static_assert(__is_same(remove_extent_t<const volatile int[]>, const volatile int)); 4978 static_assert(__is_same(remove_extent_t<const volatile int[1]>, const volatile int)); 4979 static_assert(__is_same(remove_extent_t<const volatile int[1][2]>, const volatile int[2])); 4980 static_assert(__is_same(remove_extent_t<const volatile int[][2]>, const volatile int[2])); 4981 static_assert(__is_same(remove_extent_t<int *>, int *)); 4982 static_assert(__is_same(remove_extent_t<int &>, int &)); 4983 static_assert(__is_same(remove_extent_t<int &&>, int &&)); 4984 static_assert(__is_same(remove_extent_t<int()>, int())); 4985 static_assert(__is_same(remove_extent_t<int (*)()>, int (*)())); 4986 static_assert(__is_same(remove_extent_t<int (&)()>, int (&)())); 4987 4988 static_assert(__is_same(remove_extent_t<S>, S)); 4989 static_assert(__is_same(remove_extent_t<int S::*>, int S::*)); 4990 static_assert(__is_same(remove_extent_t<int (S::*)()>, int(S::*)())); 4991 4992 using SomeArray = int[1][2]; 4993 static_assert(__is_same(remove_extent_t<const SomeArray>, const int[2])); 4994 } 4995 4996 template <class T> using remove_all_extents_t = __remove_all_extents(T); 4997 4998 void remove_all_extents() { 4999 static_assert(__is_same(remove_all_extents_t<void>, void)); 5000 static_assert(__is_same(remove_all_extents_t<int>, int)); 5001 static_assert(__is_same(remove_all_extents_t<const int>, const int)); 5002 static_assert(__is_same(remove_all_extents_t<volatile int>, volatile int)); 5003 static_assert(__is_same(remove_all_extents_t<const volatile int>, const volatile int)); 5004 static_assert(__is_same(remove_all_extents_t<int[]>, int)); 5005 static_assert(__is_same(remove_all_extents_t<int[1]>, int)); 5006 static_assert(__is_same(remove_all_extents_t<int[1][2]>, int)); 5007 static_assert(__is_same(remove_all_extents_t<int[][2]>, int)); 5008 static_assert(__is_same(remove_all_extents_t<const int[]>, const int)); 5009 static_assert(__is_same(remove_all_extents_t<const int[1]>, const int)); 5010 static_assert(__is_same(remove_all_extents_t<const int[1][2]>, const int)); 5011 static_assert(__is_same(remove_all_extents_t<const int[][2]>, const int)); 5012 static_assert(__is_same(remove_all_extents_t<volatile int[]>, volatile int)); 5013 static_assert(__is_same(remove_all_extents_t<volatile int[1]>, volatile int)); 5014 static_assert(__is_same(remove_all_extents_t<volatile int[1][2]>, volatile int)); 5015 static_assert(__is_same(remove_all_extents_t<volatile int[][2]>, volatile int)); 5016 static_assert(__is_same(remove_all_extents_t<const volatile int[]>, const volatile int)); 5017 static_assert(__is_same(remove_all_extents_t<const volatile int[1]>, const volatile int)); 5018 static_assert(__is_same(remove_all_extents_t<const volatile int[1][2]>, const volatile int)); 5019 static_assert(__is_same(remove_all_extents_t<const volatile int[][2]>, const volatile int)); 5020 static_assert(__is_same(remove_all_extents_t<int *>, int *)); 5021 static_assert(__is_same(remove_all_extents_t<int &>, int &)); 5022 static_assert(__is_same(remove_all_extents_t<int &&>, int &&)); 5023 static_assert(__is_same(remove_all_extents_t<int()>, int())); 5024 static_assert(__is_same(remove_all_extents_t<int (*)()>, int (*)())); 5025 static_assert(__is_same(remove_all_extents_t<int (&)()>, int (&)())); 5026 5027 static_assert(__is_same(remove_all_extents_t<S>, S)); 5028 static_assert(__is_same(remove_all_extents_t<int S::*>, int S::*)); 5029 static_assert(__is_same(remove_all_extents_t<int (S::*)()>, int(S::*)())); 5030 5031 using SomeArray = int[1][2]; 5032 static_assert(__is_same(remove_all_extents_t<const SomeArray>, const int)); 5033 } 5034 5035 namespace GH121278 { 5036 // https://cplusplus.github.io/LWG/lwg-active.html#3929 5037 #if __cplusplus >= 202002L 5038 template <typename B, typename D> 5039 concept C = __is_base_of(B, D); 5040 // expected-error@-1 {{incomplete type 'GH121278::S' used in type trait expression}} 5041 // expected-note@-2 {{while substituting template arguments into constraint expression here}} 5042 5043 struct T; 5044 struct S; 5045 bool b = C<T, S>; 5046 // expected-note@-1 {{while checking the satisfaction of concept 'C<GH121278::T, GH121278::S>' requested here}} 5047 #endif 5048 } 5049