1 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 %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 HasDest { ~HasDest(); }; 43 class HasPriv { int priv; }; 44 class HasProt { protected: int prot; }; 45 struct HasRef { int i; int& ref; HasRef() : i(0), ref(i) {} }; 46 struct HasNonPOD { NonPOD np; }; 47 struct HasVirt { virtual void Virt() {}; }; 48 typedef NonPOD NonPODAr[10]; 49 typedef HasVirt VirtAr[10]; 50 typedef NonPOD NonPODArNB[]; 51 union NonPODUnion { int i; Derives n; }; 52 struct DerivesHasCons : HasCons {}; 53 struct DerivesHasCopyAssign : HasCopyAssign {}; 54 struct DerivesHasMoveAssign : HasMoveAssign {}; 55 struct DerivesHasDest : HasDest {}; 56 struct DerivesHasPriv : HasPriv {}; 57 struct DerivesHasProt : HasProt {}; 58 struct DerivesHasRef : HasRef {}; 59 struct DerivesHasVirt : HasVirt {}; 60 61 struct HasNoThrowCopyAssign { 62 void operator =(const HasNoThrowCopyAssign&) throw(); 63 }; 64 struct HasMultipleCopyAssign { 65 void operator =(const HasMultipleCopyAssign&) throw(); 66 void operator =(volatile HasMultipleCopyAssign&); 67 }; 68 struct HasMultipleNoThrowCopyAssign { 69 void operator =(const HasMultipleNoThrowCopyAssign&) throw(); 70 void operator =(volatile HasMultipleNoThrowCopyAssign&) throw(); 71 }; 72 73 struct HasNoThrowConstructor { HasNoThrowConstructor() throw(); }; 74 struct HasNoThrowConstructorWithArgs { 75 HasNoThrowConstructorWithArgs(HasCons i = HasCons(0)) throw(); 76 }; 77 78 struct HasNoThrowCopy { HasNoThrowCopy(const HasNoThrowCopy&) throw(); }; 79 struct HasMultipleCopy { 80 HasMultipleCopy(const HasMultipleCopy&) throw(); 81 HasMultipleCopy(volatile HasMultipleCopy&); 82 }; 83 struct HasMultipleNoThrowCopy { 84 HasMultipleNoThrowCopy(const HasMultipleNoThrowCopy&) throw(); 85 HasMultipleNoThrowCopy(volatile HasMultipleNoThrowCopy&) throw(); 86 }; 87 88 struct HasVirtDest { virtual ~HasVirtDest(); }; 89 struct DerivedVirtDest : HasVirtDest {}; 90 typedef HasVirtDest VirtDestAr[1]; 91 92 class AllPrivate { 93 AllPrivate() throw(); 94 AllPrivate(const AllPrivate&) throw(); 95 AllPrivate &operator=(const AllPrivate &) throw(); 96 ~AllPrivate() throw(); 97 }; 98 99 void is_pod() 100 { 101 { int arr[T(__is_pod(int))]; } 102 { int arr[T(__is_pod(Enum))]; } 103 { int arr[T(__is_pod(POD))]; } 104 { int arr[T(__is_pod(Int))]; } 105 { int arr[T(__is_pod(IntAr))]; } 106 { int arr[T(__is_pod(Statics))]; } 107 { int arr[T(__is_pod(Empty))]; } 108 { int arr[T(__is_pod(EmptyUnion))]; } 109 { int arr[T(__is_pod(Union))]; } 110 { int arr[T(__is_pod(HasFunc))]; } 111 { int arr[T(__is_pod(HasOp))]; } 112 { int arr[T(__is_pod(HasConv))]; } 113 { int arr[T(__is_pod(HasAssign))]; } 114 { int arr[T(__is_pod(IntArNB))]; } 115 { int arr[T(__is_pod(HasAnonymousUnion))]; } 116 { int arr[T(__is_pod(Vector))]; } 117 { int arr[T(__is_pod(VectorExt))]; } 118 119 { int arr[F(__is_pod(Derives))]; } 120 { int arr[F(__is_pod(DerivesAr))]; } 121 { int arr[F(__is_pod(DerivesArNB))]; } 122 { int arr[F(__is_pod(DerivesEmpty))]; } 123 { int arr[F(__is_pod(HasCons))]; } 124 { int arr[F(__is_pod(HasCopyAssign))]; } 125 { int arr[F(__is_pod(HasMoveAssign))]; } 126 { int arr[F(__is_pod(HasDest))]; } 127 { int arr[F(__is_pod(HasPriv))]; } 128 { int arr[F(__is_pod(HasProt))]; } 129 { int arr[F(__is_pod(HasRef))]; } 130 { int arr[F(__is_pod(HasVirt))]; } 131 { int arr[F(__is_pod(DerivesHasCons))]; } 132 { int arr[F(__is_pod(DerivesHasCopyAssign))]; } 133 { int arr[F(__is_pod(DerivesHasMoveAssign))]; } 134 { int arr[F(__is_pod(DerivesHasDest))]; } 135 { int arr[F(__is_pod(DerivesHasPriv))]; } 136 { int arr[F(__is_pod(DerivesHasProt))]; } 137 { int arr[F(__is_pod(DerivesHasRef))]; } 138 { int arr[F(__is_pod(DerivesHasVirt))]; } 139 { int arr[F(__is_pod(NonPOD))]; } 140 { int arr[F(__is_pod(HasNonPOD))]; } 141 { int arr[F(__is_pod(NonPODAr))]; } 142 { int arr[F(__is_pod(NonPODArNB))]; } 143 { int arr[F(__is_pod(void))]; } 144 { int arr[F(__is_pod(cvoid))]; } 145 // { int arr[F(__is_pod(NonPODUnion))]; } 146 } 147 148 typedef Empty EmptyAr[10]; 149 struct Bit0 { int : 0; }; 150 struct Bit0Cons { int : 0; Bit0Cons(); }; 151 struct BitOnly { int x : 3; }; 152 //struct DerivesVirt : virtual POD {}; 153 154 void is_empty() 155 { 156 { int arr[T(__is_empty(Empty))]; } 157 { int arr[T(__is_empty(DerivesEmpty))]; } 158 { int arr[T(__is_empty(HasCons))]; } 159 { int arr[T(__is_empty(HasCopyAssign))]; } 160 { int arr[T(__is_empty(HasMoveAssign))]; } 161 { int arr[T(__is_empty(HasDest))]; } 162 { int arr[T(__is_empty(HasFunc))]; } 163 { int arr[T(__is_empty(HasOp))]; } 164 { int arr[T(__is_empty(HasConv))]; } 165 { int arr[T(__is_empty(HasAssign))]; } 166 { int arr[T(__is_empty(Bit0))]; } 167 { int arr[T(__is_empty(Bit0Cons))]; } 168 169 { int arr[F(__is_empty(Int))]; } 170 { int arr[F(__is_empty(POD))]; } 171 { int arr[F(__is_empty(EmptyUnion))]; } 172 { int arr[F(__is_empty(EmptyAr))]; } 173 { int arr[F(__is_empty(HasRef))]; } 174 { int arr[F(__is_empty(HasVirt))]; } 175 { int arr[F(__is_empty(BitOnly))]; } 176 { int arr[F(__is_empty(void))]; } 177 { int arr[F(__is_empty(IntArNB))]; } 178 { int arr[F(__is_empty(HasAnonymousUnion))]; } 179 // { int arr[F(__is_empty(DerivesVirt))]; } 180 } 181 182 typedef Derives ClassType; 183 184 void is_class() 185 { 186 { int arr[T(__is_class(Derives))]; } 187 { int arr[T(__is_class(HasPriv))]; } 188 { int arr[T(__is_class(ClassType))]; } 189 { int arr[T(__is_class(HasAnonymousUnion))]; } 190 191 { int arr[F(__is_class(int))]; } 192 { int arr[F(__is_class(Enum))]; } 193 { int arr[F(__is_class(Int))]; } 194 { int arr[F(__is_class(IntAr))]; } 195 { int arr[F(__is_class(DerivesAr))]; } 196 { int arr[F(__is_class(Union))]; } 197 { int arr[F(__is_class(cvoid))]; } 198 { int arr[F(__is_class(IntArNB))]; } 199 } 200 201 typedef Union UnionAr[10]; 202 typedef Union UnionType; 203 204 void is_union() 205 { 206 { int arr[T(__is_union(Union))]; } 207 { int arr[T(__is_union(UnionType))]; } 208 209 { int arr[F(__is_union(int))]; } 210 { int arr[F(__is_union(Enum))]; } 211 { int arr[F(__is_union(Int))]; } 212 { int arr[F(__is_union(IntAr))]; } 213 { int arr[F(__is_union(UnionAr))]; } 214 { int arr[F(__is_union(cvoid))]; } 215 { int arr[F(__is_union(IntArNB))]; } 216 { int arr[F(__is_union(HasAnonymousUnion))]; } 217 } 218 219 typedef Enum EnumType; 220 221 void is_enum() 222 { 223 { int arr[T(__is_enum(Enum))]; } 224 { int arr[T(__is_enum(EnumType))]; } 225 226 { int arr[F(__is_enum(int))]; } 227 { int arr[F(__is_enum(Union))]; } 228 { int arr[F(__is_enum(Int))]; } 229 { int arr[F(__is_enum(IntAr))]; } 230 { int arr[F(__is_enum(UnionAr))]; } 231 { int arr[F(__is_enum(Derives))]; } 232 { int arr[F(__is_enum(ClassType))]; } 233 { int arr[F(__is_enum(cvoid))]; } 234 { int arr[F(__is_enum(IntArNB))]; } 235 { int arr[F(__is_enum(HasAnonymousUnion))]; } 236 } 237 238 typedef HasVirt Polymorph; 239 struct InheritPolymorph : Polymorph {}; 240 241 void is_polymorphic() 242 { 243 { int arr[T(__is_polymorphic(Polymorph))]; } 244 { int arr[T(__is_polymorphic(InheritPolymorph))]; } 245 246 { int arr[F(__is_polymorphic(int))]; } 247 { int arr[F(__is_polymorphic(Union))]; } 248 { int arr[F(__is_polymorphic(Int))]; } 249 { int arr[F(__is_polymorphic(IntAr))]; } 250 { int arr[F(__is_polymorphic(UnionAr))]; } 251 { int arr[F(__is_polymorphic(Derives))]; } 252 { int arr[F(__is_polymorphic(ClassType))]; } 253 { int arr[F(__is_polymorphic(Enum))]; } 254 { int arr[F(__is_polymorphic(cvoid))]; } 255 { int arr[F(__is_polymorphic(IntArNB))]; } 256 } 257 258 void is_integral() 259 { 260 int t01[T(__is_integral(bool))]; 261 int t02[T(__is_integral(char))]; 262 int t03[T(__is_integral(signed char))]; 263 int t04[T(__is_integral(unsigned char))]; 264 //int t05[T(__is_integral(char16_t))]; 265 //int t06[T(__is_integral(char32_t))]; 266 int t07[T(__is_integral(wchar_t))]; 267 int t08[T(__is_integral(short))]; 268 int t09[T(__is_integral(unsigned short))]; 269 int t10[T(__is_integral(int))]; 270 int t11[T(__is_integral(unsigned int))]; 271 int t12[T(__is_integral(long))]; 272 int t13[T(__is_integral(unsigned long))]; 273 274 int t21[F(__is_integral(float))]; 275 int t22[F(__is_integral(double))]; 276 int t23[F(__is_integral(long double))]; 277 int t24[F(__is_integral(Union))]; 278 int t25[F(__is_integral(UnionAr))]; 279 int t26[F(__is_integral(Derives))]; 280 int t27[F(__is_integral(ClassType))]; 281 int t28[F(__is_integral(Enum))]; 282 int t29[F(__is_integral(void))]; 283 int t30[F(__is_integral(cvoid))]; 284 int t31[F(__is_integral(IntArNB))]; 285 } 286 287 void is_floating_point() 288 { 289 int t01[T(__is_floating_point(float))]; 290 int t02[T(__is_floating_point(double))]; 291 int t03[T(__is_floating_point(long double))]; 292 293 int t11[F(__is_floating_point(bool))]; 294 int t12[F(__is_floating_point(char))]; 295 int t13[F(__is_floating_point(signed char))]; 296 int t14[F(__is_floating_point(unsigned char))]; 297 //int t15[F(__is_floating_point(char16_t))]; 298 //int t16[F(__is_floating_point(char32_t))]; 299 int t17[F(__is_floating_point(wchar_t))]; 300 int t18[F(__is_floating_point(short))]; 301 int t19[F(__is_floating_point(unsigned short))]; 302 int t20[F(__is_floating_point(int))]; 303 int t21[F(__is_floating_point(unsigned int))]; 304 int t22[F(__is_floating_point(long))]; 305 int t23[F(__is_floating_point(unsigned long))]; 306 int t24[F(__is_floating_point(Union))]; 307 int t25[F(__is_floating_point(UnionAr))]; 308 int t26[F(__is_floating_point(Derives))]; 309 int t27[F(__is_floating_point(ClassType))]; 310 int t28[F(__is_floating_point(Enum))]; 311 int t29[F(__is_floating_point(void))]; 312 int t30[F(__is_floating_point(cvoid))]; 313 int t31[F(__is_floating_point(IntArNB))]; 314 } 315 316 void is_arithmetic() 317 { 318 int t01[T(__is_arithmetic(float))]; 319 int t02[T(__is_arithmetic(double))]; 320 int t03[T(__is_arithmetic(long double))]; 321 int t11[T(__is_arithmetic(bool))]; 322 int t12[T(__is_arithmetic(char))]; 323 int t13[T(__is_arithmetic(signed char))]; 324 int t14[T(__is_arithmetic(unsigned char))]; 325 //int t15[T(__is_arithmetic(char16_t))]; 326 //int t16[T(__is_arithmetic(char32_t))]; 327 int t17[T(__is_arithmetic(wchar_t))]; 328 int t18[T(__is_arithmetic(short))]; 329 int t19[T(__is_arithmetic(unsigned short))]; 330 int t20[T(__is_arithmetic(int))]; 331 int t21[T(__is_arithmetic(unsigned int))]; 332 int t22[T(__is_arithmetic(long))]; 333 int t23[T(__is_arithmetic(unsigned long))]; 334 335 int t24[F(__is_arithmetic(Union))]; 336 int t25[F(__is_arithmetic(UnionAr))]; 337 int t26[F(__is_arithmetic(Derives))]; 338 int t27[F(__is_arithmetic(ClassType))]; 339 int t28[F(__is_arithmetic(Enum))]; 340 int t29[F(__is_arithmetic(void))]; 341 int t30[F(__is_arithmetic(cvoid))]; 342 int t31[F(__is_arithmetic(IntArNB))]; 343 } 344 345 struct ACompleteType {}; 346 struct AnIncompleteType; 347 348 void is_complete_type() 349 { 350 int t01[T(__is_complete_type(float))]; 351 int t02[T(__is_complete_type(double))]; 352 int t03[T(__is_complete_type(long double))]; 353 int t11[T(__is_complete_type(bool))]; 354 int t12[T(__is_complete_type(char))]; 355 int t13[T(__is_complete_type(signed char))]; 356 int t14[T(__is_complete_type(unsigned char))]; 357 //int t15[T(__is_complete_type(char16_t))]; 358 //int t16[T(__is_complete_type(char32_t))]; 359 int t17[T(__is_complete_type(wchar_t))]; 360 int t18[T(__is_complete_type(short))]; 361 int t19[T(__is_complete_type(unsigned short))]; 362 int t20[T(__is_complete_type(int))]; 363 int t21[T(__is_complete_type(unsigned int))]; 364 int t22[T(__is_complete_type(long))]; 365 int t23[T(__is_complete_type(unsigned long))]; 366 int t24[T(__is_complete_type(ACompleteType))]; 367 368 int t30[F(__is_complete_type(AnIncompleteType))]; 369 } 370 371 void is_void() 372 { 373 int t01[T(__is_void(void))]; 374 int t02[T(__is_void(cvoid))]; 375 376 int t10[F(__is_void(float))]; 377 int t11[F(__is_void(double))]; 378 int t12[F(__is_void(long double))]; 379 int t13[F(__is_void(bool))]; 380 int t14[F(__is_void(char))]; 381 int t15[F(__is_void(signed char))]; 382 int t16[F(__is_void(unsigned char))]; 383 int t17[F(__is_void(wchar_t))]; 384 int t18[F(__is_void(short))]; 385 int t19[F(__is_void(unsigned short))]; 386 int t20[F(__is_void(int))]; 387 int t21[F(__is_void(unsigned int))]; 388 int t22[F(__is_void(long))]; 389 int t23[F(__is_void(unsigned long))]; 390 int t24[F(__is_void(Union))]; 391 int t25[F(__is_void(UnionAr))]; 392 int t26[F(__is_void(Derives))]; 393 int t27[F(__is_void(ClassType))]; 394 int t28[F(__is_void(Enum))]; 395 int t29[F(__is_void(IntArNB))]; 396 int t30[F(__is_void(void*))]; 397 int t31[F(__is_void(cvoid*))]; 398 } 399 400 void is_array() 401 { 402 int t01[T(__is_array(IntAr))]; 403 int t02[T(__is_array(IntArNB))]; 404 int t03[T(__is_array(UnionAr))]; 405 406 int t10[F(__is_array(void))]; 407 int t11[F(__is_array(cvoid))]; 408 int t12[F(__is_array(float))]; 409 int t13[F(__is_array(double))]; 410 int t14[F(__is_array(long double))]; 411 int t15[F(__is_array(bool))]; 412 int t16[F(__is_array(char))]; 413 int t17[F(__is_array(signed char))]; 414 int t18[F(__is_array(unsigned char))]; 415 int t19[F(__is_array(wchar_t))]; 416 int t20[F(__is_array(short))]; 417 int t21[F(__is_array(unsigned short))]; 418 int t22[F(__is_array(int))]; 419 int t23[F(__is_array(unsigned int))]; 420 int t24[F(__is_array(long))]; 421 int t25[F(__is_array(unsigned long))]; 422 int t26[F(__is_array(Union))]; 423 int t27[F(__is_array(Derives))]; 424 int t28[F(__is_array(ClassType))]; 425 int t29[F(__is_array(Enum))]; 426 int t30[F(__is_array(void*))]; 427 int t31[F(__is_array(cvoid*))]; 428 } 429 430 template <typename T> void tmpl_func(T&) {} 431 432 template <typename T> struct type_wrapper { 433 typedef T type; 434 typedef T* ptrtype; 435 typedef T& reftype; 436 }; 437 438 void is_function() 439 { 440 int t01[T(__is_function(type_wrapper<void(void)>::type))]; 441 int t02[T(__is_function(typeof(tmpl_func<int>)))]; 442 443 typedef void (*ptr_to_func_type)(void); 444 445 int t10[F(__is_function(void))]; 446 int t11[F(__is_function(cvoid))]; 447 int t12[F(__is_function(float))]; 448 int t13[F(__is_function(double))]; 449 int t14[F(__is_function(long double))]; 450 int t15[F(__is_function(bool))]; 451 int t16[F(__is_function(char))]; 452 int t17[F(__is_function(signed char))]; 453 int t18[F(__is_function(unsigned char))]; 454 int t19[F(__is_function(wchar_t))]; 455 int t20[F(__is_function(short))]; 456 int t21[F(__is_function(unsigned short))]; 457 int t22[F(__is_function(int))]; 458 int t23[F(__is_function(unsigned int))]; 459 int t24[F(__is_function(long))]; 460 int t25[F(__is_function(unsigned long))]; 461 int t26[F(__is_function(Union))]; 462 int t27[F(__is_function(Derives))]; 463 int t28[F(__is_function(ClassType))]; 464 int t29[F(__is_function(Enum))]; 465 int t30[F(__is_function(void*))]; 466 int t31[F(__is_function(cvoid*))]; 467 int t32[F(__is_function(void(*)()))]; 468 int t33[F(__is_function(ptr_to_func_type))]; 469 int t34[F(__is_function(type_wrapper<void(void)>::ptrtype))]; 470 int t35[F(__is_function(type_wrapper<void(void)>::reftype))]; 471 } 472 473 void is_reference() 474 { 475 int t01[T(__is_reference(int&))]; 476 int t02[T(__is_reference(const int&))]; 477 int t03[T(__is_reference(void *&))]; 478 479 int t10[F(__is_reference(int))]; 480 int t11[F(__is_reference(const int))]; 481 int t12[F(__is_reference(void *))]; 482 } 483 484 void is_lvalue_reference() 485 { 486 int t01[T(__is_lvalue_reference(int&))]; 487 int t02[T(__is_lvalue_reference(void *&))]; 488 int t03[T(__is_lvalue_reference(const int&))]; 489 int t04[T(__is_lvalue_reference(void * const &))]; 490 491 int t10[F(__is_lvalue_reference(int))]; 492 int t11[F(__is_lvalue_reference(const int))]; 493 int t12[F(__is_lvalue_reference(void *))]; 494 } 495 496 #if __has_feature(cxx_rvalue_references) 497 498 void is_rvalue_reference() 499 { 500 int t01[T(__is_rvalue_reference(const int&&))]; 501 int t02[T(__is_rvalue_reference(void * const &&))]; 502 503 int t10[F(__is_rvalue_reference(int&))]; 504 int t11[F(__is_rvalue_reference(void *&))]; 505 int t12[F(__is_rvalue_reference(const int&))]; 506 int t13[F(__is_rvalue_reference(void * const &))]; 507 int t14[F(__is_rvalue_reference(int))]; 508 int t15[F(__is_rvalue_reference(const int))]; 509 int t16[F(__is_rvalue_reference(void *))]; 510 } 511 512 #endif 513 514 void is_fundamental() 515 { 516 int t01[T(__is_fundamental(float))]; 517 int t02[T(__is_fundamental(double))]; 518 int t03[T(__is_fundamental(long double))]; 519 int t11[T(__is_fundamental(bool))]; 520 int t12[T(__is_fundamental(char))]; 521 int t13[T(__is_fundamental(signed char))]; 522 int t14[T(__is_fundamental(unsigned char))]; 523 //int t15[T(__is_fundamental(char16_t))]; 524 //int t16[T(__is_fundamental(char32_t))]; 525 int t17[T(__is_fundamental(wchar_t))]; 526 int t18[T(__is_fundamental(short))]; 527 int t19[T(__is_fundamental(unsigned short))]; 528 int t20[T(__is_fundamental(int))]; 529 int t21[T(__is_fundamental(unsigned int))]; 530 int t22[T(__is_fundamental(long))]; 531 int t23[T(__is_fundamental(unsigned long))]; 532 int t24[T(__is_fundamental(void))]; 533 int t25[T(__is_fundamental(cvoid))]; 534 535 int t30[F(__is_fundamental(Union))]; 536 int t31[F(__is_fundamental(UnionAr))]; 537 int t32[F(__is_fundamental(Derives))]; 538 int t33[F(__is_fundamental(ClassType))]; 539 int t34[F(__is_fundamental(Enum))]; 540 int t35[F(__is_fundamental(IntArNB))]; 541 } 542 543 void is_object() 544 { 545 int t01[T(__is_object(int))]; 546 int t02[T(__is_object(int *))]; 547 int t03[T(__is_object(void *))]; 548 int t04[T(__is_object(Union))]; 549 int t05[T(__is_object(UnionAr))]; 550 int t06[T(__is_object(ClassType))]; 551 int t07[T(__is_object(Enum))]; 552 553 int t10[F(__is_object(type_wrapper<void(void)>::type))]; 554 int t11[F(__is_object(int&))]; 555 int t12[F(__is_object(void))]; 556 } 557 558 void is_scalar() 559 { 560 int t01[T(__is_scalar(float))]; 561 int t02[T(__is_scalar(double))]; 562 int t03[T(__is_scalar(long double))]; 563 int t04[T(__is_scalar(bool))]; 564 int t05[T(__is_scalar(char))]; 565 int t06[T(__is_scalar(signed char))]; 566 int t07[T(__is_scalar(unsigned char))]; 567 int t08[T(__is_scalar(wchar_t))]; 568 int t09[T(__is_scalar(short))]; 569 int t10[T(__is_scalar(unsigned short))]; 570 int t11[T(__is_scalar(int))]; 571 int t12[T(__is_scalar(unsigned int))]; 572 int t13[T(__is_scalar(long))]; 573 int t14[T(__is_scalar(unsigned long))]; 574 int t15[T(__is_scalar(Enum))]; 575 int t16[T(__is_scalar(void*))]; 576 int t17[T(__is_scalar(cvoid*))]; 577 578 int t20[F(__is_scalar(void))]; 579 int t21[F(__is_scalar(cvoid))]; 580 int t22[F(__is_scalar(Union))]; 581 int t23[F(__is_scalar(UnionAr))]; 582 int t24[F(__is_scalar(Derives))]; 583 int t25[F(__is_scalar(ClassType))]; 584 int t26[F(__is_scalar(IntArNB))]; 585 } 586 587 struct StructWithMembers { 588 int member; 589 void method() {} 590 }; 591 592 void is_compound() 593 { 594 int t01[T(__is_compound(void*))]; 595 int t02[T(__is_compound(cvoid*))]; 596 int t03[T(__is_compound(void (*)()))]; 597 int t04[T(__is_compound(int StructWithMembers::*))]; 598 int t05[T(__is_compound(void (StructWithMembers::*)()))]; 599 int t06[T(__is_compound(int&))]; 600 int t07[T(__is_compound(Union))]; 601 int t08[T(__is_compound(UnionAr))]; 602 int t09[T(__is_compound(Derives))]; 603 int t10[T(__is_compound(ClassType))]; 604 int t11[T(__is_compound(IntArNB))]; 605 int t12[T(__is_compound(Enum))]; 606 607 int t20[F(__is_compound(float))]; 608 int t21[F(__is_compound(double))]; 609 int t22[F(__is_compound(long double))]; 610 int t23[F(__is_compound(bool))]; 611 int t24[F(__is_compound(char))]; 612 int t25[F(__is_compound(signed char))]; 613 int t26[F(__is_compound(unsigned char))]; 614 int t27[F(__is_compound(wchar_t))]; 615 int t28[F(__is_compound(short))]; 616 int t29[F(__is_compound(unsigned short))]; 617 int t30[F(__is_compound(int))]; 618 int t31[F(__is_compound(unsigned int))]; 619 int t32[F(__is_compound(long))]; 620 int t33[F(__is_compound(unsigned long))]; 621 int t34[F(__is_compound(void))]; 622 int t35[F(__is_compound(cvoid))]; 623 } 624 625 void is_pointer() 626 { 627 StructWithMembers x; 628 629 int t01[T(__is_pointer(void*))]; 630 int t02[T(__is_pointer(cvoid*))]; 631 int t03[T(__is_pointer(cvoid*))]; 632 int t04[T(__is_pointer(char*))]; 633 int t05[T(__is_pointer(int*))]; 634 int t06[T(__is_pointer(int**))]; 635 int t07[T(__is_pointer(ClassType*))]; 636 int t08[T(__is_pointer(Derives*))]; 637 int t09[T(__is_pointer(Enum*))]; 638 int t10[T(__is_pointer(IntArNB*))]; 639 int t11[T(__is_pointer(Union*))]; 640 int t12[T(__is_pointer(UnionAr*))]; 641 int t13[T(__is_pointer(StructWithMembers*))]; 642 int t14[T(__is_pointer(void (*)()))]; 643 644 int t20[F(__is_pointer(void))]; 645 int t21[F(__is_pointer(cvoid))]; 646 int t22[F(__is_pointer(cvoid))]; 647 int t23[F(__is_pointer(char))]; 648 int t24[F(__is_pointer(int))]; 649 int t25[F(__is_pointer(int))]; 650 int t26[F(__is_pointer(ClassType))]; 651 int t27[F(__is_pointer(Derives))]; 652 int t28[F(__is_pointer(Enum))]; 653 int t29[F(__is_pointer(IntArNB))]; 654 int t30[F(__is_pointer(Union))]; 655 int t31[F(__is_pointer(UnionAr))]; 656 int t32[F(__is_pointer(StructWithMembers))]; 657 int t33[F(__is_pointer(int StructWithMembers::*))]; 658 int t34[F(__is_pointer(void (StructWithMembers::*) ()))]; 659 } 660 661 void is_member_object_pointer() 662 { 663 StructWithMembers x; 664 665 int t01[T(__is_member_object_pointer(int StructWithMembers::*))]; 666 667 int t10[F(__is_member_object_pointer(void (StructWithMembers::*) ()))]; 668 int t11[F(__is_member_object_pointer(void*))]; 669 int t12[F(__is_member_object_pointer(cvoid*))]; 670 int t13[F(__is_member_object_pointer(cvoid*))]; 671 int t14[F(__is_member_object_pointer(char*))]; 672 int t15[F(__is_member_object_pointer(int*))]; 673 int t16[F(__is_member_object_pointer(int**))]; 674 int t17[F(__is_member_object_pointer(ClassType*))]; 675 int t18[F(__is_member_object_pointer(Derives*))]; 676 int t19[F(__is_member_object_pointer(Enum*))]; 677 int t20[F(__is_member_object_pointer(IntArNB*))]; 678 int t21[F(__is_member_object_pointer(Union*))]; 679 int t22[F(__is_member_object_pointer(UnionAr*))]; 680 int t23[F(__is_member_object_pointer(StructWithMembers*))]; 681 int t24[F(__is_member_object_pointer(void))]; 682 int t25[F(__is_member_object_pointer(cvoid))]; 683 int t26[F(__is_member_object_pointer(cvoid))]; 684 int t27[F(__is_member_object_pointer(char))]; 685 int t28[F(__is_member_object_pointer(int))]; 686 int t29[F(__is_member_object_pointer(int))]; 687 int t30[F(__is_member_object_pointer(ClassType))]; 688 int t31[F(__is_member_object_pointer(Derives))]; 689 int t32[F(__is_member_object_pointer(Enum))]; 690 int t33[F(__is_member_object_pointer(IntArNB))]; 691 int t34[F(__is_member_object_pointer(Union))]; 692 int t35[F(__is_member_object_pointer(UnionAr))]; 693 int t36[F(__is_member_object_pointer(StructWithMembers))]; 694 int t37[F(__is_member_object_pointer(void (*)()))]; 695 } 696 697 void is_member_function_pointer() 698 { 699 StructWithMembers x; 700 701 int t01[T(__is_member_function_pointer(void (StructWithMembers::*) ()))]; 702 703 int t10[F(__is_member_function_pointer(int StructWithMembers::*))]; 704 int t11[F(__is_member_function_pointer(void*))]; 705 int t12[F(__is_member_function_pointer(cvoid*))]; 706 int t13[F(__is_member_function_pointer(cvoid*))]; 707 int t14[F(__is_member_function_pointer(char*))]; 708 int t15[F(__is_member_function_pointer(int*))]; 709 int t16[F(__is_member_function_pointer(int**))]; 710 int t17[F(__is_member_function_pointer(ClassType*))]; 711 int t18[F(__is_member_function_pointer(Derives*))]; 712 int t19[F(__is_member_function_pointer(Enum*))]; 713 int t20[F(__is_member_function_pointer(IntArNB*))]; 714 int t21[F(__is_member_function_pointer(Union*))]; 715 int t22[F(__is_member_function_pointer(UnionAr*))]; 716 int t23[F(__is_member_function_pointer(StructWithMembers*))]; 717 int t24[F(__is_member_function_pointer(void))]; 718 int t25[F(__is_member_function_pointer(cvoid))]; 719 int t26[F(__is_member_function_pointer(cvoid))]; 720 int t27[F(__is_member_function_pointer(char))]; 721 int t28[F(__is_member_function_pointer(int))]; 722 int t29[F(__is_member_function_pointer(int))]; 723 int t30[F(__is_member_function_pointer(ClassType))]; 724 int t31[F(__is_member_function_pointer(Derives))]; 725 int t32[F(__is_member_function_pointer(Enum))]; 726 int t33[F(__is_member_function_pointer(IntArNB))]; 727 int t34[F(__is_member_function_pointer(Union))]; 728 int t35[F(__is_member_function_pointer(UnionAr))]; 729 int t36[F(__is_member_function_pointer(StructWithMembers))]; 730 int t37[F(__is_member_function_pointer(void (*)()))]; 731 } 732 733 void is_member_pointer() 734 { 735 StructWithMembers x; 736 737 int t01[T(__is_member_pointer(int StructWithMembers::*))]; 738 int t02[T(__is_member_pointer(void (StructWithMembers::*) ()))]; 739 740 int t10[F(__is_member_pointer(void*))]; 741 int t11[F(__is_member_pointer(cvoid*))]; 742 int t12[F(__is_member_pointer(cvoid*))]; 743 int t13[F(__is_member_pointer(char*))]; 744 int t14[F(__is_member_pointer(int*))]; 745 int t15[F(__is_member_pointer(int**))]; 746 int t16[F(__is_member_pointer(ClassType*))]; 747 int t17[F(__is_member_pointer(Derives*))]; 748 int t18[F(__is_member_pointer(Enum*))]; 749 int t19[F(__is_member_pointer(IntArNB*))]; 750 int t20[F(__is_member_pointer(Union*))]; 751 int t21[F(__is_member_pointer(UnionAr*))]; 752 int t22[F(__is_member_pointer(StructWithMembers*))]; 753 int t23[F(__is_member_pointer(void))]; 754 int t24[F(__is_member_pointer(cvoid))]; 755 int t25[F(__is_member_pointer(cvoid))]; 756 int t26[F(__is_member_pointer(char))]; 757 int t27[F(__is_member_pointer(int))]; 758 int t28[F(__is_member_pointer(int))]; 759 int t29[F(__is_member_pointer(ClassType))]; 760 int t30[F(__is_member_pointer(Derives))]; 761 int t31[F(__is_member_pointer(Enum))]; 762 int t32[F(__is_member_pointer(IntArNB))]; 763 int t33[F(__is_member_pointer(Union))]; 764 int t34[F(__is_member_pointer(UnionAr))]; 765 int t35[F(__is_member_pointer(StructWithMembers))]; 766 int t36[F(__is_member_pointer(void (*)()))]; 767 } 768 769 void is_const() 770 { 771 int t01[T(__is_const(cvoid))]; 772 int t02[T(__is_const(const char))]; 773 int t03[T(__is_const(const int))]; 774 int t04[T(__is_const(const long))]; 775 int t05[T(__is_const(const short))]; 776 int t06[T(__is_const(const signed char))]; 777 int t07[T(__is_const(const wchar_t))]; 778 int t08[T(__is_const(const bool))]; 779 int t09[T(__is_const(const float))]; 780 int t10[T(__is_const(const double))]; 781 int t11[T(__is_const(const long double))]; 782 int t12[T(__is_const(const unsigned char))]; 783 int t13[T(__is_const(const unsigned int))]; 784 int t14[T(__is_const(const unsigned long long))]; 785 int t15[T(__is_const(const unsigned long))]; 786 int t16[T(__is_const(const unsigned short))]; 787 int t17[T(__is_const(const void))]; 788 int t18[T(__is_const(const ClassType))]; 789 int t19[T(__is_const(const Derives))]; 790 int t20[T(__is_const(const Enum))]; 791 int t21[T(__is_const(const IntArNB))]; 792 int t22[T(__is_const(const Union))]; 793 int t23[T(__is_const(const UnionAr))]; 794 795 int t30[F(__is_const(char))]; 796 int t31[F(__is_const(int))]; 797 int t32[F(__is_const(long))]; 798 int t33[F(__is_const(short))]; 799 int t34[F(__is_const(signed char))]; 800 int t35[F(__is_const(wchar_t))]; 801 int t36[F(__is_const(bool))]; 802 int t37[F(__is_const(float))]; 803 int t38[F(__is_const(double))]; 804 int t39[F(__is_const(long double))]; 805 int t40[F(__is_const(unsigned char))]; 806 int t41[F(__is_const(unsigned int))]; 807 int t42[F(__is_const(unsigned long long))]; 808 int t43[F(__is_const(unsigned long))]; 809 int t44[F(__is_const(unsigned short))]; 810 int t45[F(__is_const(void))]; 811 int t46[F(__is_const(ClassType))]; 812 int t47[F(__is_const(Derives))]; 813 int t48[F(__is_const(Enum))]; 814 int t49[F(__is_const(IntArNB))]; 815 int t50[F(__is_const(Union))]; 816 int t51[F(__is_const(UnionAr))]; 817 } 818 819 void is_volatile() 820 { 821 int t02[T(__is_volatile(volatile char))]; 822 int t03[T(__is_volatile(volatile int))]; 823 int t04[T(__is_volatile(volatile long))]; 824 int t05[T(__is_volatile(volatile short))]; 825 int t06[T(__is_volatile(volatile signed char))]; 826 int t07[T(__is_volatile(volatile wchar_t))]; 827 int t08[T(__is_volatile(volatile bool))]; 828 int t09[T(__is_volatile(volatile float))]; 829 int t10[T(__is_volatile(volatile double))]; 830 int t11[T(__is_volatile(volatile long double))]; 831 int t12[T(__is_volatile(volatile unsigned char))]; 832 int t13[T(__is_volatile(volatile unsigned int))]; 833 int t14[T(__is_volatile(volatile unsigned long long))]; 834 int t15[T(__is_volatile(volatile unsigned long))]; 835 int t16[T(__is_volatile(volatile unsigned short))]; 836 int t17[T(__is_volatile(volatile void))]; 837 int t18[T(__is_volatile(volatile ClassType))]; 838 int t19[T(__is_volatile(volatile Derives))]; 839 int t20[T(__is_volatile(volatile Enum))]; 840 int t21[T(__is_volatile(volatile IntArNB))]; 841 int t22[T(__is_volatile(volatile Union))]; 842 int t23[T(__is_volatile(volatile UnionAr))]; 843 844 int t30[F(__is_volatile(char))]; 845 int t31[F(__is_volatile(int))]; 846 int t32[F(__is_volatile(long))]; 847 int t33[F(__is_volatile(short))]; 848 int t34[F(__is_volatile(signed char))]; 849 int t35[F(__is_volatile(wchar_t))]; 850 int t36[F(__is_volatile(bool))]; 851 int t37[F(__is_volatile(float))]; 852 int t38[F(__is_volatile(double))]; 853 int t39[F(__is_volatile(long double))]; 854 int t40[F(__is_volatile(unsigned char))]; 855 int t41[F(__is_volatile(unsigned int))]; 856 int t42[F(__is_volatile(unsigned long long))]; 857 int t43[F(__is_volatile(unsigned long))]; 858 int t44[F(__is_volatile(unsigned short))]; 859 int t45[F(__is_volatile(void))]; 860 int t46[F(__is_volatile(ClassType))]; 861 int t47[F(__is_volatile(Derives))]; 862 int t48[F(__is_volatile(Enum))]; 863 int t49[F(__is_volatile(IntArNB))]; 864 int t50[F(__is_volatile(Union))]; 865 int t51[F(__is_volatile(UnionAr))]; 866 } 867 868 struct TrivialStruct { 869 int member; 870 }; 871 872 struct NonTrivialStruct { 873 int member; 874 NonTrivialStruct() { 875 member = 0; 876 } 877 }; 878 879 struct SuperNonTrivialStruct { 880 SuperNonTrivialStruct() { } 881 ~SuperNonTrivialStruct() { } 882 }; 883 884 struct NonTCStruct { 885 NonTCStruct(const NonTCStruct&) {} 886 }; 887 888 void is_trivial2() 889 { 890 int t01[T(__is_trivial(char))]; 891 int t02[T(__is_trivial(int))]; 892 int t03[T(__is_trivial(long))]; 893 int t04[T(__is_trivial(short))]; 894 int t05[T(__is_trivial(signed char))]; 895 int t06[T(__is_trivial(wchar_t))]; 896 int t07[T(__is_trivial(bool))]; 897 int t08[T(__is_trivial(float))]; 898 int t09[T(__is_trivial(double))]; 899 int t10[T(__is_trivial(long double))]; 900 int t11[T(__is_trivial(unsigned char))]; 901 int t12[T(__is_trivial(unsigned int))]; 902 int t13[T(__is_trivial(unsigned long long))]; 903 int t14[T(__is_trivial(unsigned long))]; 904 int t15[T(__is_trivial(unsigned short))]; 905 int t16[T(__is_trivial(ClassType))]; 906 int t17[T(__is_trivial(Derives))]; 907 int t18[T(__is_trivial(Enum))]; 908 int t19[T(__is_trivial(IntAr))]; 909 int t20[T(__is_trivial(Union))]; 910 int t21[T(__is_trivial(UnionAr))]; 911 int t22[T(__is_trivial(TrivialStruct))]; 912 913 int t30[F(__is_trivial(void))]; 914 int t31[F(__is_trivial(NonTrivialStruct))]; 915 int t32[F(__is_trivial(SuperNonTrivialStruct))]; 916 int t33[F(__is_trivial(NonTCStruct))]; 917 } 918 919 void is_trivially_copyable2() 920 { 921 int t01[T(__is_trivially_copyable(char))]; 922 int t02[T(__is_trivially_copyable(int))]; 923 int t03[T(__is_trivially_copyable(long))]; 924 int t04[T(__is_trivially_copyable(short))]; 925 int t05[T(__is_trivially_copyable(signed char))]; 926 int t06[T(__is_trivially_copyable(wchar_t))]; 927 int t07[T(__is_trivially_copyable(bool))]; 928 int t08[T(__is_trivially_copyable(float))]; 929 int t09[T(__is_trivially_copyable(double))]; 930 int t10[T(__is_trivially_copyable(long double))]; 931 int t11[T(__is_trivially_copyable(unsigned char))]; 932 int t12[T(__is_trivially_copyable(unsigned int))]; 933 int t13[T(__is_trivially_copyable(unsigned long long))]; 934 int t14[T(__is_trivially_copyable(unsigned long))]; 935 int t15[T(__is_trivially_copyable(unsigned short))]; 936 int t16[T(__is_trivially_copyable(ClassType))]; 937 int t17[T(__is_trivially_copyable(Derives))]; 938 int t18[T(__is_trivially_copyable(Enum))]; 939 int t19[T(__is_trivially_copyable(IntAr))]; 940 int t20[T(__is_trivially_copyable(Union))]; 941 int t21[T(__is_trivially_copyable(UnionAr))]; 942 int t22[T(__is_trivially_copyable(TrivialStruct))]; 943 int t23[T(__is_trivially_copyable(NonTrivialStruct))]; 944 945 int t30[F(__is_trivially_copyable(void))]; 946 int t32[F(__is_trivially_copyable(SuperNonTrivialStruct))]; 947 int t31[F(__is_trivially_copyable(NonTCStruct))]; 948 } 949 950 struct CStruct { 951 int one; 952 int two; 953 }; 954 955 struct CEmptyStruct {}; 956 957 struct CppEmptyStruct : CStruct {}; 958 struct CppStructStandard : CEmptyStruct { 959 int three; 960 int four; 961 }; 962 struct CppStructNonStandardByBase : CStruct { 963 int three; 964 int four; 965 }; 966 struct CppStructNonStandardByVirt : CStruct { 967 virtual void method() {} 968 }; 969 struct CppStructNonStandardByMemb : CStruct { 970 CppStructNonStandardByVirt member; 971 }; 972 struct CppStructNonStandardByProt : CStruct { 973 int five; 974 protected: 975 int six; 976 }; 977 struct CppStructNonStandardByVirtBase : virtual CStruct { 978 }; 979 struct CppStructNonStandardBySameBase : CEmptyStruct { 980 CEmptyStruct member; 981 }; 982 struct CppStructNonStandardBy2ndVirtBase : CEmptyStruct { 983 CEmptyStruct member; 984 }; 985 986 void is_standard_layout() 987 { 988 typedef const int ConstInt; 989 typedef ConstInt ConstIntAr[4]; 990 typedef CppStructStandard CppStructStandardAr[4]; 991 992 int t01[T(__is_standard_layout(int))]; 993 int t02[T(__is_standard_layout(ConstInt))]; 994 int t03[T(__is_standard_layout(ConstIntAr))]; 995 int t04[T(__is_standard_layout(CStruct))]; 996 int t05[T(__is_standard_layout(CppStructStandard))]; 997 int t06[T(__is_standard_layout(CppStructStandardAr))]; 998 int t07[T(__is_standard_layout(Vector))]; 999 int t08[T(__is_standard_layout(VectorExt))]; 1000 1001 typedef CppStructNonStandardByBase CppStructNonStandardByBaseAr[4]; 1002 1003 int t10[F(__is_standard_layout(CppStructNonStandardByVirt))]; 1004 int t11[F(__is_standard_layout(CppStructNonStandardByMemb))]; 1005 int t12[F(__is_standard_layout(CppStructNonStandardByProt))]; 1006 int t13[F(__is_standard_layout(CppStructNonStandardByVirtBase))]; 1007 int t14[F(__is_standard_layout(CppStructNonStandardByBase))]; 1008 int t15[F(__is_standard_layout(CppStructNonStandardByBaseAr))]; 1009 int t16[F(__is_standard_layout(CppStructNonStandardBySameBase))]; 1010 int t17[F(__is_standard_layout(CppStructNonStandardBy2ndVirtBase))]; 1011 } 1012 1013 void is_signed() 1014 { 1015 //int t01[T(__is_signed(char))]; 1016 int t02[T(__is_signed(int))]; 1017 int t03[T(__is_signed(long))]; 1018 int t04[T(__is_signed(short))]; 1019 int t05[T(__is_signed(signed char))]; 1020 int t06[T(__is_signed(wchar_t))]; 1021 1022 int t10[F(__is_signed(bool))]; 1023 int t11[F(__is_signed(cvoid))]; 1024 int t12[F(__is_signed(float))]; 1025 int t13[F(__is_signed(double))]; 1026 int t14[F(__is_signed(long double))]; 1027 int t15[F(__is_signed(unsigned char))]; 1028 int t16[F(__is_signed(unsigned int))]; 1029 int t17[F(__is_signed(unsigned long long))]; 1030 int t18[F(__is_signed(unsigned long))]; 1031 int t19[F(__is_signed(unsigned short))]; 1032 int t20[F(__is_signed(void))]; 1033 int t21[F(__is_signed(ClassType))]; 1034 int t22[F(__is_signed(Derives))]; 1035 int t23[F(__is_signed(Enum))]; 1036 int t24[F(__is_signed(IntArNB))]; 1037 int t25[F(__is_signed(Union))]; 1038 int t26[F(__is_signed(UnionAr))]; 1039 } 1040 1041 void is_unsigned() 1042 { 1043 int t01[T(__is_unsigned(bool))]; 1044 int t02[T(__is_unsigned(unsigned char))]; 1045 int t03[T(__is_unsigned(unsigned short))]; 1046 int t04[T(__is_unsigned(unsigned int))]; 1047 int t05[T(__is_unsigned(unsigned long))]; 1048 int t06[T(__is_unsigned(unsigned long long))]; 1049 int t07[T(__is_unsigned(Enum))]; 1050 1051 int t10[F(__is_unsigned(void))]; 1052 int t11[F(__is_unsigned(cvoid))]; 1053 int t12[F(__is_unsigned(float))]; 1054 int t13[F(__is_unsigned(double))]; 1055 int t14[F(__is_unsigned(long double))]; 1056 int t16[F(__is_unsigned(char))]; 1057 int t17[F(__is_unsigned(signed char))]; 1058 int t18[F(__is_unsigned(wchar_t))]; 1059 int t19[F(__is_unsigned(short))]; 1060 int t20[F(__is_unsigned(int))]; 1061 int t21[F(__is_unsigned(long))]; 1062 int t22[F(__is_unsigned(Union))]; 1063 int t23[F(__is_unsigned(UnionAr))]; 1064 int t24[F(__is_unsigned(Derives))]; 1065 int t25[F(__is_unsigned(ClassType))]; 1066 int t26[F(__is_unsigned(IntArNB))]; 1067 } 1068 1069 typedef Int& IntRef; 1070 typedef const IntAr ConstIntAr; 1071 typedef ConstIntAr ConstIntArAr[4]; 1072 1073 struct HasCopy { 1074 HasCopy(HasCopy& cp); 1075 }; 1076 1077 struct HasMove { 1078 HasMove(HasMove&& cp); 1079 }; 1080 1081 struct HasTemplateCons { 1082 HasVirt Annoying; 1083 1084 template <typename T> 1085 HasTemplateCons(const T&); 1086 }; 1087 1088 void has_trivial_default_constructor() { 1089 { int arr[T(__has_trivial_constructor(Int))]; } 1090 { int arr[T(__has_trivial_constructor(IntAr))]; } 1091 { int arr[T(__has_trivial_constructor(Union))]; } 1092 { int arr[T(__has_trivial_constructor(UnionAr))]; } 1093 { int arr[T(__has_trivial_constructor(POD))]; } 1094 { int arr[T(__has_trivial_constructor(Derives))]; } 1095 { int arr[T(__has_trivial_constructor(DerivesAr))]; } 1096 { int arr[T(__has_trivial_constructor(ConstIntAr))]; } 1097 { int arr[T(__has_trivial_constructor(ConstIntArAr))]; } 1098 { int arr[T(__has_trivial_constructor(HasDest))]; } 1099 { int arr[T(__has_trivial_constructor(HasPriv))]; } 1100 { int arr[T(__has_trivial_constructor(HasCopyAssign))]; } 1101 { int arr[T(__has_trivial_constructor(HasMoveAssign))]; } 1102 { int arr[T(__has_trivial_constructor(const Int))]; } 1103 1104 { int arr[F(__has_trivial_constructor(HasCons))]; } 1105 { int arr[F(__has_trivial_constructor(HasRef))]; } 1106 { int arr[F(__has_trivial_constructor(HasCopy))]; } 1107 { int arr[F(__has_trivial_constructor(IntRef))]; } 1108 { int arr[F(__has_trivial_constructor(VirtAr))]; } 1109 { int arr[F(__has_trivial_constructor(void))]; } 1110 { int arr[F(__has_trivial_constructor(cvoid))]; } 1111 { int arr[F(__has_trivial_constructor(HasTemplateCons))]; } 1112 { int arr[F(__has_trivial_constructor(AllPrivate))]; } 1113 } 1114 1115 void has_trivial_copy_constructor() { 1116 { int arr[T(__has_trivial_copy(Int))]; } 1117 { int arr[T(__has_trivial_copy(IntAr))]; } 1118 { int arr[T(__has_trivial_copy(Union))]; } 1119 { int arr[T(__has_trivial_copy(UnionAr))]; } 1120 { int arr[T(__has_trivial_copy(POD))]; } 1121 { int arr[T(__has_trivial_copy(Derives))]; } 1122 { int arr[T(__has_trivial_copy(ConstIntAr))]; } 1123 { int arr[T(__has_trivial_copy(ConstIntArAr))]; } 1124 { int arr[T(__has_trivial_copy(HasDest))]; } 1125 { int arr[T(__has_trivial_copy(HasPriv))]; } 1126 { int arr[T(__has_trivial_copy(HasCons))]; } 1127 { int arr[T(__has_trivial_copy(HasRef))]; } 1128 { int arr[T(__has_trivial_copy(HasMove))]; } 1129 { int arr[T(__has_trivial_copy(IntRef))]; } 1130 { int arr[T(__has_trivial_copy(HasCopyAssign))]; } 1131 { int arr[T(__has_trivial_copy(HasMoveAssign))]; } 1132 { int arr[T(__has_trivial_copy(const Int))]; } 1133 1134 { int arr[F(__has_trivial_copy(HasCopy))]; } 1135 { int arr[F(__has_trivial_copy(HasTemplateCons))]; } 1136 { int arr[F(__has_trivial_copy(DerivesAr))]; } 1137 { int arr[F(__has_trivial_copy(VirtAr))]; } 1138 { int arr[F(__has_trivial_copy(void))]; } 1139 { int arr[F(__has_trivial_copy(cvoid))]; } 1140 { int arr[F(__has_trivial_copy(AllPrivate))]; } 1141 } 1142 1143 void has_trivial_copy_assignment() { 1144 { int arr[T(__has_trivial_assign(Int))]; } 1145 { int arr[T(__has_trivial_assign(IntAr))]; } 1146 { int arr[T(__has_trivial_assign(Union))]; } 1147 { int arr[T(__has_trivial_assign(UnionAr))]; } 1148 { int arr[T(__has_trivial_assign(POD))]; } 1149 { int arr[T(__has_trivial_assign(Derives))]; } 1150 { int arr[T(__has_trivial_assign(HasDest))]; } 1151 { int arr[T(__has_trivial_assign(HasPriv))]; } 1152 { int arr[T(__has_trivial_assign(HasCons))]; } 1153 { int arr[T(__has_trivial_assign(HasRef))]; } 1154 { int arr[T(__has_trivial_assign(HasCopy))]; } 1155 { int arr[T(__has_trivial_assign(HasMove))]; } 1156 { int arr[T(__has_trivial_assign(HasMoveAssign))]; } 1157 1158 { int arr[F(__has_trivial_assign(IntRef))]; } 1159 { int arr[F(__has_trivial_assign(HasCopyAssign))]; } 1160 { int arr[F(__has_trivial_assign(const Int))]; } 1161 { int arr[F(__has_trivial_assign(ConstIntAr))]; } 1162 { int arr[F(__has_trivial_assign(ConstIntArAr))]; } 1163 { int arr[F(__has_trivial_assign(DerivesAr))]; } 1164 { int arr[F(__has_trivial_assign(VirtAr))]; } 1165 { int arr[F(__has_trivial_assign(void))]; } 1166 { int arr[F(__has_trivial_assign(cvoid))]; } 1167 { int arr[F(__has_trivial_assign(AllPrivate))]; } 1168 } 1169 1170 void has_trivial_destructor() { 1171 { int arr[T(__has_trivial_destructor(Int))]; } 1172 { int arr[T(__has_trivial_destructor(IntAr))]; } 1173 { int arr[T(__has_trivial_destructor(Union))]; } 1174 { int arr[T(__has_trivial_destructor(UnionAr))]; } 1175 { int arr[T(__has_trivial_destructor(POD))]; } 1176 { int arr[T(__has_trivial_destructor(Derives))]; } 1177 { int arr[T(__has_trivial_destructor(ConstIntAr))]; } 1178 { int arr[T(__has_trivial_destructor(ConstIntArAr))]; } 1179 { int arr[T(__has_trivial_destructor(HasPriv))]; } 1180 { int arr[T(__has_trivial_destructor(HasCons))]; } 1181 { int arr[T(__has_trivial_destructor(HasRef))]; } 1182 { int arr[T(__has_trivial_destructor(HasCopy))]; } 1183 { int arr[T(__has_trivial_destructor(HasMove))]; } 1184 { int arr[T(__has_trivial_destructor(IntRef))]; } 1185 { int arr[T(__has_trivial_destructor(HasCopyAssign))]; } 1186 { int arr[T(__has_trivial_destructor(HasMoveAssign))]; } 1187 { int arr[T(__has_trivial_destructor(const Int))]; } 1188 { int arr[T(__has_trivial_destructor(DerivesAr))]; } 1189 { int arr[T(__has_trivial_destructor(VirtAr))]; } 1190 1191 { int arr[F(__has_trivial_destructor(HasDest))]; } 1192 { int arr[F(__has_trivial_destructor(void))]; } 1193 { int arr[F(__has_trivial_destructor(cvoid))]; } 1194 { int arr[F(__has_trivial_destructor(AllPrivate))]; } 1195 } 1196 1197 struct A { ~A() {} }; 1198 template<typename> struct B : A { }; 1199 1200 void f() { 1201 { int arr[F(__has_trivial_destructor(A))]; } 1202 { int arr[F(__has_trivial_destructor(B<int>))]; } 1203 } 1204 1205 class PR11110 { 1206 template <int> int operator=( int ); 1207 int operator=(PR11110); 1208 }; 1209 1210 class UsingAssign; 1211 1212 class UsingAssignBase { 1213 protected: 1214 UsingAssign &operator=(const UsingAssign&) throw(); 1215 }; 1216 1217 class UsingAssign : public UsingAssignBase { 1218 public: 1219 using UsingAssignBase::operator=; 1220 }; 1221 1222 void has_nothrow_assign() { 1223 { int arr[T(__has_nothrow_assign(Int))]; } 1224 { int arr[T(__has_nothrow_assign(IntAr))]; } 1225 { int arr[T(__has_nothrow_assign(Union))]; } 1226 { int arr[T(__has_nothrow_assign(UnionAr))]; } 1227 { int arr[T(__has_nothrow_assign(POD))]; } 1228 { int arr[T(__has_nothrow_assign(Derives))]; } 1229 { int arr[T(__has_nothrow_assign(HasDest))]; } 1230 { int arr[T(__has_nothrow_assign(HasPriv))]; } 1231 { int arr[T(__has_nothrow_assign(HasCons))]; } 1232 { int arr[T(__has_nothrow_assign(HasRef))]; } 1233 { int arr[T(__has_nothrow_assign(HasCopy))]; } 1234 { int arr[T(__has_nothrow_assign(HasMove))]; } 1235 { int arr[T(__has_nothrow_assign(HasMoveAssign))]; } 1236 { int arr[T(__has_nothrow_assign(HasNoThrowCopyAssign))]; } 1237 { int arr[T(__has_nothrow_assign(HasMultipleNoThrowCopyAssign))]; } 1238 { int arr[T(__has_nothrow_assign(HasVirtDest))]; } 1239 { int arr[T(__has_nothrow_assign(AllPrivate))]; } 1240 { int arr[T(__has_nothrow_assign(UsingAssign))]; } 1241 1242 { int arr[F(__has_nothrow_assign(IntRef))]; } 1243 { int arr[F(__has_nothrow_assign(HasCopyAssign))]; } 1244 { int arr[F(__has_nothrow_assign(HasMultipleCopyAssign))]; } 1245 { int arr[F(__has_nothrow_assign(const Int))]; } 1246 { int arr[F(__has_nothrow_assign(ConstIntAr))]; } 1247 { int arr[F(__has_nothrow_assign(ConstIntArAr))]; } 1248 { int arr[F(__has_nothrow_assign(DerivesAr))]; } 1249 { int arr[F(__has_nothrow_assign(VirtAr))]; } 1250 { int arr[F(__has_nothrow_assign(void))]; } 1251 { int arr[F(__has_nothrow_assign(cvoid))]; } 1252 { int arr[F(__has_nothrow_assign(PR11110))]; } 1253 } 1254 1255 void has_nothrow_copy() { 1256 { int arr[T(__has_nothrow_copy(Int))]; } 1257 { int arr[T(__has_nothrow_copy(IntAr))]; } 1258 { int arr[T(__has_nothrow_copy(Union))]; } 1259 { int arr[T(__has_nothrow_copy(UnionAr))]; } 1260 { int arr[T(__has_nothrow_copy(POD))]; } 1261 { int arr[T(__has_nothrow_copy(const Int))]; } 1262 { int arr[T(__has_nothrow_copy(ConstIntAr))]; } 1263 { int arr[T(__has_nothrow_copy(ConstIntArAr))]; } 1264 { int arr[T(__has_nothrow_copy(Derives))]; } 1265 { int arr[T(__has_nothrow_copy(IntRef))]; } 1266 { int arr[T(__has_nothrow_copy(HasDest))]; } 1267 { int arr[T(__has_nothrow_copy(HasPriv))]; } 1268 { int arr[T(__has_nothrow_copy(HasCons))]; } 1269 { int arr[T(__has_nothrow_copy(HasRef))]; } 1270 { int arr[T(__has_nothrow_copy(HasMove))]; } 1271 { int arr[T(__has_nothrow_copy(HasCopyAssign))]; } 1272 { int arr[T(__has_nothrow_copy(HasMoveAssign))]; } 1273 { int arr[T(__has_nothrow_copy(HasNoThrowCopy))]; } 1274 { int arr[T(__has_nothrow_copy(HasMultipleNoThrowCopy))]; } 1275 { int arr[T(__has_nothrow_copy(HasVirtDest))]; } 1276 { int arr[T(__has_nothrow_copy(HasTemplateCons))]; } 1277 { int arr[T(__has_nothrow_copy(AllPrivate))]; } 1278 1279 { int arr[F(__has_nothrow_copy(HasCopy))]; } 1280 { int arr[F(__has_nothrow_copy(HasMultipleCopy))]; } 1281 { int arr[F(__has_nothrow_copy(DerivesAr))]; } 1282 { int arr[F(__has_nothrow_copy(VirtAr))]; } 1283 { int arr[F(__has_nothrow_copy(void))]; } 1284 { int arr[F(__has_nothrow_copy(cvoid))]; } 1285 } 1286 1287 template<bool b> struct assert_expr; 1288 template<> struct assert_expr<true> {}; 1289 1290 void has_nothrow_constructor() { 1291 { int arr[T(__has_nothrow_constructor(Int))]; } 1292 { int arr[T(__has_nothrow_constructor(IntAr))]; } 1293 { int arr[T(__has_nothrow_constructor(Union))]; } 1294 { int arr[T(__has_nothrow_constructor(UnionAr))]; } 1295 { int arr[T(__has_nothrow_constructor(POD))]; } 1296 { int arr[T(__has_nothrow_constructor(Derives))]; } 1297 { int arr[T(__has_nothrow_constructor(DerivesAr))]; } 1298 { int arr[T(__has_nothrow_constructor(ConstIntAr))]; } 1299 { int arr[T(__has_nothrow_constructor(ConstIntArAr))]; } 1300 { int arr[T(__has_nothrow_constructor(HasDest))]; } 1301 { int arr[T(__has_nothrow_constructor(HasPriv))]; } 1302 { int arr[T(__has_nothrow_constructor(HasCopyAssign))]; } 1303 { int arr[T(__has_nothrow_constructor(const Int))]; } 1304 { int arr[T(__has_nothrow_constructor(HasNoThrowConstructor))]; } 1305 { int arr[T(__has_nothrow_constructor(HasVirtDest))]; } 1306 // { int arr[T(__has_nothrow_constructor(VirtAr))]; } // not implemented 1307 { int arr[T(__has_nothrow_constructor(AllPrivate))]; } 1308 1309 { int arr[F(__has_nothrow_constructor(HasCons))]; } 1310 { int arr[F(__has_nothrow_constructor(HasRef))]; } 1311 { int arr[F(__has_nothrow_constructor(HasCopy))]; } 1312 { int arr[F(__has_nothrow_constructor(HasMove))]; } 1313 { int arr[F(__has_nothrow_constructor(HasNoThrowConstructorWithArgs))]; } 1314 { int arr[F(__has_nothrow_constructor(IntRef))]; } 1315 { int arr[F(__has_nothrow_constructor(void))]; } 1316 { int arr[F(__has_nothrow_constructor(cvoid))]; } 1317 { int arr[F(__has_nothrow_constructor(HasTemplateCons))]; } 1318 1319 // While parsing an in-class initializer, the constructor is not known to be 1320 // non-throwing yet. 1321 struct HasInClassInit { int n = (assert_expr<!__has_nothrow_constructor(HasInClassInit)>(), 0); }; 1322 { int arr[T(__has_nothrow_constructor(HasInClassInit))]; } 1323 } 1324 1325 void has_virtual_destructor() { 1326 { int arr[F(__has_virtual_destructor(Int))]; } 1327 { int arr[F(__has_virtual_destructor(IntAr))]; } 1328 { int arr[F(__has_virtual_destructor(Union))]; } 1329 { int arr[F(__has_virtual_destructor(UnionAr))]; } 1330 { int arr[F(__has_virtual_destructor(POD))]; } 1331 { int arr[F(__has_virtual_destructor(Derives))]; } 1332 { int arr[F(__has_virtual_destructor(DerivesAr))]; } 1333 { int arr[F(__has_virtual_destructor(const Int))]; } 1334 { int arr[F(__has_virtual_destructor(ConstIntAr))]; } 1335 { int arr[F(__has_virtual_destructor(ConstIntArAr))]; } 1336 { int arr[F(__has_virtual_destructor(HasDest))]; } 1337 { int arr[F(__has_virtual_destructor(HasPriv))]; } 1338 { int arr[F(__has_virtual_destructor(HasCons))]; } 1339 { int arr[F(__has_virtual_destructor(HasRef))]; } 1340 { int arr[F(__has_virtual_destructor(HasCopy))]; } 1341 { int arr[F(__has_virtual_destructor(HasMove))]; } 1342 { int arr[F(__has_virtual_destructor(HasCopyAssign))]; } 1343 { int arr[F(__has_virtual_destructor(HasMoveAssign))]; } 1344 { int arr[F(__has_virtual_destructor(IntRef))]; } 1345 { int arr[F(__has_virtual_destructor(VirtAr))]; } 1346 1347 { int arr[T(__has_virtual_destructor(HasVirtDest))]; } 1348 { int arr[T(__has_virtual_destructor(DerivedVirtDest))]; } 1349 { int arr[F(__has_virtual_destructor(VirtDestAr))]; } 1350 { int arr[F(__has_virtual_destructor(void))]; } 1351 { int arr[F(__has_virtual_destructor(cvoid))]; } 1352 { int arr[F(__has_virtual_destructor(AllPrivate))]; } 1353 } 1354 1355 1356 class Base {}; 1357 class Derived : Base {}; 1358 class Derived2a : Derived {}; 1359 class Derived2b : Derived {}; 1360 class Derived3 : virtual Derived2a, virtual Derived2b {}; 1361 template<typename T> struct BaseA { T a; }; 1362 template<typename T> struct DerivedB : BaseA<T> { }; 1363 template<typename T> struct CrazyDerived : T { }; 1364 1365 1366 class class_forward; // expected-note {{forward declaration of 'class_forward'}} 1367 1368 template <typename Base, typename Derived> 1369 void isBaseOfT() { 1370 int t[T(__is_base_of(Base, Derived))]; 1371 }; 1372 template <typename Base, typename Derived> 1373 void isBaseOfF() { 1374 int t[F(__is_base_of(Base, Derived))]; 1375 }; 1376 1377 template <class T> class DerivedTemp : Base {}; 1378 template <class T> class NonderivedTemp {}; 1379 template <class T> class UndefinedTemp; // expected-note {{declared here}} 1380 1381 void is_base_of() { 1382 { int arr[T(__is_base_of(Base, Derived))]; } 1383 { int arr[T(__is_base_of(const Base, Derived))]; } 1384 { int arr[F(__is_base_of(Derived, Base))]; } 1385 { int arr[F(__is_base_of(Derived, int))]; } 1386 { int arr[T(__is_base_of(Base, Base))]; } 1387 { int arr[T(__is_base_of(Base, Derived3))]; } 1388 { int arr[T(__is_base_of(Derived, Derived3))]; } 1389 { int arr[T(__is_base_of(Derived2b, Derived3))]; } 1390 { int arr[T(__is_base_of(Derived2a, Derived3))]; } 1391 { int arr[T(__is_base_of(BaseA<int>, DerivedB<int>))]; } 1392 { int arr[F(__is_base_of(DerivedB<int>, BaseA<int>))]; } 1393 { int arr[T(__is_base_of(Base, CrazyDerived<Base>))]; } 1394 { int arr[F(__is_base_of(Union, Union))]; } 1395 { int arr[T(__is_base_of(Empty, Empty))]; } 1396 { int arr[T(__is_base_of(class_forward, class_forward))]; } 1397 { int arr[F(__is_base_of(Empty, class_forward))]; } // expected-error {{incomplete type 'class_forward' used in type trait expression}} 1398 { int arr[F(__is_base_of(Base&, Derived&))]; } 1399 int t18[F(__is_base_of(Base[10], Derived[10]))]; 1400 { int arr[F(__is_base_of(int, int))]; } 1401 { int arr[F(__is_base_of(long, int))]; } 1402 { int arr[T(__is_base_of(Base, DerivedTemp<int>))]; } 1403 { int arr[F(__is_base_of(Base, NonderivedTemp<int>))]; } 1404 { int arr[F(__is_base_of(Base, UndefinedTemp<int>))]; } // expected-error {{implicit instantiation of undefined template 'UndefinedTemp<int>'}} 1405 1406 isBaseOfT<Base, Derived>(); 1407 isBaseOfF<Derived, Base>(); 1408 1409 isBaseOfT<Base, CrazyDerived<Base> >(); 1410 isBaseOfF<CrazyDerived<Base>, Base>(); 1411 1412 isBaseOfT<BaseA<int>, DerivedB<int> >(); 1413 isBaseOfF<DerivedB<int>, BaseA<int> >(); 1414 } 1415 1416 #if 0 1417 template<class T, class U> 1418 class TemplateClass {}; 1419 1420 template<class T> 1421 using TemplateAlias = TemplateClass<T, int>; 1422 #endif 1423 1424 typedef class Base BaseTypedef; 1425 1426 void is_same() 1427 { 1428 int t01[T(__is_same(Base, Base))]; 1429 int t02[T(__is_same(Base, BaseTypedef))]; 1430 #if 0 1431 int t03[T(__is_same(TemplateClass<int, int>, TemplateAlias<int>))]; 1432 #endif 1433 1434 int t10[F(__is_same(Base, const Base))]; 1435 int t11[F(__is_same(Base, Base&))]; 1436 int t12[F(__is_same(Base, Derived))]; 1437 } 1438 1439 struct IntWrapper 1440 { 1441 int value; 1442 IntWrapper(int _value) : value(_value) {} 1443 operator int() const { 1444 return value; 1445 } 1446 }; 1447 1448 struct FloatWrapper 1449 { 1450 float value; 1451 FloatWrapper(float _value) : value(_value) {} 1452 FloatWrapper(const IntWrapper& obj) 1453 : value(static_cast<float>(obj.value)) {} 1454 operator float() const { 1455 return value; 1456 } 1457 operator IntWrapper() const { 1458 return IntWrapper(static_cast<int>(value)); 1459 } 1460 }; 1461 1462 void is_convertible() 1463 { 1464 int t01[T(__is_convertible(IntWrapper, IntWrapper))]; 1465 int t02[T(__is_convertible(IntWrapper, const IntWrapper))]; 1466 int t03[T(__is_convertible(IntWrapper, int))]; 1467 int t04[T(__is_convertible(int, IntWrapper))]; 1468 int t05[T(__is_convertible(IntWrapper, FloatWrapper))]; 1469 int t06[T(__is_convertible(FloatWrapper, IntWrapper))]; 1470 int t07[T(__is_convertible(FloatWrapper, float))]; 1471 int t08[T(__is_convertible(float, FloatWrapper))]; 1472 } 1473 1474 struct FromInt { FromInt(int); }; 1475 struct ToInt { operator int(); }; 1476 typedef void Function(); 1477 1478 void is_convertible_to(); 1479 class PrivateCopy { 1480 PrivateCopy(const PrivateCopy&); 1481 friend void is_convertible_to(); 1482 }; 1483 1484 template<typename T> 1485 struct X0 { 1486 template<typename U> X0(const X0<U>&); 1487 }; 1488 1489 void is_convertible_to() { 1490 { int arr[T(__is_convertible_to(Int, Int))]; } 1491 { int arr[F(__is_convertible_to(Int, IntAr))]; } 1492 { int arr[F(__is_convertible_to(IntAr, IntAr))]; } 1493 { int arr[T(__is_convertible_to(void, void))]; } 1494 { int arr[T(__is_convertible_to(cvoid, void))]; } 1495 { int arr[T(__is_convertible_to(void, cvoid))]; } 1496 { int arr[T(__is_convertible_to(cvoid, cvoid))]; } 1497 { int arr[T(__is_convertible_to(int, FromInt))]; } 1498 { int arr[T(__is_convertible_to(long, FromInt))]; } 1499 { int arr[T(__is_convertible_to(double, FromInt))]; } 1500 { int arr[T(__is_convertible_to(const int, FromInt))]; } 1501 { int arr[T(__is_convertible_to(const int&, FromInt))]; } 1502 { int arr[T(__is_convertible_to(ToInt, int))]; } 1503 { int arr[T(__is_convertible_to(ToInt, const int&))]; } 1504 { int arr[T(__is_convertible_to(ToInt, long))]; } 1505 { int arr[F(__is_convertible_to(ToInt, int&))]; } 1506 { int arr[F(__is_convertible_to(ToInt, FromInt))]; } 1507 { int arr[T(__is_convertible_to(IntAr&, IntAr&))]; } 1508 { int arr[T(__is_convertible_to(IntAr&, const IntAr&))]; } 1509 { int arr[F(__is_convertible_to(const IntAr&, IntAr&))]; } 1510 { int arr[F(__is_convertible_to(Function, Function))]; } 1511 { int arr[F(__is_convertible_to(PrivateCopy, PrivateCopy))]; } 1512 { int arr[T(__is_convertible_to(X0<int>, X0<float>))]; } 1513 } 1514 1515 void is_trivial() 1516 { 1517 { int arr[T(__is_trivial(int))]; } 1518 { int arr[T(__is_trivial(Enum))]; } 1519 { int arr[T(__is_trivial(POD))]; } 1520 { int arr[T(__is_trivial(Int))]; } 1521 { int arr[T(__is_trivial(IntAr))]; } 1522 { int arr[T(__is_trivial(IntArNB))]; } 1523 { int arr[T(__is_trivial(Statics))]; } 1524 { int arr[T(__is_trivial(Empty))]; } 1525 { int arr[T(__is_trivial(EmptyUnion))]; } 1526 { int arr[T(__is_trivial(Union))]; } 1527 { int arr[T(__is_trivial(Derives))]; } 1528 { int arr[T(__is_trivial(DerivesAr))]; } 1529 { int arr[T(__is_trivial(DerivesArNB))]; } 1530 { int arr[T(__is_trivial(DerivesEmpty))]; } 1531 { int arr[T(__is_trivial(HasFunc))]; } 1532 { int arr[T(__is_trivial(HasOp))]; } 1533 { int arr[T(__is_trivial(HasConv))]; } 1534 { int arr[T(__is_trivial(HasAssign))]; } 1535 { int arr[T(__is_trivial(HasAnonymousUnion))]; } 1536 { int arr[T(__is_trivial(HasPriv))]; } 1537 { int arr[T(__is_trivial(HasProt))]; } 1538 { int arr[T(__is_trivial(DerivesHasPriv))]; } 1539 { int arr[T(__is_trivial(DerivesHasProt))]; } 1540 { int arr[T(__is_trivial(Vector))]; } 1541 { int arr[T(__is_trivial(VectorExt))]; } 1542 1543 { int arr[F(__is_trivial(HasCons))]; } 1544 { int arr[F(__is_trivial(HasCopyAssign))]; } 1545 { int arr[F(__is_trivial(HasMoveAssign))]; } 1546 { int arr[F(__is_trivial(HasDest))]; } 1547 { int arr[F(__is_trivial(HasRef))]; } 1548 { int arr[F(__is_trivial(HasNonPOD))]; } 1549 { int arr[F(__is_trivial(HasVirt))]; } 1550 { int arr[F(__is_trivial(DerivesHasCons))]; } 1551 { int arr[F(__is_trivial(DerivesHasCopyAssign))]; } 1552 { int arr[F(__is_trivial(DerivesHasMoveAssign))]; } 1553 { int arr[F(__is_trivial(DerivesHasDest))]; } 1554 { int arr[F(__is_trivial(DerivesHasRef))]; } 1555 { int arr[F(__is_trivial(DerivesHasVirt))]; } 1556 { int arr[F(__is_trivial(void))]; } 1557 { int arr[F(__is_trivial(cvoid))]; } 1558 } 1559 1560 void is_trivially_copyable() 1561 { 1562 { int arr[T(__is_trivially_copyable(int))]; } 1563 { int arr[T(__is_trivially_copyable(Enum))]; } 1564 { int arr[T(__is_trivially_copyable(POD))]; } 1565 { int arr[T(__is_trivially_copyable(Int))]; } 1566 { int arr[T(__is_trivially_copyable(IntAr))]; } 1567 { int arr[T(__is_trivially_copyable(IntArNB))]; } 1568 { int arr[T(__is_trivially_copyable(Statics))]; } 1569 { int arr[T(__is_trivially_copyable(Empty))]; } 1570 { int arr[T(__is_trivially_copyable(EmptyUnion))]; } 1571 { int arr[T(__is_trivially_copyable(Union))]; } 1572 { int arr[T(__is_trivially_copyable(Derives))]; } 1573 { int arr[T(__is_trivially_copyable(DerivesAr))]; } 1574 { int arr[T(__is_trivially_copyable(DerivesArNB))]; } 1575 { int arr[T(__is_trivially_copyable(DerivesEmpty))]; } 1576 { int arr[T(__is_trivially_copyable(HasFunc))]; } 1577 { int arr[T(__is_trivially_copyable(HasOp))]; } 1578 { int arr[T(__is_trivially_copyable(HasConv))]; } 1579 { int arr[T(__is_trivially_copyable(HasAssign))]; } 1580 { int arr[T(__is_trivially_copyable(HasAnonymousUnion))]; } 1581 { int arr[T(__is_trivially_copyable(HasPriv))]; } 1582 { int arr[T(__is_trivially_copyable(HasProt))]; } 1583 { int arr[T(__is_trivially_copyable(DerivesHasPriv))]; } 1584 { int arr[T(__is_trivially_copyable(DerivesHasProt))]; } 1585 { int arr[T(__is_trivially_copyable(Vector))]; } 1586 { int arr[T(__is_trivially_copyable(VectorExt))]; } 1587 { int arr[T(__is_trivially_copyable(HasCons))]; } 1588 { int arr[T(__is_trivially_copyable(HasRef))]; } 1589 { int arr[T(__is_trivially_copyable(HasNonPOD))]; } 1590 { int arr[T(__is_trivially_copyable(DerivesHasCons))]; } 1591 { int arr[T(__is_trivially_copyable(DerivesHasRef))]; } 1592 1593 { int arr[F(__is_trivially_copyable(HasCopyAssign))]; } 1594 { int arr[F(__is_trivially_copyable(HasMoveAssign))]; } 1595 { int arr[F(__is_trivially_copyable(HasDest))]; } 1596 { int arr[F(__is_trivially_copyable(HasVirt))]; } 1597 { int arr[F(__is_trivially_copyable(DerivesHasCopyAssign))]; } 1598 { int arr[F(__is_trivially_copyable(DerivesHasMoveAssign))]; } 1599 { int arr[F(__is_trivially_copyable(DerivesHasDest))]; } 1600 { int arr[F(__is_trivially_copyable(DerivesHasVirt))]; } 1601 { int arr[F(__is_trivially_copyable(void))]; } 1602 { int arr[F(__is_trivially_copyable(cvoid))]; } 1603 } 1604 1605 void array_rank() { 1606 int t01[T(__array_rank(IntAr) == 1)]; 1607 int t02[T(__array_rank(ConstIntArAr) == 2)]; 1608 } 1609 1610 void array_extent() { 1611 int t01[T(__array_extent(IntAr, 0) == 10)]; 1612 int t02[T(__array_extent(ConstIntArAr, 0) == 4)]; 1613 int t03[T(__array_extent(ConstIntArAr, 1) == 10)]; 1614 } 1615