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