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