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