test/SemaCXX/type-traits.cpp

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