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