brintos / llvm-project-archived public Read only

1// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted -Wno-c++17-extensions  %s2// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++14 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted -Wno-c++17-extensions  %s3// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++17 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted  %s4// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++20 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted  %s5 6 7struct NonPOD { NonPOD(int); };8typedef NonPOD NonPODAr[10];9typedef NonPOD NonPODArNB[];10typedef NonPOD NonPODArMB[10][2];11 12// PODs13enum Enum { EV };14enum SignedEnum : signed int { };15enum UnsignedEnum : unsigned int { };16enum class EnumClass { EV };17enum class SignedEnumClass : signed int {};18enum class UnsignedEnumClass : unsigned int {};19struct POD { Enum e; int i; float f; NonPOD* p; };20struct Empty {};21struct IncompleteStruct; // expected-note {{forward declaration of 'IncompleteStruct'}}22typedef Empty EmptyAr[10];23typedef Empty EmptyArNB[];24typedef Empty EmptyArMB[1][2];25typedef int Int;26typedef Int IntAr[10];27typedef Int IntArNB[];28typedef Int IntArZero[0];29class Statics { static int priv; static NonPOD np; };30union EmptyUnion {};31union IncompleteUnion; // expected-note {{forward declaration of 'IncompleteUnion'}}32union Union { int i; float f; };33struct HasFunc { void f (); };34struct HasOp { void operator *(); };35struct HasConv { operator int(); };36struct HasAssign { void operator =(int); };37 38struct HasAnonymousUnion {39  union {40    int i;41    float f;42  };43};44 45typedef int Vector __attribute__((vector_size(16)));46typedef int VectorExt __attribute__((ext_vector_type(4)));47 48using ComplexFloat = _Complex float;49using ComplexInt = _Complex int;50 51// Not PODs52typedef const void cvoid;53struct Derives : POD {};54typedef Derives DerivesAr[10];55typedef Derives DerivesArNB[];56struct DerivesEmpty : Empty {};57struct HasCons { HasCons(int); };58struct HasDefaultCons { HasDefaultCons() = default; };59struct HasExplicitDefaultCons { explicit HasExplicitDefaultCons() = default; };60struct HasInheritedCons : HasDefaultCons { using HasDefaultCons::HasDefaultCons; };61struct HasNoInheritedCons : HasCons {};62struct HasCopyAssign { HasCopyAssign operator =(const HasCopyAssign&); };63struct HasMoveAssign { HasMoveAssign operator =(const HasMoveAssign&&); };64struct HasNoThrowMoveAssign {65  HasNoThrowMoveAssign& operator=(66    const HasNoThrowMoveAssign&&) throw(); };67struct HasNoExceptNoThrowMoveAssign {68  HasNoExceptNoThrowMoveAssign& operator=(69    const HasNoExceptNoThrowMoveAssign&&) noexcept;70};71struct HasThrowMoveAssign {72  HasThrowMoveAssign& operator=(const HasThrowMoveAssign&&)73#if __cplusplus <= 201402L74  throw(POD);75#else76  noexcept(false);77#endif78};79 80 81struct HasNoExceptFalseMoveAssign {82  HasNoExceptFalseMoveAssign& operator=(83    const HasNoExceptFalseMoveAssign&&) noexcept(false); };84struct HasMoveCtor { HasMoveCtor(const HasMoveCtor&&); };85struct HasMemberMoveCtor { HasMoveCtor member; };86struct HasMemberMoveAssign { HasMoveAssign member; };87struct HasStaticMemberMoveCtor { static HasMoveCtor member; };88struct HasStaticMemberMoveAssign { static HasMoveAssign member; };89struct HasMemberThrowMoveAssign { HasThrowMoveAssign member; };90struct HasMemberNoExceptFalseMoveAssign {91  HasNoExceptFalseMoveAssign member; };92struct HasMemberNoThrowMoveAssign { HasNoThrowMoveAssign member; };93struct HasMemberNoExceptNoThrowMoveAssign {94  HasNoExceptNoThrowMoveAssign member; };95 96struct HasDefaultTrivialCopyAssign {97  HasDefaultTrivialCopyAssign &operator=(98    const HasDefaultTrivialCopyAssign&) = default;99};100struct TrivialMoveButNotCopy {101  TrivialMoveButNotCopy &operator=(TrivialMoveButNotCopy&&) = default;102  TrivialMoveButNotCopy &operator=(const TrivialMoveButNotCopy&);103};104struct NonTrivialDefault {105  NonTrivialDefault();106};107 108struct HasDest { ~HasDest(); };109class  HasPriv { int priv; };110class  HasProt { protected: int prot; };111struct HasRef { int i; int& ref; HasRef() : i(0), ref(i) {} };112struct HasRefAggregate { int i; int& ref; };113struct HasNonPOD { NonPOD np; };114struct HasVirt { virtual void Virt() {}; };115typedef NonPOD NonPODAr[10];116typedef HasVirt VirtAr[10];117typedef NonPOD NonPODArNB[];118union NonPODUnion { int i; Derives n; };119struct DerivesHasCons : HasCons {};120struct DerivesHasCopyAssign : HasCopyAssign {};121struct DerivesHasMoveAssign : HasMoveAssign {};122struct DerivesHasDest : HasDest {};123struct DerivesHasPriv : HasPriv {};124struct DerivesHasProt : HasProt {};125struct DerivesHasRef : HasRef {};126struct DerivesHasVirt : HasVirt {};127struct DerivesHasMoveCtor : HasMoveCtor {};128 129struct HasNoThrowCopyAssign {130  void operator =(const HasNoThrowCopyAssign&) throw();131};132struct HasMultipleCopyAssign {133  void operator =(const HasMultipleCopyAssign&) throw();134  void operator =(volatile HasMultipleCopyAssign&);135};136struct HasMultipleNoThrowCopyAssign {137  void operator =(const HasMultipleNoThrowCopyAssign&) throw();138  void operator =(volatile HasMultipleNoThrowCopyAssign&) throw();139};140 141struct HasNoThrowConstructor { HasNoThrowConstructor() throw(); };142struct HasNoThrowConstructorWithArgs {143  HasNoThrowConstructorWithArgs(HasCons i = HasCons(0)) throw();144};145struct HasMultipleDefaultConstructor1 {146  HasMultipleDefaultConstructor1() throw();147  HasMultipleDefaultConstructor1(int i = 0);148};149struct HasMultipleDefaultConstructor2 {150  HasMultipleDefaultConstructor2(int i = 0);151  HasMultipleDefaultConstructor2() throw();152};153 154struct HasNoThrowCopy { HasNoThrowCopy(const HasNoThrowCopy&) throw(); };155struct HasMultipleCopy {156  HasMultipleCopy(const HasMultipleCopy&) throw();157  HasMultipleCopy(volatile HasMultipleCopy&);158};159struct HasMultipleNoThrowCopy {160  HasMultipleNoThrowCopy(const HasMultipleNoThrowCopy&) throw();161  HasMultipleNoThrowCopy(volatile HasMultipleNoThrowCopy&) throw();162};163 164struct HasVirtDest { virtual ~HasVirtDest(); };165struct DerivedVirtDest : HasVirtDest {};166typedef HasVirtDest VirtDestAr[1];167 168class AllPrivate {169  AllPrivate() throw();170  AllPrivate(const AllPrivate&) throw();171  AllPrivate &operator=(const AllPrivate &) throw();172  ~AllPrivate() throw();173};174 175struct ThreeArgCtor {176  ThreeArgCtor(int*, char*, int);177};178 179struct VariadicCtor {180  template<typename...T> VariadicCtor(T...);181};182 183struct ThrowingDtor {184  ~ThrowingDtor()185#if __cplusplus <= 201402L186  throw(int);187#else188  noexcept(false);189#endif190};191 192struct NoExceptDtor {193  ~NoExceptDtor() noexcept(true);194};195 196struct NoThrowDtor {197  ~NoThrowDtor() throw();198};199 200struct ACompleteType {};201struct AnIncompleteType; // expected-note 1+ {{forward declaration of 'AnIncompleteType'}}202typedef AnIncompleteType AnIncompleteTypeAr[42];203typedef AnIncompleteType AnIncompleteTypeArNB[];204typedef AnIncompleteType AnIncompleteTypeArMB[1][10];205 206struct HasInClassInit {207  int x = 42;208};209 210struct HasPrivateBase : private ACompleteType {};211struct HasProtectedBase : protected ACompleteType {};212struct HasVirtBase : virtual ACompleteType {};213 214void is_pod()215{216  static_assert(__is_pod(int));217  static_assert(__is_pod(Enum));218  static_assert(__is_pod(POD));219  static_assert(__is_pod(Int));220  static_assert(__is_pod(IntAr));221  static_assert(__is_pod(Statics));222  static_assert(__is_pod(Empty));223  static_assert(__is_pod(EmptyUnion));224  static_assert(__is_pod(Union));225  static_assert(__is_pod(HasFunc));226  static_assert(__is_pod(HasOp));227  static_assert(__is_pod(HasConv));228  static_assert(__is_pod(HasAssign));229  static_assert(__is_pod(IntArNB));230  static_assert(__is_pod(HasAnonymousUnion));231  static_assert(__is_pod(Vector));232  static_assert(__is_pod(VectorExt));233  static_assert(__is_pod(Derives));234  static_assert(__is_pod(DerivesAr));235  static_assert(__is_pod(DerivesArNB));236  static_assert(__is_pod(DerivesEmpty));237  static_assert(__is_pod(HasPriv));238  static_assert(__is_pod(HasProt));239  static_assert(__is_pod(DerivesHasPriv));240  static_assert(__is_pod(DerivesHasProt));241 242  static_assert(!__is_pod(HasCons));243  static_assert(!__is_pod(HasCopyAssign));244  static_assert(!__is_pod(HasMoveAssign));245  static_assert(!__is_pod(HasDest));246  static_assert(!__is_pod(HasRef));247  static_assert(!__is_pod(HasVirt));248  static_assert(!__is_pod(DerivesHasCons));249  static_assert(!__is_pod(DerivesHasCopyAssign));250  static_assert(!__is_pod(DerivesHasMoveAssign));251  static_assert(!__is_pod(DerivesHasDest));252  static_assert(!__is_pod(DerivesHasRef));253  static_assert(!__is_pod(DerivesHasVirt));254  static_assert(!__is_pod(NonPOD));255  static_assert(!__is_pod(HasNonPOD));256  static_assert(!__is_pod(NonPODAr));257  static_assert(!__is_pod(NonPODArNB));258  static_assert(!__is_pod(void));259  static_assert(!__is_pod(cvoid));260// static_assert(!__is_pod(NonPODUnion));261 262  static_assert(__is_pod(ACompleteType));263  static_assert(!__is_pod(AnIncompleteType)); // expected-error {{incomplete type}}264  static_assert(!__is_pod(AnIncompleteType[])); // expected-error {{incomplete type}}265  static_assert(!__is_pod(AnIncompleteType[1])); // expected-error {{incomplete type}}266}267 268typedef Empty EmptyAr[10];269struct Bit0 { int : 0; };270struct Bit0Cons { int : 0; Bit0Cons(); };271struct AnonBitOnly { int : 3; };272struct BitOnly { int x : 3; };273struct DerivesVirt : virtual POD {};274 275void is_empty()276{277  static_assert(__is_empty(Empty));278  static_assert(__is_empty(DerivesEmpty));279  static_assert(__is_empty(HasCons));280  static_assert(__is_empty(HasCopyAssign));281  static_assert(__is_empty(HasMoveAssign));282  static_assert(__is_empty(HasDest));283  static_assert(__is_empty(HasFunc));284  static_assert(__is_empty(HasOp));285  static_assert(__is_empty(HasConv));286  static_assert(__is_empty(HasAssign));287  static_assert(__is_empty(Bit0));288  static_assert(__is_empty(Bit0Cons));289 290  static_assert(!__is_empty(Int));291  static_assert(!__is_empty(POD));292  static_assert(!__is_empty(EmptyUnion));293  static_assert(!__is_empty(IncompleteUnion));294  static_assert(!__is_empty(EmptyAr));295  static_assert(!__is_empty(HasRef));296  static_assert(!__is_empty(HasVirt));297  static_assert(!__is_empty(AnonBitOnly));298  static_assert(!__is_empty(BitOnly));299  static_assert(!__is_empty(void));300  static_assert(!__is_empty(IntArNB));301  static_assert(!__is_empty(HasAnonymousUnion));302//  static_assert(!__is_empty(DerivesVirt));303 304  static_assert(__is_empty(ACompleteType));305  static_assert(!__is_empty(AnIncompleteType)); // expected-error {{incomplete type}}306  static_assert(!__is_empty(AnIncompleteType[]));307  static_assert(!__is_empty(AnIncompleteType[1]));308}309 310typedef Derives ClassType;311 312void is_class()313{314  static_assert(__is_class(Derives));315  static_assert(__is_class(HasPriv));316  static_assert(__is_class(ClassType));317  static_assert(__is_class(HasAnonymousUnion));318 319  static_assert(!__is_class(int));320  static_assert(!__is_class(Enum));321  static_assert(!__is_class(Int));322  static_assert(!__is_class(IntAr));323  static_assert(!__is_class(DerivesAr));324  static_assert(!__is_class(Union));325  static_assert(!__is_class(cvoid));326  static_assert(!__is_class(IntArNB));327}328 329typedef Union UnionAr[10];330typedef Union UnionType;331 332void is_union()333{334  static_assert(__is_union(Union));335  static_assert(__is_union(UnionType));336 337  static_assert(!__is_union(int));338  static_assert(!__is_union(Enum));339  static_assert(!__is_union(Int));340  static_assert(!__is_union(IntAr));341  static_assert(!__is_union(UnionAr));342  static_assert(!__is_union(cvoid));343  static_assert(!__is_union(IntArNB));344  static_assert(!__is_union(HasAnonymousUnion));345}346 347typedef Enum EnumType;348typedef EnumClass EnumClassType;349 350void is_enum()351{352  static_assert(__is_enum(Enum));353  static_assert(__is_enum(EnumType));354  static_assert(__is_enum(SignedEnum));355  static_assert(__is_enum(UnsignedEnum));356 357  static_assert(__is_enum(EnumClass));358  static_assert(__is_enum(EnumClassType));359  static_assert(__is_enum(SignedEnumClass));360  static_assert(__is_enum(UnsignedEnumClass));361 362  static_assert(!__is_enum(int));363  static_assert(!__is_enum(Union));364  static_assert(!__is_enum(Int));365  static_assert(!__is_enum(IntAr));366  static_assert(!__is_enum(UnionAr));367  static_assert(!__is_enum(Derives));368  static_assert(!__is_enum(ClassType));369  static_assert(!__is_enum(cvoid));370  static_assert(!__is_enum(IntArNB));371  static_assert(!__is_enum(HasAnonymousUnion));372  static_assert(!__is_enum(AnIncompleteType));373  static_assert(!__is_enum(AnIncompleteTypeAr));374  static_assert(!__is_enum(AnIncompleteTypeArMB));375  static_assert(!__is_enum(AnIncompleteTypeArNB));376}377 378void is_scoped_enum() {379  static_assert(!__is_scoped_enum(Enum));380  static_assert(!__is_scoped_enum(EnumType));381  static_assert(!__is_scoped_enum(SignedEnum));382  static_assert(!__is_scoped_enum(UnsignedEnum));383 384  static_assert(__is_scoped_enum(EnumClass));385  static_assert(__is_scoped_enum(EnumClassType));386  static_assert(__is_scoped_enum(SignedEnumClass));387  static_assert(__is_scoped_enum(UnsignedEnumClass));388 389  static_assert(!__is_scoped_enum(int));390  static_assert(!__is_scoped_enum(Union));391  static_assert(!__is_scoped_enum(Int));392  static_assert(!__is_scoped_enum(IntAr));393  static_assert(!__is_scoped_enum(UnionAr));394  static_assert(!__is_scoped_enum(Derives));395  static_assert(!__is_scoped_enum(ClassType));396  static_assert(!__is_scoped_enum(cvoid));397  static_assert(!__is_scoped_enum(IntArNB));398  static_assert(!__is_scoped_enum(HasAnonymousUnion));399  static_assert(!__is_scoped_enum(AnIncompleteType));400  static_assert(!__is_scoped_enum(AnIncompleteTypeAr));401  static_assert(!__is_scoped_enum(AnIncompleteTypeArMB));402  static_assert(!__is_scoped_enum(AnIncompleteTypeArNB));403}404 405struct FinalClass final {406};407 408template<typename T>409struct PotentiallyFinal { };410 411template<typename T>412struct PotentiallyFinal<T*> final { };413 414template<>415struct PotentiallyFinal<int> final { };416 417struct FwdDeclFinal;418using FwdDeclFinalAlias = FwdDeclFinal;419struct FwdDeclFinal final {};420 421 422 423 424void is_final()425{426	static_assert(__is_final(FinalClass));427	static_assert(__is_final(PotentiallyFinal<float*>));428	static_assert(__is_final(PotentiallyFinal<int>));429        static_assert(__is_final(FwdDeclFinal));430        static_assert(__is_final(FwdDeclFinalAlias));431 432	static_assert(!__is_final(int));433	static_assert(!__is_final(Union));434	static_assert(!__is_final(Int));435	static_assert(!__is_final(IntAr));436	static_assert(!__is_final(UnionAr));437	static_assert(!__is_final(Derives));438	static_assert(!__is_final(ClassType));439	static_assert(!__is_final(cvoid));440	static_assert(!__is_final(IntArNB));441	static_assert(!__is_final(HasAnonymousUnion));442}443 444 445typedef HasVirt Polymorph;446struct InheritPolymorph : Polymorph {};447 448void is_polymorphic()449{450  static_assert(__is_polymorphic(Polymorph));451  static_assert(__is_polymorphic(InheritPolymorph));452 453  static_assert(!__is_polymorphic(int));454  static_assert(!__is_polymorphic(Union));455  static_assert(!__is_polymorphic(IncompleteUnion));456  static_assert(!__is_polymorphic(Int));457  static_assert(!__is_polymorphic(IntAr));458  static_assert(!__is_polymorphic(UnionAr));459  static_assert(!__is_polymorphic(Derives));460  static_assert(!__is_polymorphic(ClassType));461  static_assert(!__is_polymorphic(Enum));462  static_assert(!__is_polymorphic(cvoid));463  static_assert(!__is_polymorphic(IntArNB));464}465 466void is_integral()467{468  static_assert(__is_integral(bool));469  static_assert(__is_integral(char));470  static_assert(__is_integral(signed char));471  static_assert(__is_integral(unsigned char));472  //static_assert(__is_integral(char16_t));473  //static_assert(__is_integral(char32_t));474  static_assert(__is_integral(wchar_t));475  static_assert(__is_integral(short));476  static_assert(__is_integral(unsigned short));477  static_assert(__is_integral(int));478  static_assert(__is_integral(unsigned int));479  static_assert(__is_integral(long));480  static_assert(__is_integral(unsigned long));481 482  static_assert(!__is_integral(float));483  static_assert(!__is_integral(double));484  static_assert(!__is_integral(long double));485  static_assert(!__is_integral(Union));486  static_assert(!__is_integral(UnionAr));487  static_assert(!__is_integral(Derives));488  static_assert(!__is_integral(ClassType));489  static_assert(!__is_integral(Enum));490  static_assert(!__is_integral(void));491  static_assert(!__is_integral(cvoid));492  static_assert(!__is_integral(IntArNB));493}494 495void is_floating_point()496{497  static_assert(__is_floating_point(float));498  static_assert(__is_floating_point(double));499  static_assert(__is_floating_point(long double));500 501  static_assert(!__is_floating_point(bool));502  static_assert(!__is_floating_point(char));503  static_assert(!__is_floating_point(signed char));504  static_assert(!__is_floating_point(unsigned char));505  //static_assert(!__is_floating_point(char16_t));506  //static_assert(!__is_floating_point(char32_t));507  static_assert(!__is_floating_point(wchar_t));508  static_assert(!__is_floating_point(short));509  static_assert(!__is_floating_point(unsigned short));510  static_assert(!__is_floating_point(int));511  static_assert(!__is_floating_point(unsigned int));512  static_assert(!__is_floating_point(long));513  static_assert(!__is_floating_point(unsigned long));514  static_assert(!__is_floating_point(Union));515  static_assert(!__is_floating_point(UnionAr));516  static_assert(!__is_floating_point(Derives));517  static_assert(!__is_floating_point(ClassType));518  static_assert(!__is_floating_point(Enum));519  static_assert(!__is_floating_point(void));520  static_assert(!__is_floating_point(cvoid));521  static_assert(!__is_floating_point(IntArNB));522}523 524template <class T>525struct AggregateTemplate {526  T value;527};528 529template <class T>530struct NonAggregateTemplate {531  T value;532  NonAggregateTemplate();533};534 535void is_aggregate()536{537  constexpr bool TrueAfterCpp11 = __cplusplus > 201103L;538  constexpr bool TrueAfterCpp14 = __cplusplus > 201402L;539 540  __is_aggregate(AnIncompleteType); // expected-error {{incomplete type}}541  __is_aggregate(IncompleteUnion); // expected-error {{incomplete type}}542 543  // Valid since LWG3823544  static_assert(__is_aggregate(AnIncompleteType[]));545  static_assert(__is_aggregate(AnIncompleteType[1]));546  static_assert(__is_aggregate(AnIncompleteTypeAr));547  static_assert(__is_aggregate(AnIncompleteTypeArNB));548  static_assert(__is_aggregate(AnIncompleteTypeArMB));549 550  static_assert(!__is_aggregate(NonPOD));551  static_assert(__is_aggregate(NonPODAr));552  static_assert(__is_aggregate(NonPODArNB));553  static_assert(__is_aggregate(NonPODArMB));554 555  static_assert(!__is_aggregate(Enum));556  static_assert(__is_aggregate(POD));557  static_assert(__is_aggregate(Empty));558  static_assert(__is_aggregate(EmptyAr));559  static_assert(__is_aggregate(EmptyArNB));560  static_assert(__is_aggregate(EmptyArMB));561  static_assert(!__is_aggregate(void));562  static_assert(!__is_aggregate(const volatile void));563  static_assert(!__is_aggregate(int));564  static_assert(__is_aggregate(IntAr));565  static_assert(__is_aggregate(IntArNB));566  static_assert(__is_aggregate(EmptyUnion));567  static_assert(__is_aggregate(Union));568  static_assert(__is_aggregate(Statics));569  static_assert(__is_aggregate(HasFunc));570  static_assert(__is_aggregate(HasOp));571  static_assert(__is_aggregate(HasAssign));572  static_assert(__is_aggregate(HasAnonymousUnion));573 574  static_assert(__is_aggregate(Derives) == TrueAfterCpp14);575  static_assert(__is_aggregate(DerivesAr));576  static_assert(__is_aggregate(DerivesArNB));577  static_assert(!__is_aggregate(HasCons));578#if __cplusplus >= 202002L579  static_assert(!__is_aggregate(HasDefaultCons));580#else581  static_assert(__is_aggregate(HasDefaultCons));582#endif583  static_assert(!__is_aggregate(HasExplicitDefaultCons));584  static_assert(!__is_aggregate(HasInheritedCons));585  static_assert(__is_aggregate(HasNoInheritedCons) == TrueAfterCpp14);586  static_assert(__is_aggregate(HasCopyAssign));587  static_assert(!__is_aggregate(NonTrivialDefault));588  static_assert(__is_aggregate(HasDest));589  static_assert(!__is_aggregate(HasPriv));590  static_assert(!__is_aggregate(HasProt));591  static_assert(__is_aggregate(HasRefAggregate));592  static_assert(__is_aggregate(HasNonPOD));593  static_assert(!__is_aggregate(HasVirt));594  static_assert(__is_aggregate(VirtAr));595  static_assert(__is_aggregate(HasInClassInit) == TrueAfterCpp11);596  static_assert(!__is_aggregate(HasPrivateBase));597  static_assert(!__is_aggregate(HasProtectedBase));598  static_assert(!__is_aggregate(HasVirtBase));599 600  static_assert(__is_aggregate(AggregateTemplate<int>));601  static_assert(!__is_aggregate(NonAggregateTemplate<int>));602 603  static_assert(__is_aggregate(Vector)); // Extension supported by GCC and Clang604  static_assert(__is_aggregate(VectorExt));605  static_assert(__is_aggregate(ComplexInt));606  static_assert(__is_aggregate(ComplexFloat));607}608 609void is_arithmetic()610{611  static_assert(__is_arithmetic(float));612  static_assert(__is_arithmetic(double));613  static_assert(__is_arithmetic(long double));614  static_assert(__is_arithmetic(bool));615  static_assert(__is_arithmetic(char));616  static_assert(__is_arithmetic(signed char));617  static_assert(__is_arithmetic(unsigned char));618  //static_assert(__is_arithmetic(char16_t));619  //static_assert(__is_arithmetic(char32_t));620  static_assert(__is_arithmetic(wchar_t));621  static_assert(__is_arithmetic(short));622  static_assert(__is_arithmetic(unsigned short));623  static_assert(__is_arithmetic(int));624  static_assert(__is_arithmetic(unsigned int));625  static_assert(__is_arithmetic(long));626  static_assert(__is_arithmetic(unsigned long));627 628  static_assert(!__is_arithmetic(Union));629  static_assert(!__is_arithmetic(UnionAr));630  static_assert(!__is_arithmetic(Derives));631  static_assert(!__is_arithmetic(ClassType));632  static_assert(!__is_arithmetic(Enum));633  static_assert(!__is_arithmetic(void));634  static_assert(!__is_arithmetic(cvoid));635  static_assert(!__is_arithmetic(IntArNB));636}637 638void is_complete_type()639{640  static_assert(__is_complete_type(float));641  static_assert(__is_complete_type(double));642  static_assert(__is_complete_type(long double));643  static_assert(__is_complete_type(bool));644  static_assert(__is_complete_type(char));645  static_assert(__is_complete_type(signed char));646  static_assert(__is_complete_type(unsigned char));647  //static_assert(__is_complete_type(char16_t));648  //static_assert(__is_complete_type(char32_t));649  static_assert(__is_complete_type(wchar_t));650  static_assert(__is_complete_type(short));651  static_assert(__is_complete_type(unsigned short));652  static_assert(__is_complete_type(int));653  static_assert(__is_complete_type(unsigned int));654  static_assert(__is_complete_type(long));655  static_assert(__is_complete_type(unsigned long));656  static_assert(__is_complete_type(ACompleteType));657 658  static_assert(!__is_complete_type(AnIncompleteType));659}660 661void is_void()662{663  static_assert(__is_void(void));664  static_assert(__is_void(cvoid));665 666  static_assert(!__is_void(float));667  static_assert(!__is_void(double));668  static_assert(!__is_void(long double));669  static_assert(!__is_void(bool));670  static_assert(!__is_void(char));671  static_assert(!__is_void(signed char));672  static_assert(!__is_void(unsigned char));673  static_assert(!__is_void(wchar_t));674  static_assert(!__is_void(short));675  static_assert(!__is_void(unsigned short));676  static_assert(!__is_void(int));677  static_assert(!__is_void(unsigned int));678  static_assert(!__is_void(long));679  static_assert(!__is_void(unsigned long));680  static_assert(!__is_void(Union));681  static_assert(!__is_void(UnionAr));682  static_assert(!__is_void(Derives));683  static_assert(!__is_void(ClassType));684  static_assert(!__is_void(Enum));685  static_assert(!__is_void(IntArNB));686  static_assert(!__is_void(void*));687  static_assert(!__is_void(cvoid*));688}689 690void is_array()691{692  static_assert(__is_array(IntAr));693  static_assert(__is_array(IntArNB));694  static_assert(!__is_array(IntArZero));695  static_assert(__is_array(UnionAr));696 697  static_assert(!__is_array(void));698  static_assert(!__is_array(cvoid));699  static_assert(!__is_array(float));700  static_assert(!__is_array(double));701  static_assert(!__is_array(long double));702  static_assert(!__is_array(bool));703  static_assert(!__is_array(char));704  static_assert(!__is_array(signed char));705  static_assert(!__is_array(unsigned char));706  static_assert(!__is_array(wchar_t));707  static_assert(!__is_array(short));708  static_assert(!__is_array(unsigned short));709  static_assert(!__is_array(int));710  static_assert(!__is_array(unsigned int));711  static_assert(!__is_array(long));712  static_assert(!__is_array(unsigned long));713  static_assert(!__is_array(Union));714  static_assert(!__is_array(Derives));715  static_assert(!__is_array(ClassType));716  static_assert(!__is_array(Enum));717  static_assert(!__is_array(void*));718  static_assert(!__is_array(cvoid*));719}720 721void is_bounded_array(int n) {722  static_assert(__is_bounded_array(IntAr));723  static_assert(!__is_bounded_array(IntArNB));724  static_assert(!__is_bounded_array(IntArZero));725  static_assert(__is_bounded_array(UnionAr));726 727  static_assert(!__is_bounded_array(void));728  static_assert(!__is_bounded_array(cvoid));729  static_assert(!__is_bounded_array(float));730  static_assert(!__is_bounded_array(double));731  static_assert(!__is_bounded_array(long double));732  static_assert(!__is_bounded_array(bool));733  static_assert(!__is_bounded_array(char));734  static_assert(!__is_bounded_array(signed char));735  static_assert(!__is_bounded_array(unsigned char));736  static_assert(!__is_bounded_array(wchar_t));737  static_assert(!__is_bounded_array(short));738  static_assert(!__is_bounded_array(unsigned short));739  static_assert(!__is_bounded_array(int));740  static_assert(!__is_bounded_array(unsigned int));741  static_assert(!__is_bounded_array(long));742  static_assert(!__is_bounded_array(unsigned long));743  static_assert(!__is_bounded_array(Union));744  static_assert(!__is_bounded_array(Derives));745  static_assert(!__is_bounded_array(ClassType));746  static_assert(!__is_bounded_array(Enum));747  static_assert(!__is_bounded_array(void *));748  static_assert(!__is_bounded_array(cvoid *));749 750  int t32[n];751  (void)__is_bounded_array(decltype(t32)); // expected-error{{variable length arrays are not supported in '__is_bounded_array'}}752}753 754void is_unbounded_array(int n) {755  static_assert(!__is_unbounded_array(IntAr));756  static_assert(__is_unbounded_array(IntArNB));757  static_assert(!__is_unbounded_array(IntArZero));758  static_assert(!__is_unbounded_array(UnionAr));759 760  static_assert(!__is_unbounded_array(void));761  static_assert(!__is_unbounded_array(cvoid));762  static_assert(!__is_unbounded_array(float));763  static_assert(!__is_unbounded_array(double));764  static_assert(!__is_unbounded_array(long double));765  static_assert(!__is_unbounded_array(bool));766  static_assert(!__is_unbounded_array(char));767  static_assert(!__is_unbounded_array(signed char));768  static_assert(!__is_unbounded_array(unsigned char));769  static_assert(!__is_unbounded_array(wchar_t));770  static_assert(!__is_unbounded_array(short));771  static_assert(!__is_unbounded_array(unsigned short));772  static_assert(!__is_unbounded_array(int));773  static_assert(!__is_unbounded_array(unsigned int));774  static_assert(!__is_unbounded_array(long));775  static_assert(!__is_unbounded_array(unsigned long));776  static_assert(!__is_unbounded_array(Union));777  static_assert(!__is_unbounded_array(Derives));778  static_assert(!__is_unbounded_array(ClassType));779  static_assert(!__is_unbounded_array(Enum));780  static_assert(!__is_unbounded_array(void *));781  static_assert(!__is_unbounded_array(cvoid *));782 783  int t32[n];784  (void)__is_unbounded_array(decltype(t32)); // expected-error{{variable length arrays are not supported in '__is_unbounded_array'}}785}786 787template <typename T> void tmpl_func(T&) {}788 789template <typename T> struct type_wrapper {790  typedef T type;791  typedef T* ptrtype;792  typedef T& reftype;793};794 795void is_function()796{797  static_assert(__is_function(type_wrapper<void(void)>::type));798  static_assert(__is_function(typeof(tmpl_func<int>)));799 800  typedef void (*ptr_to_func_type)(void);801 802  static_assert(!__is_function(void));803  static_assert(!__is_function(cvoid));804  static_assert(!__is_function(float));805  static_assert(!__is_function(double));806  static_assert(!__is_function(long double));807  static_assert(!__is_function(bool));808  static_assert(!__is_function(char));809  static_assert(!__is_function(signed char));810  static_assert(!__is_function(unsigned char));811  static_assert(!__is_function(wchar_t));812  static_assert(!__is_function(short));813  static_assert(!__is_function(unsigned short));814  static_assert(!__is_function(int));815  static_assert(!__is_function(unsigned int));816  static_assert(!__is_function(long));817  static_assert(!__is_function(unsigned long));818  static_assert(!__is_function(Union));819  static_assert(!__is_function(Derives));820  static_assert(!__is_function(ClassType));821  static_assert(!__is_function(Enum));822  static_assert(!__is_function(void*));823  static_assert(!__is_function(cvoid*));824  static_assert(!__is_function(void(*)()));825  static_assert(!__is_function(ptr_to_func_type));826  static_assert(!__is_function(type_wrapper<void(void)>::ptrtype));827  static_assert(!__is_function(type_wrapper<void(void)>::reftype));828}829 830void is_reference()831{832  static_assert(__is_reference(int&));833  static_assert(__is_reference(const int&));834  static_assert(__is_reference(void *&));835 836  static_assert(!__is_reference(int));837  static_assert(!__is_reference(const int));838  static_assert(!__is_reference(void *));839}840 841void is_lvalue_reference()842{843  static_assert(__is_lvalue_reference(int&));844  static_assert(__is_lvalue_reference(void *&));845  static_assert(__is_lvalue_reference(const int&));846  static_assert(__is_lvalue_reference(void * const &));847 848  static_assert(!__is_lvalue_reference(int));849  static_assert(!__is_lvalue_reference(const int));850  static_assert(!__is_lvalue_reference(void *));851}852 853#if __has_feature(cxx_rvalue_references)854 855void is_rvalue_reference()856{857  static_assert(__is_rvalue_reference(const int&&));858  static_assert(__is_rvalue_reference(void * const &&));859 860  static_assert(!__is_rvalue_reference(int&));861  static_assert(!__is_rvalue_reference(void *&));862  static_assert(!__is_rvalue_reference(const int&));863  static_assert(!__is_rvalue_reference(void * const &));864  static_assert(!__is_rvalue_reference(int));865  static_assert(!__is_rvalue_reference(const int));866  static_assert(!__is_rvalue_reference(void *));867}868 869#endif870 871void is_fundamental()872{873  static_assert(__is_fundamental(float));874  static_assert(__is_fundamental(double));875  static_assert(__is_fundamental(long double));876  static_assert(__is_fundamental(bool));877  static_assert(__is_fundamental(char));878  static_assert(__is_fundamental(signed char));879  static_assert(__is_fundamental(unsigned char));880  //static_assert(__is_fundamental(char16_t));881  //static_assert(__is_fundamental(char32_t));882  static_assert(__is_fundamental(wchar_t));883  static_assert(__is_fundamental(short));884  static_assert(__is_fundamental(unsigned short));885  static_assert(__is_fundamental(int));886  static_assert(__is_fundamental(unsigned int));887  static_assert(__is_fundamental(long));888  static_assert(__is_fundamental(unsigned long));889  static_assert(__is_fundamental(void));890  static_assert(__is_fundamental(cvoid));891  static_assert(__is_fundamental(decltype(nullptr)));892 893  static_assert(!__is_fundamental(Union));894  static_assert(!__is_fundamental(UnionAr));895  static_assert(!__is_fundamental(Derives));896  static_assert(!__is_fundamental(ClassType));897  static_assert(!__is_fundamental(Enum));898  static_assert(!__is_fundamental(IntArNB));899}900 901void is_object()902{903  static_assert(__is_object(int));904  static_assert(__is_object(int *));905  static_assert(__is_object(void *));906  static_assert(__is_object(Union));907  static_assert(__is_object(UnionAr));908  static_assert(__is_object(ClassType));909  static_assert(__is_object(Enum));910 911  static_assert(!__is_object(type_wrapper<void(void)>::type));912  static_assert(!__is_object(int&));913  static_assert(!__is_object(void));914}915 916void is_scalar()917{918  static_assert(__is_scalar(float));919  static_assert(__is_scalar(double));920  static_assert(__is_scalar(long double));921  static_assert(__is_scalar(bool));922  static_assert(__is_scalar(char));923  static_assert(__is_scalar(signed char));924  static_assert(__is_scalar(unsigned char));925  static_assert(__is_scalar(wchar_t));926  static_assert(__is_scalar(short));927  static_assert(__is_scalar(unsigned short));928  static_assert(__is_scalar(int));929  static_assert(__is_scalar(unsigned int));930  static_assert(__is_scalar(long));931  static_assert(__is_scalar(unsigned long));932  static_assert(__is_scalar(Enum));933  static_assert(__is_scalar(void*));934  static_assert(__is_scalar(cvoid*));935 936  static_assert(!__is_scalar(void));937  static_assert(!__is_scalar(cvoid));938  static_assert(!__is_scalar(Union));939  static_assert(!__is_scalar(UnionAr));940  static_assert(!__is_scalar(Derives));941  static_assert(!__is_scalar(ClassType));942  static_assert(!__is_scalar(IntArNB));943}944 945struct StructWithMembers {946  int member;947  void method() {}948};949 950void is_compound()951{952  static_assert(__is_compound(void*));953  static_assert(__is_compound(cvoid*));954  static_assert(__is_compound(void (*)()));955  static_assert(__is_compound(int StructWithMembers::*));956  static_assert(__is_compound(void (StructWithMembers::*)()));957  static_assert(__is_compound(int&));958  static_assert(__is_compound(Union));959  static_assert(__is_compound(UnionAr));960  static_assert(__is_compound(Derives));961  static_assert(__is_compound(ClassType));962  static_assert(__is_compound(IntArNB));963  static_assert(__is_compound(Enum));964 965  static_assert(!__is_compound(float));966  static_assert(!__is_compound(double));967  static_assert(!__is_compound(long double));968  static_assert(!__is_compound(bool));969  static_assert(!__is_compound(char));970  static_assert(!__is_compound(signed char));971  static_assert(!__is_compound(unsigned char));972  static_assert(!__is_compound(wchar_t));973  static_assert(!__is_compound(short));974  static_assert(!__is_compound(unsigned short));975  static_assert(!__is_compound(int));976  static_assert(!__is_compound(unsigned int));977  static_assert(!__is_compound(long));978  static_assert(!__is_compound(unsigned long));979  static_assert(!__is_compound(void));980  static_assert(!__is_compound(cvoid));981}982 983void is_pointer()984{985  StructWithMembers x;986 987  static_assert(__is_pointer(void*));988  static_assert(__is_pointer(cvoid*));989  static_assert(__is_pointer(cvoid*));990  static_assert(__is_pointer(char*));991  static_assert(__is_pointer(int*));992  static_assert(__is_pointer(int**));993  static_assert(__is_pointer(ClassType*));994  static_assert(__is_pointer(Derives*));995  static_assert(__is_pointer(Enum*));996  static_assert(__is_pointer(IntArNB*));997  static_assert(__is_pointer(Union*));998  static_assert(__is_pointer(UnionAr*));999  static_assert(__is_pointer(StructWithMembers*));1000  static_assert(__is_pointer(void (*)()));1001 1002  static_assert(!__is_pointer(void));1003  static_assert(!__is_pointer(cvoid));1004  static_assert(!__is_pointer(cvoid));1005  static_assert(!__is_pointer(char));1006  static_assert(!__is_pointer(int));1007  static_assert(!__is_pointer(int));1008  static_assert(!__is_pointer(ClassType));1009  static_assert(!__is_pointer(Derives));1010  static_assert(!__is_pointer(Enum));1011  static_assert(!__is_pointer(IntArNB));1012  static_assert(!__is_pointer(Union));1013  static_assert(!__is_pointer(UnionAr));1014  static_assert(!__is_pointer(StructWithMembers));1015  static_assert(!__is_pointer(int StructWithMembers::*));1016  static_assert(!__is_pointer(void (StructWithMembers::*) ()));1017}1018 1019void is_member_object_pointer()1020{1021  StructWithMembers x;1022 1023  static_assert(__is_member_object_pointer(int StructWithMembers::*));1024 1025  static_assert(!__is_member_object_pointer(void (StructWithMembers::*) ()));1026  static_assert(!__is_member_object_pointer(void*));1027  static_assert(!__is_member_object_pointer(cvoid*));1028  static_assert(!__is_member_object_pointer(cvoid*));1029  static_assert(!__is_member_object_pointer(char*));1030  static_assert(!__is_member_object_pointer(int*));1031  static_assert(!__is_member_object_pointer(int**));1032  static_assert(!__is_member_object_pointer(ClassType*));1033  static_assert(!__is_member_object_pointer(Derives*));1034  static_assert(!__is_member_object_pointer(Enum*));1035  static_assert(!__is_member_object_pointer(IntArNB*));1036  static_assert(!__is_member_object_pointer(Union*));1037  static_assert(!__is_member_object_pointer(UnionAr*));1038  static_assert(!__is_member_object_pointer(StructWithMembers*));1039  static_assert(!__is_member_object_pointer(void));1040  static_assert(!__is_member_object_pointer(cvoid));1041  static_assert(!__is_member_object_pointer(cvoid));1042  static_assert(!__is_member_object_pointer(char));1043  static_assert(!__is_member_object_pointer(int));1044  static_assert(!__is_member_object_pointer(int));1045  static_assert(!__is_member_object_pointer(ClassType));1046  static_assert(!__is_member_object_pointer(Derives));1047  static_assert(!__is_member_object_pointer(Enum));1048  static_assert(!__is_member_object_pointer(IntArNB));1049  static_assert(!__is_member_object_pointer(Union));1050  static_assert(!__is_member_object_pointer(UnionAr));1051  static_assert(!__is_member_object_pointer(StructWithMembers));1052  static_assert(!__is_member_object_pointer(void (*)()));1053}1054 1055void is_member_function_pointer()1056{1057  StructWithMembers x;1058 1059  static_assert(__is_member_function_pointer(void (StructWithMembers::*) ()));1060 1061  static_assert(!__is_member_function_pointer(int StructWithMembers::*));1062  static_assert(!__is_member_function_pointer(void*));1063  static_assert(!__is_member_function_pointer(cvoid*));1064  static_assert(!__is_member_function_pointer(cvoid*));1065  static_assert(!__is_member_function_pointer(char*));1066  static_assert(!__is_member_function_pointer(int*));1067  static_assert(!__is_member_function_pointer(int**));1068  static_assert(!__is_member_function_pointer(ClassType*));1069  static_assert(!__is_member_function_pointer(Derives*));1070  static_assert(!__is_member_function_pointer(Enum*));1071  static_assert(!__is_member_function_pointer(IntArNB*));1072  static_assert(!__is_member_function_pointer(Union*));1073  static_assert(!__is_member_function_pointer(UnionAr*));1074  static_assert(!__is_member_function_pointer(StructWithMembers*));1075  static_assert(!__is_member_function_pointer(void));1076  static_assert(!__is_member_function_pointer(cvoid));1077  static_assert(!__is_member_function_pointer(cvoid));1078  static_assert(!__is_member_function_pointer(char));1079  static_assert(!__is_member_function_pointer(int));1080  static_assert(!__is_member_function_pointer(int));1081  static_assert(!__is_member_function_pointer(ClassType));1082  static_assert(!__is_member_function_pointer(Derives));1083  static_assert(!__is_member_function_pointer(Enum));1084  static_assert(!__is_member_function_pointer(IntArNB));1085  static_assert(!__is_member_function_pointer(Union));1086  static_assert(!__is_member_function_pointer(UnionAr));1087  static_assert(!__is_member_function_pointer(StructWithMembers));1088  static_assert(!__is_member_function_pointer(void (*)()));1089}1090 1091void is_member_pointer()1092{1093  StructWithMembers x;1094 1095  static_assert(__is_member_pointer(int StructWithMembers::*));1096  static_assert(__is_member_pointer(void (StructWithMembers::*) ()));1097 1098  static_assert(!__is_member_pointer(void*));1099  static_assert(!__is_member_pointer(cvoid*));1100  static_assert(!__is_member_pointer(cvoid*));1101  static_assert(!__is_member_pointer(char*));1102  static_assert(!__is_member_pointer(int*));1103  static_assert(!__is_member_pointer(int**));1104  static_assert(!__is_member_pointer(ClassType*));1105  static_assert(!__is_member_pointer(Derives*));1106  static_assert(!__is_member_pointer(Enum*));1107  static_assert(!__is_member_pointer(IntArNB*));1108  static_assert(!__is_member_pointer(Union*));1109  static_assert(!__is_member_pointer(UnionAr*));1110  static_assert(!__is_member_pointer(StructWithMembers*));1111  static_assert(!__is_member_pointer(void));1112  static_assert(!__is_member_pointer(cvoid));1113  static_assert(!__is_member_pointer(cvoid));1114  static_assert(!__is_member_pointer(char));1115  static_assert(!__is_member_pointer(int));1116  static_assert(!__is_member_pointer(int));1117  static_assert(!__is_member_pointer(ClassType));1118  static_assert(!__is_member_pointer(Derives));1119  static_assert(!__is_member_pointer(Enum));1120  static_assert(!__is_member_pointer(IntArNB));1121  static_assert(!__is_member_pointer(Union));1122  static_assert(!__is_member_pointer(UnionAr));1123  static_assert(!__is_member_pointer(StructWithMembers));1124  static_assert(!__is_member_pointer(void (*)()));1125}1126 1127void is_const()1128{1129  static_assert(__is_const(cvoid));1130  static_assert(__is_const(const char));1131  static_assert(__is_const(const int));1132  static_assert(__is_const(const long));1133  static_assert(__is_const(const short));1134  static_assert(__is_const(const signed char));1135  static_assert(__is_const(const wchar_t));1136  static_assert(__is_const(const bool));1137  static_assert(__is_const(const float));1138  static_assert(__is_const(const double));1139  static_assert(__is_const(const long double));1140  static_assert(__is_const(const unsigned char));1141  static_assert(__is_const(const unsigned int));1142  static_assert(__is_const(const unsigned long long));1143  static_assert(__is_const(const unsigned long));1144  static_assert(__is_const(const unsigned short));1145  static_assert(__is_const(const void));1146  static_assert(__is_const(const ClassType));1147  static_assert(__is_const(const Derives));1148  static_assert(__is_const(const Enum));1149  static_assert(__is_const(const IntArNB));1150  static_assert(__is_const(const Union));1151  static_assert(__is_const(const UnionAr));1152 1153  static_assert(!__is_const(char));1154  static_assert(!__is_const(int));1155  static_assert(!__is_const(long));1156  static_assert(!__is_const(short));1157  static_assert(!__is_const(signed char));1158  static_assert(!__is_const(wchar_t));1159  static_assert(!__is_const(bool));1160  static_assert(!__is_const(float));1161  static_assert(!__is_const(double));1162  static_assert(!__is_const(long double));1163  static_assert(!__is_const(unsigned char));1164  static_assert(!__is_const(unsigned int));1165  static_assert(!__is_const(unsigned long long));1166  static_assert(!__is_const(unsigned long));1167  static_assert(!__is_const(unsigned short));1168  static_assert(!__is_const(void));1169  static_assert(!__is_const(ClassType));1170  static_assert(!__is_const(Derives));1171  static_assert(!__is_const(Enum));1172  static_assert(!__is_const(IntArNB));1173  static_assert(!__is_const(Union));1174  static_assert(!__is_const(UnionAr));1175}1176 1177void is_volatile()1178{1179  static_assert(__is_volatile(volatile char));1180  static_assert(__is_volatile(volatile int));1181  static_assert(__is_volatile(volatile long));1182  static_assert(__is_volatile(volatile short));1183  static_assert(__is_volatile(volatile signed char));1184  static_assert(__is_volatile(volatile wchar_t));1185  static_assert(__is_volatile(volatile bool));1186  static_assert(__is_volatile(volatile float));1187  static_assert(__is_volatile(volatile double));1188  static_assert(__is_volatile(volatile long double));1189  static_assert(__is_volatile(volatile unsigned char));1190  static_assert(__is_volatile(volatile unsigned int));1191  static_assert(__is_volatile(volatile unsigned long long));1192  static_assert(__is_volatile(volatile unsigned long));1193  static_assert(__is_volatile(volatile unsigned short));1194  static_assert(__is_volatile(volatile void));1195  static_assert(__is_volatile(volatile ClassType));1196  static_assert(__is_volatile(volatile Derives));1197  static_assert(__is_volatile(volatile Enum));1198  static_assert(__is_volatile(volatile IntArNB));1199  static_assert(__is_volatile(volatile Union));1200  static_assert(__is_volatile(volatile UnionAr));1201 1202  static_assert(!__is_volatile(char));1203  static_assert(!__is_volatile(int));1204  static_assert(!__is_volatile(long));1205  static_assert(!__is_volatile(short));1206  static_assert(!__is_volatile(signed char));1207  static_assert(!__is_volatile(wchar_t));1208  static_assert(!__is_volatile(bool));1209  static_assert(!__is_volatile(float));1210  static_assert(!__is_volatile(double));1211  static_assert(!__is_volatile(long double));1212  static_assert(!__is_volatile(unsigned char));1213  static_assert(!__is_volatile(unsigned int));1214  static_assert(!__is_volatile(unsigned long long));1215  static_assert(!__is_volatile(unsigned long));1216  static_assert(!__is_volatile(unsigned short));1217  static_assert(!__is_volatile(void));1218  static_assert(!__is_volatile(ClassType));1219  static_assert(!__is_volatile(Derives));1220  static_assert(!__is_volatile(Enum));1221  static_assert(!__is_volatile(IntArNB));1222  static_assert(!__is_volatile(Union));1223  static_assert(!__is_volatile(UnionAr));1224}1225 1226struct TrivialStruct {1227  int member;1228};1229 1230struct NonTrivialStruct {1231  int member;1232  NonTrivialStruct() {1233    member = 0;1234  }1235};1236 1237struct SuperNonTrivialStruct {1238  SuperNonTrivialStruct() { }1239  ~SuperNonTrivialStruct() { }1240};1241 1242struct NonTCStruct {1243  NonTCStruct(const NonTCStruct&) {}1244};1245 1246struct AllDefaulted {1247  AllDefaulted() = default;1248  AllDefaulted(const AllDefaulted &) = default;1249  AllDefaulted(AllDefaulted &&) = default;1250  AllDefaulted &operator=(const AllDefaulted &) = default;1251  AllDefaulted &operator=(AllDefaulted &&) = default;1252  ~AllDefaulted() = default;1253};1254 1255struct NoDefaultMoveAssignDueToUDCopyCtor {1256  NoDefaultMoveAssignDueToUDCopyCtor(const NoDefaultMoveAssignDueToUDCopyCtor&);1257};1258 1259struct NoDefaultMoveAssignDueToUDCopyAssign {1260  NoDefaultMoveAssignDueToUDCopyAssign& operator=(1261    const NoDefaultMoveAssignDueToUDCopyAssign&);1262};1263 1264struct NoDefaultMoveAssignDueToDtor {1265  ~NoDefaultMoveAssignDueToDtor();1266};1267 1268struct AllDeleted {1269  AllDeleted() = delete;1270  AllDeleted(const AllDeleted &) = delete;1271  AllDeleted(AllDeleted &&) = delete;1272  AllDeleted &operator=(const AllDeleted &) = delete;1273  AllDeleted &operator=(AllDeleted &&) = delete;1274  ~AllDeleted() = delete;1275};1276 1277struct ExtDefaulted {1278  ExtDefaulted();1279  ExtDefaulted(const ExtDefaulted &);1280  ExtDefaulted(ExtDefaulted &&);1281  ExtDefaulted &operator=(const ExtDefaulted &);1282  ExtDefaulted &operator=(ExtDefaulted &&);1283  ~ExtDefaulted();1284};1285 1286// Despite being defaulted, these functions are not trivial.1287ExtDefaulted::ExtDefaulted() = default;1288ExtDefaulted::ExtDefaulted(const ExtDefaulted &) = default;1289ExtDefaulted::ExtDefaulted(ExtDefaulted &&) = default;1290ExtDefaulted &ExtDefaulted::operator=(const ExtDefaulted &) = default;1291ExtDefaulted &ExtDefaulted::operator=(ExtDefaulted &&) = default;1292ExtDefaulted::~ExtDefaulted() = default;1293 1294void is_trivial2()1295{1296  static_assert(__is_trivial(char));1297  static_assert(__is_trivial(int));1298  static_assert(__is_trivial(long));1299  static_assert(__is_trivial(short));1300  static_assert(__is_trivial(signed char));1301  static_assert(__is_trivial(wchar_t));1302  static_assert(__is_trivial(bool));1303  static_assert(__is_trivial(float));1304  static_assert(__is_trivial(double));1305  static_assert(__is_trivial(long double));1306  static_assert(__is_trivial(unsigned char));1307  static_assert(__is_trivial(unsigned int));1308  static_assert(__is_trivial(unsigned long long));1309  static_assert(__is_trivial(unsigned long));1310  static_assert(__is_trivial(unsigned short));1311  static_assert(__is_trivial(ClassType));1312  static_assert(__is_trivial(Derives));1313  static_assert(__is_trivial(Enum));1314  static_assert(__is_trivial(IntAr));1315  static_assert(__is_trivial(Union));1316  static_assert(__is_trivial(UnionAr));1317  static_assert(__is_trivial(TrivialStruct));1318  static_assert(__is_trivial(AllDefaulted));1319  static_assert(__is_trivial(AllDeleted));1320 1321  static_assert(!__is_trivial(void));1322  static_assert(!__is_trivial(NonTrivialStruct));1323  static_assert(!__is_trivial(SuperNonTrivialStruct));1324  static_assert(!__is_trivial(NonTCStruct));1325  static_assert(!__is_trivial(ExtDefaulted));1326 1327  static_assert(__is_trivial(ACompleteType));1328  static_assert(!__is_trivial(AnIncompleteType)); // expected-error {{incomplete type}}1329  static_assert(!__is_trivial(AnIncompleteType[])); // expected-error {{incomplete type}}1330  static_assert(!__is_trivial(AnIncompleteType[1])); // expected-error {{incomplete type}}1331  static_assert(!__is_trivial(void));1332  static_assert(!__is_trivial(const volatile void));1333}1334 1335void is_trivially_copyable2()1336{1337  static_assert(__is_trivially_copyable(char));1338  static_assert(__is_trivially_copyable(int));1339  static_assert(__is_trivially_copyable(long));1340  static_assert(__is_trivially_copyable(short));1341  static_assert(__is_trivially_copyable(signed char));1342  static_assert(__is_trivially_copyable(wchar_t));1343  static_assert(__is_trivially_copyable(bool));1344  static_assert(__is_trivially_copyable(float));1345  static_assert(__is_trivially_copyable(double));1346  static_assert(__is_trivially_copyable(long double));1347  static_assert(__is_trivially_copyable(unsigned char));1348  static_assert(__is_trivially_copyable(unsigned int));1349  static_assert(__is_trivially_copyable(unsigned long long));1350  static_assert(__is_trivially_copyable(unsigned long));1351  static_assert(__is_trivially_copyable(unsigned short));1352  static_assert(__is_trivially_copyable(ClassType));1353  static_assert(__is_trivially_copyable(Derives));1354  static_assert(__is_trivially_copyable(Enum));1355  static_assert(__is_trivially_copyable(IntAr));1356  static_assert(__is_trivially_copyable(Union));1357  static_assert(__is_trivially_copyable(UnionAr));1358  static_assert(__is_trivially_copyable(TrivialStruct));1359  static_assert(__is_trivially_copyable(NonTrivialStruct));1360  static_assert(__is_trivially_copyable(AllDefaulted));1361  static_assert(__is_trivially_copyable(AllDeleted));1362 1363  static_assert(!__is_trivially_copyable(void));1364  static_assert(!__is_trivially_copyable(SuperNonTrivialStruct));1365  static_assert(!__is_trivially_copyable(NonTCStruct));1366  static_assert(!__is_trivially_copyable(ExtDefaulted));1367 1368  static_assert(__is_trivially_copyable(const int));1369  static_assert(__is_trivially_copyable(volatile int));1370 1371  static_assert(__is_trivially_copyable(ACompleteType));1372  static_assert(!__is_trivially_copyable(AnIncompleteType)); // expected-error {{incomplete type}}1373  static_assert(!__is_trivially_copyable(AnIncompleteType[])); // expected-error {{incomplete type}}1374  static_assert(!__is_trivially_copyable(AnIncompleteType[1])); // expected-error {{incomplete type}}1375  static_assert(!__is_trivially_copyable(void));1376  static_assert(!__is_trivially_copyable(const volatile void));1377}1378 1379struct CStruct {1380  int one;1381  int two;1382};1383 1384struct CEmptyStruct {};1385 1386struct CppEmptyStruct : CStruct {};1387struct CppStructStandard : CEmptyStruct {1388  int three;1389  int four;1390};1391struct CppStructNonStandardByBase : CStruct {1392  int three;1393  int four;1394};1395struct CppStructNonStandardByVirt : CStruct {1396  virtual void method() {}1397};1398struct CppStructNonStandardByMemb : CStruct {1399  CppStructNonStandardByVirt member;1400};1401struct CppStructNonStandardByProt : CStruct {1402  int five;1403protected:1404  int six;1405};1406struct CppStructNonStandardByVirtBase : virtual CStruct {1407};1408struct CppStructNonStandardBySameBase : CEmptyStruct {1409  CEmptyStruct member;1410};1411struct CppStructNonStandardBy2ndVirtBase : CEmptyStruct {1412  CEmptyStruct member;1413};1414 1415void is_standard_layout()1416{1417  typedef const int ConstInt;1418  typedef ConstInt ConstIntAr[4];1419  typedef CppStructStandard CppStructStandardAr[4];1420 1421  static_assert(__is_standard_layout(int));1422  static_assert(__is_standard_layout(ConstInt));1423  static_assert(__is_standard_layout(ConstIntAr));1424  static_assert(__is_standard_layout(CStruct));1425  static_assert(__is_standard_layout(CppStructStandard));1426  static_assert(__is_standard_layout(CppStructStandardAr));1427  static_assert(__is_standard_layout(Vector));1428  static_assert(__is_standard_layout(VectorExt));1429 1430  typedef CppStructNonStandardByBase CppStructNonStandardByBaseAr[4];1431 1432  static_assert(!__is_standard_layout(CppStructNonStandardByVirt));1433  static_assert(!__is_standard_layout(CppStructNonStandardByMemb));1434  static_assert(!__is_standard_layout(CppStructNonStandardByProt));1435  static_assert(!__is_standard_layout(CppStructNonStandardByVirtBase));1436  static_assert(!__is_standard_layout(CppStructNonStandardByBase));1437  static_assert(!__is_standard_layout(CppStructNonStandardByBaseAr));1438  static_assert(!__is_standard_layout(CppStructNonStandardBySameBase));1439  static_assert(!__is_standard_layout(CppStructNonStandardBy2ndVirtBase));1440 1441  static_assert(__is_standard_layout(ACompleteType));1442  static_assert(!__is_standard_layout(AnIncompleteType)); // expected-error {{incomplete type}}1443  static_assert(!__is_standard_layout(AnIncompleteType[])); // expected-error {{incomplete type}}1444  static_assert(!__is_standard_layout(AnIncompleteType[1])); // expected-error {{incomplete type}}1445  static_assert(!__is_standard_layout(void));1446  static_assert(!__is_standard_layout(const volatile void));1447 1448  struct HasAnonEmptyBitfield { int : 0; };1449  struct HasAnonBitfield { int : 4; };1450  struct DerivesFromBitfield : HasAnonBitfield {};1451  struct DerivesFromBitfieldWithBitfield : HasAnonBitfield { int : 5; };1452  struct DerivesFromBitfieldTwice : DerivesFromBitfield, HasAnonEmptyBitfield {};1453 1454  static_assert(__is_standard_layout(HasAnonEmptyBitfield));1455  static_assert(__is_standard_layout(HasAnonBitfield));1456  static_assert(__is_standard_layout(DerivesFromBitfield));1457  static_assert(!__is_standard_layout(DerivesFromBitfieldWithBitfield));1458  static_assert(!__is_standard_layout(DerivesFromBitfieldTwice));1459 1460  struct Empty {};1461  struct HasEmptyBase : Empty {};1462  struct HoldsEmptyBase { Empty e; };1463  struct HasRepeatedEmptyBase : Empty, HasEmptyBase {}; // expected-warning {{inaccessible}}1464  struct HasEmptyBaseAsMember : Empty { Empty e; };1465  struct HasEmptyBaseAsSubobjectOfMember1 : Empty { HoldsEmptyBase e; };1466  struct HasEmptyBaseAsSubobjectOfMember2 : Empty { HasEmptyBase e; };1467  struct HasEmptyBaseAsSubobjectOfMember3 : Empty { HoldsEmptyBase e[2]; };1468  struct HasEmptyIndirectBaseAsMember : HasEmptyBase { Empty e; };1469  struct HasEmptyIndirectBaseAsSecondMember : HasEmptyBase { int n; Empty e; };1470  struct HasEmptyIndirectBaseAfterBitfield : HasEmptyBase { int : 4; Empty e; };1471 1472  static_assert(__is_standard_layout(Empty));1473  static_assert(__is_standard_layout(HasEmptyBase));1474  static_assert(!__is_standard_layout(HasRepeatedEmptyBase));1475  static_assert(!__is_standard_layout(HasEmptyBaseAsMember));1476  static_assert(!__is_standard_layout(HasEmptyBaseAsSubobjectOfMember1));1477  static_assert(__is_standard_layout(HasEmptyBaseAsSubobjectOfMember2)); // FIXME: standard bug?1478  static_assert(!__is_standard_layout(HasEmptyBaseAsSubobjectOfMember3));1479  static_assert(!__is_standard_layout(HasEmptyIndirectBaseAsMember));1480  static_assert(__is_standard_layout(HasEmptyIndirectBaseAsSecondMember));1481  static_assert(!__is_standard_layout(HasEmptyIndirectBaseAfterBitfield)); // FIXME: standard bug?1482 1483  struct StructWithEmptyFields {1484    int n;1485    HoldsEmptyBase e[3];1486  };1487  union UnionWithEmptyFields {1488    int n;1489    HoldsEmptyBase e[3];1490  };1491  struct HasEmptyIndirectBaseAsSecondStructMember : HasEmptyBase {1492    StructWithEmptyFields u;1493  };1494  struct HasEmptyIndirectBaseAsSecondUnionMember : HasEmptyBase {1495    UnionWithEmptyFields u;1496  };1497 1498  static_assert(__is_standard_layout(HasEmptyIndirectBaseAsSecondStructMember));1499  static_assert(!__is_standard_layout(HasEmptyIndirectBaseAsSecondUnionMember));1500}1501 1502struct CStruct2 {1503  int one;1504  int two;1505};1506 1507struct CEmptyStruct2 {};1508 1509struct CppEmptyStruct2 : CStruct2 {};1510struct CppStructStandard2 : CEmptyStruct2 {1511  int three;1512  int four;1513};1514struct CppStructNonStandardByBase2 : CStruct2 {1515  int three;1516  int four;1517};1518struct CppStructNonStandardByVirt2 : CStruct2 {1519  virtual void method() {}1520};1521struct CppStructNonStandardByMemb2 : CStruct2 {1522  CppStructNonStandardByVirt member;1523};1524struct CppStructNonStandardByProt2 : CStruct2 {1525  int five;1526protected:1527  int six;1528};1529struct CppStructNonStandardByVirtBase2 : virtual CStruct2 {1530};1531struct CppStructNonStandardBySameBase2 : CEmptyStruct2 {1532  CEmptyStruct member;1533};1534struct CppStructNonStandardBy2ndVirtBase2 : CEmptyStruct2 {1535  CEmptyStruct member;1536};1537 1538struct CStructWithQualifiers {1539  const int one;1540  volatile int two;1541};1542 1543struct CStructNoUniqueAddress {1544  int one;1545  [[no_unique_address]] int two;1546};1547 1548struct CStructNoUniqueAddress2 {1549  int one;1550  [[no_unique_address]] int two;1551};1552 1553struct alignas(64) CStructAlignment {1554  int one;1555  int two;1556};1557 1558struct CStructAlignedMembers {1559  int one;1560  alignas(16) int two;1561};1562 1563enum EnumLayout : int {};1564enum class EnumClassLayout {};1565enum EnumForward : int;1566enum class EnumClassForward;1567 1568struct CStructIncomplete; // #CStructIncomplete1569 1570struct CStructNested {1571  int a;1572  CStruct s;1573  int b;1574};1575 1576struct CStructNested2 {1577  int a2;1578  CStruct s2;1579  int b2;1580};1581 1582struct CStructWithBitfelds {1583  int a : 5;1584  int : 0;1585};1586 1587struct CStructWithBitfelds2 {1588  int a : 5;1589  int : 0;1590};1591 1592struct CStructWithBitfelds3 {1593  int : 0;1594  int b : 5;1595};1596 1597struct CStructWithBitfelds4 {1598  EnumLayout a : 5;1599  int : 0;1600};1601 1602union UnionLayout {1603  int a;1604  double b;1605  CStruct c;1606  [[no_unique_address]] CEmptyStruct d;1607  [[no_unique_address]] CEmptyStruct2 e;1608};1609 1610union UnionLayout2 {1611  CStruct c;1612  int a;1613  CEmptyStruct2 e;1614  double b;1615  [[no_unique_address]] CEmptyStruct d;1616};1617 1618union UnionLayout3 {1619  CStruct c;1620  int a;1621  double b;1622  [[no_unique_address]] CEmptyStruct d;1623};1624 1625union UnionNoOveralignedMembers {1626  int a;1627  double b;1628};1629 1630union UnionWithOveralignedMembers {1631  int a;1632  alignas(16) double b;1633};1634 1635struct StructWithAnonUnion {1636  union {1637    int a;1638    double b;1639    CStruct c;1640    [[no_unique_address]] CEmptyStruct d;1641    [[no_unique_address]] CEmptyStruct2 e;1642  };1643};1644 1645struct StructWithAnonUnion2 {1646  union {1647    CStruct c;1648    int a;1649    CEmptyStruct2 e;1650    double b;1651    [[no_unique_address]] CEmptyStruct d;1652  };1653};1654 1655struct StructWithAnonUnion3 {1656  union {1657    CStruct c;1658    int a;1659    CEmptyStruct2 e;1660    double b;1661    [[no_unique_address]] CEmptyStruct d;1662  } u;1663};1664 1665struct CStructWithArrayAtTheEnd {1666  int a;1667  int b[4];1668};1669 1670struct CStructWithFMA {1671  int c;1672  int d[];1673};1674 1675struct CStructWithFMA2 {1676  int e;1677  int f[];1678};1679 1680template<int N>1681struct UniqueEmpty {};1682template<typename... Bases>1683struct D : Bases... {};1684 1685void is_layout_compatible(int n)1686{1687  static_assert(__is_layout_compatible(void, void));1688  static_assert(!__is_layout_compatible(void, int));1689  static_assert(__is_layout_compatible(void, const void));1690  static_assert(__is_layout_compatible(void, volatile void));1691  static_assert(__is_layout_compatible(const void, volatile void));1692  static_assert(__is_layout_compatible(int, int));1693  static_assert(__is_layout_compatible(int, const int));1694  static_assert(__is_layout_compatible(int, volatile int));1695  static_assert(__is_layout_compatible(const int, volatile int));1696  static_assert(__is_layout_compatible(int *, int * __restrict));1697  // Note: atomic qualification matters for layout compatibility.1698  static_assert(!__is_layout_compatible(int, _Atomic int));1699  static_assert(__is_layout_compatible(_Atomic(int), _Atomic int));1700  static_assert(!__is_layout_compatible(int, unsigned int));1701  static_assert(!__is_layout_compatible(char, unsigned char));1702  static_assert(!__is_layout_compatible(char, signed char));1703  static_assert(!__is_layout_compatible(unsigned char, signed char));1704  static_assert(__is_layout_compatible(int[], int[]));1705  static_assert(__is_layout_compatible(int[2], int[2]));1706  static_assert(!__is_layout_compatible(int[n], int[2]));1707  // expected-error@-1 {{variable length arrays are not supported in '__is_layout_compatible'}}1708  static_assert(!__is_layout_compatible(int[n], int[n]));1709  // expected-error@-1 {{variable length arrays are not supported in '__is_layout_compatible'}}1710  // expected-error@-2 {{variable length arrays are not supported in '__is_layout_compatible'}}1711  static_assert(__is_layout_compatible(int&, int&));1712  static_assert(!__is_layout_compatible(int&, char&));1713  static_assert(__is_layout_compatible(void(int), void(int)));1714  static_assert(!__is_layout_compatible(void(int), void(char)));1715  static_assert(__is_layout_compatible(void(&)(int), void(&)(int)));1716  static_assert(!__is_layout_compatible(void(&)(int), void(&)(char)));1717  static_assert(__is_layout_compatible(void(*)(int), void(*)(int)));1718  static_assert(!__is_layout_compatible(void(*)(int), void(*)(char)));1719  using function_type = void();1720  using function_type2 = void(char);1721  static_assert(__is_layout_compatible(const function_type, const function_type));1722  // expected-warning@-1 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}}1723  // expected-warning@-2 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}}1724  static_assert(__is_layout_compatible(function_type, const function_type));1725  // expected-warning@-1 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}}1726  static_assert(!__is_layout_compatible(const function_type, const function_type2));1727  // expected-warning@-1 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}}1728  // expected-warning@-2 {{'const' qualifier on function type 'function_type2' (aka 'void (char)') has no effect}}1729  static_assert(__is_layout_compatible(CStruct, CStruct2));1730  static_assert(__is_layout_compatible(CStruct, const CStruct2));1731  static_assert(__is_layout_compatible(CStruct, volatile CStruct2));1732  static_assert(__is_layout_compatible(const CStruct, volatile CStruct2));1733  static_assert(__is_layout_compatible(CEmptyStruct, CEmptyStruct2));1734  static_assert(__is_layout_compatible(CppEmptyStruct, CppEmptyStruct2));1735  static_assert(__is_layout_compatible(CppStructStandard, CppStructStandard2));1736  static_assert(!__is_layout_compatible(CppStructNonStandardByBase, CppStructNonStandardByBase2));1737  static_assert(!__is_layout_compatible(CppStructNonStandardByVirt, CppStructNonStandardByVirt2));1738  static_assert(!__is_layout_compatible(CppStructNonStandardByMemb, CppStructNonStandardByMemb2));1739  static_assert(!__is_layout_compatible(CppStructNonStandardByProt, CppStructNonStandardByProt2));1740  static_assert(!__is_layout_compatible(CppStructNonStandardByVirtBase, CppStructNonStandardByVirtBase2));1741  static_assert(!__is_layout_compatible(CppStructNonStandardBySameBase, CppStructNonStandardBySameBase2));1742  static_assert(!__is_layout_compatible(CppStructNonStandardBy2ndVirtBase, CppStructNonStandardBy2ndVirtBase2));1743  static_assert(__is_layout_compatible(CStruct, CStructWithQualifiers));1744  static_assert(__is_layout_compatible(CStruct, CStructNoUniqueAddress) != bool(__has_cpp_attribute(no_unique_address)));1745  static_assert(__is_layout_compatible(CStructNoUniqueAddress, CStructNoUniqueAddress2) != bool(__has_cpp_attribute(no_unique_address)));1746  static_assert(__is_layout_compatible(CStruct, CStructAlignment));1747  static_assert(!__is_layout_compatible(CStruct, CStructAlignedMembers));1748  static_assert(__is_layout_compatible(UnionNoOveralignedMembers, UnionWithOveralignedMembers));1749  static_assert(__is_layout_compatible(CStructWithBitfelds, CStructWithBitfelds));1750  static_assert(__is_layout_compatible(CStructWithBitfelds, CStructWithBitfelds2));1751  static_assert(!__is_layout_compatible(CStructWithBitfelds, CStructWithBitfelds3));1752  static_assert(!__is_layout_compatible(CStructWithBitfelds, CStructWithBitfelds4));1753  static_assert(__is_layout_compatible(int CStruct2::*, int CStruct2::*));1754  static_assert(!__is_layout_compatible(int CStruct2::*, char CStruct2::*));1755  static_assert(__is_layout_compatible(void(CStruct2::*)(int), void(CStruct2::*)(int)));1756  static_assert(!__is_layout_compatible(void(CStruct2::*)(int), void(CStruct2::*)(char)));1757  static_assert(__is_layout_compatible(CStructNested, CStructNested2));1758  static_assert(__is_layout_compatible(UnionLayout, UnionLayout));1759  static_assert(!__is_layout_compatible(UnionLayout, UnionLayout2));1760  static_assert(!__is_layout_compatible(UnionLayout, UnionLayout3));1761  static_assert(!__is_layout_compatible(StructWithAnonUnion, StructWithAnonUnion2));1762  static_assert(!__is_layout_compatible(StructWithAnonUnion, StructWithAnonUnion3));1763  static_assert(__is_layout_compatible(EnumLayout, EnumClassLayout));1764  static_assert(__is_layout_compatible(EnumForward, EnumForward));1765  static_assert(__is_layout_compatible(EnumForward, EnumClassForward));1766  static_assert(__is_layout_compatible(CStructIncomplete, CStructIncomplete));1767  // expected-error@-1 {{incomplete type 'CStructIncomplete' where a complete type is required}}1768  //   expected-note@#CStructIncomplete {{forward declaration of 'CStructIncomplete'}}1769  // expected-error@-3 {{incomplete type 'CStructIncomplete' where a complete type is required}}1770  //   expected-note@#CStructIncomplete {{forward declaration of 'CStructIncomplete'}}1771  static_assert(!__is_layout_compatible(CStruct, CStructIncomplete));1772  // expected-error@-1 {{incomplete type 'CStructIncomplete' where a complete type is required}}1773  //   expected-note@#CStructIncomplete {{forward declaration of 'CStructIncomplete'}}1774  static_assert(__is_layout_compatible(CStructIncomplete[2], CStructIncomplete[2]));1775  // expected-error@-1 {{incomplete type 'CStructIncomplete[2]' where a complete type is required}}1776  //   expected-note@#CStructIncomplete {{forward declaration of 'CStructIncomplete'}}1777  // expected-error@-3 {{incomplete type 'CStructIncomplete[2]' where a complete type is required}}1778  //   expected-note@#CStructIncomplete {{forward declaration of 'CStructIncomplete'}}1779  static_assert(__is_layout_compatible(CStructIncomplete[], CStructIncomplete[]));1780  static_assert(!__is_layout_compatible(CStructWithArrayAtTheEnd, CStructWithFMA));1781  static_assert(__is_layout_compatible(CStructWithFMA, CStructWithFMA));1782  static_assert(__is_layout_compatible(CStructWithFMA, CStructWithFMA2));1783  // Layout compatibility rules for enums might be relaxed in the future. See https://github.com/cplusplus/CWG/issues/39#issuecomment-11847913641784  static_assert(!__is_layout_compatible(EnumLayout, int));1785  static_assert(!__is_layout_compatible(EnumClassLayout, int));1786  static_assert(!__is_layout_compatible(EnumForward, int));1787  static_assert(!__is_layout_compatible(EnumClassForward, int));1788  static_assert(__is_layout_compatible(CStruct, D<CStruct>));1789  static_assert(__is_layout_compatible(CStruct, D<UniqueEmpty<0>, CStruct>));1790  static_assert(__is_layout_compatible(CStruct, D<UniqueEmpty<0>, D<UniqueEmpty<1>, CStruct>, D<UniqueEmpty<2>>>));1791  static_assert(__is_layout_compatible(CStruct, D<CStructWithQualifiers>));1792  static_assert(__is_layout_compatible(CStruct, D<UniqueEmpty<0>, CStructWithQualifiers>));1793  static_assert(__is_layout_compatible(CStructWithQualifiers, D<UniqueEmpty<0>, D<UniqueEmpty<1>, CStruct>, D<UniqueEmpty<2>>>));1794}1795 1796namespace IPIBO {1797struct Base {};1798struct Base2 {};1799struct Base3 : Base {};1800struct Base3Virtual : virtual Base {};1801struct Derived : Base {};1802struct DerivedIndirect : Base3 {};1803struct DerivedMultiple : Base, Base2 {};1804struct DerivedAmbiguous : Base, Base3 {};1805/* expected-warning@-1 {{direct base 'Base' is inaccessible due to ambiguity:1806    struct IPIBO::DerivedAmbiguous -> Base1807    struct IPIBO::DerivedAmbiguous -> Base3 -> Base}} */1808struct DerivedPrivate : private Base {};1809struct DerivedVirtual : virtual Base {};1810 1811union Union {};1812union UnionIncomplete;1813struct StructIncomplete; // #StructIncomplete1814 1815void is_pointer_interconvertible_base_of(int n)1816{1817  static_assert(__is_pointer_interconvertible_base_of(Base, Derived));1818  static_assert(!__is_pointer_interconvertible_base_of(Base2, Derived));1819  static_assert(__is_pointer_interconvertible_base_of(Base, DerivedIndirect));1820  static_assert(__is_pointer_interconvertible_base_of(Base, DerivedMultiple));1821  static_assert(__is_pointer_interconvertible_base_of(Base2, DerivedMultiple));1822  static_assert(!__is_pointer_interconvertible_base_of(Base3, DerivedMultiple));1823  static_assert(!__is_pointer_interconvertible_base_of(Base, DerivedAmbiguous));1824  static_assert(__is_pointer_interconvertible_base_of(Base, DerivedPrivate));1825  static_assert(!__is_pointer_interconvertible_base_of(Base, DerivedVirtual));1826  static_assert(!__is_pointer_interconvertible_base_of(Union, Union));1827  static_assert(!__is_pointer_interconvertible_base_of(UnionIncomplete, UnionIncomplete));1828  static_assert(__is_pointer_interconvertible_base_of(StructIncomplete, StructIncomplete));1829  static_assert(__is_pointer_interconvertible_base_of(StructIncomplete, const StructIncomplete));1830  static_assert(__is_pointer_interconvertible_base_of(StructIncomplete, volatile StructIncomplete));1831  static_assert(__is_pointer_interconvertible_base_of(const StructIncomplete, volatile StructIncomplete));1832  static_assert(!__is_pointer_interconvertible_base_of(StructIncomplete, Derived));1833  static_assert(!__is_pointer_interconvertible_base_of(Base, StructIncomplete));1834  // expected-error@-1 {{incomplete type 'StructIncomplete' where a complete type is required}}1835  //   expected-note@#StructIncomplete {{forward declaration of 'IPIBO::StructIncomplete'}}1836  static_assert(!__is_pointer_interconvertible_base_of(CStruct2, CppStructNonStandardByBase2));1837  static_assert(!__is_pointer_interconvertible_base_of(void, void));1838  static_assert(!__is_pointer_interconvertible_base_of(void, int));1839  static_assert(!__is_pointer_interconvertible_base_of(void, const void));1840  static_assert(!__is_pointer_interconvertible_base_of(void, volatile void));1841  static_assert(!__is_pointer_interconvertible_base_of(const void, volatile void));1842  static_assert(!__is_pointer_interconvertible_base_of(int, int));1843  static_assert(!__is_pointer_interconvertible_base_of(int, const int));1844  static_assert(!__is_pointer_interconvertible_base_of(int, volatile int));1845  static_assert(!__is_pointer_interconvertible_base_of(const int, volatile int));1846  static_assert(!__is_pointer_interconvertible_base_of(int *, int * __restrict));1847  static_assert(!__is_pointer_interconvertible_base_of(int, _Atomic int));1848  static_assert(!__is_pointer_interconvertible_base_of(_Atomic(int), _Atomic int));1849  static_assert(!__is_pointer_interconvertible_base_of(int, unsigned int));1850  static_assert(!__is_pointer_interconvertible_base_of(char, unsigned char));1851  static_assert(!__is_pointer_interconvertible_base_of(char, signed char));1852  static_assert(!__is_pointer_interconvertible_base_of(unsigned char, signed char));1853  using function_type = void();1854  using function_type2 = void(char);1855  static_assert(!__is_pointer_interconvertible_base_of(const function_type, const function_type));1856  // expected-warning@-1 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}}1857  // expected-warning@-2 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}}1858  static_assert(!__is_pointer_interconvertible_base_of(function_type, const function_type));1859  // expected-warning@-1 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}}1860  static_assert(!__is_pointer_interconvertible_base_of(const function_type, const function_type2));1861  // expected-warning@-1 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}}1862  // expected-warning@-2 {{'const' qualifier on function type 'function_type2' (aka 'void (char)') has no effect}}1863  static_assert(!__is_pointer_interconvertible_base_of(int CStruct2::*, int CStruct2::*));1864  static_assert(!__is_pointer_interconvertible_base_of(int CStruct2::*, char CStruct2::*));1865  static_assert(!__is_pointer_interconvertible_base_of(void(CStruct2::*)(int), void(CStruct2::*)(int)));1866  static_assert(!__is_pointer_interconvertible_base_of(void(CStruct2::*)(int), void(CStruct2::*)(char)));1867  static_assert(!__is_pointer_interconvertible_base_of(int[], int[]));1868  static_assert(!__is_pointer_interconvertible_base_of(int[], double[]));1869  static_assert(!__is_pointer_interconvertible_base_of(int[2], int[2]));1870  static_assert(!__is_pointer_interconvertible_base_of(int[n], int[2]));1871  // expected-error@-1 {{variable length arrays are not supported in '__is_pointer_interconvertible_base_of'}}1872  static_assert(!__is_pointer_interconvertible_base_of(int[n], int[n]));1873  // expected-error@-1 {{variable length arrays are not supported in '__is_pointer_interconvertible_base_of'}}1874  // expected-error@-2 {{variable length arrays are not supported in '__is_pointer_interconvertible_base_of'}}1875  static_assert(!__is_pointer_interconvertible_base_of(int&, int&));1876  static_assert(!__is_pointer_interconvertible_base_of(int&, char&));1877  static_assert(!__is_pointer_interconvertible_base_of(void(int), void(int)));1878  static_assert(!__is_pointer_interconvertible_base_of(void(int), void(char)));1879  static_assert(!__is_pointer_interconvertible_base_of(void(&)(int), void(&)(int)));1880  static_assert(!__is_pointer_interconvertible_base_of(void(&)(int), void(&)(char)));1881  static_assert(!__is_pointer_interconvertible_base_of(void(*)(int), void(*)(int)));1882  static_assert(!__is_pointer_interconvertible_base_of(void(*)(int), void(*)(char)));1883}1884}1885 1886struct NoEligibleTrivialContructor {1887  NoEligibleTrivialContructor() {};1888  NoEligibleTrivialContructor(const NoEligibleTrivialContructor&) {}1889  NoEligibleTrivialContructor(NoEligibleTrivialContructor&&) {}1890};1891 1892struct OnlyDefaultConstructorIsTrivial {1893  OnlyDefaultConstructorIsTrivial() = default;1894  OnlyDefaultConstructorIsTrivial(const OnlyDefaultConstructorIsTrivial&) {}1895  OnlyDefaultConstructorIsTrivial(OnlyDefaultConstructorIsTrivial&&) {}1896};1897 1898struct AllContstructorsAreTrivial {1899  AllContstructorsAreTrivial() = default;1900  AllContstructorsAreTrivial(const AllContstructorsAreTrivial&) = default;1901  AllContstructorsAreTrivial(AllContstructorsAreTrivial&&) = default;1902};1903 1904struct InheritedNoEligibleTrivialConstructor : NoEligibleTrivialContructor {1905  using NoEligibleTrivialContructor::NoEligibleTrivialContructor;1906};1907 1908struct InheritedOnlyDefaultConstructorIsTrivial : OnlyDefaultConstructorIsTrivial {1909  using OnlyDefaultConstructorIsTrivial::OnlyDefaultConstructorIsTrivial;1910};1911 1912struct InheritedAllContstructorsAreTrivial : AllContstructorsAreTrivial {1913  using AllContstructorsAreTrivial::AllContstructorsAreTrivial;1914};1915 1916struct UserDeclaredDestructor {1917  ~UserDeclaredDestructor() = default;1918};1919 1920struct UserProvidedDestructor {1921  ~UserProvidedDestructor() {}1922};1923 1924struct UserDeletedDestructorInAggregate {1925  ~UserDeletedDestructorInAggregate() = delete;1926};1927 1928struct UserDeletedDestructorInNonAggregate {1929  virtual void NonAggregate();1930  ~UserDeletedDestructorInNonAggregate() = delete;1931};1932 1933struct DeletedDestructorViaBaseInAggregate : UserDeletedDestructorInAggregate {};1934struct DeletedDestructorViaBaseInNonAggregate : UserDeletedDestructorInNonAggregate {};1935 1936#if __cplusplus >= 202002L1937template<bool B>1938struct ConstrainedUserDeclaredDefaultConstructor{1939  ConstrainedUserDeclaredDefaultConstructor() requires B = default;1940  ConstrainedUserDeclaredDefaultConstructor(const ConstrainedUserDeclaredDefaultConstructor&) {}1941};1942 1943template<bool B>1944struct ConstrainedUserProvidedDestructor {1945  ~ConstrainedUserProvidedDestructor() = default;1946  ~ConstrainedUserProvidedDestructor() requires B {}1947};1948#endif1949 1950struct StructWithFAM {1951  int a[];1952};1953 1954struct StructWithZeroSizedArray {1955  int a[0];1956};1957 1958typedef float float4 __attribute__((ext_vector_type(4)));1959typedef int *align_value_int __attribute__((align_value(16)));1960 1961struct [[clang::enforce_read_only_placement]] EnforceReadOnlyPlacement {};1962struct [[clang::type_visibility("hidden")]] TypeVisibility {};1963 1964void is_implicit_lifetime(int n) {1965  static_assert(__builtin_is_implicit_lifetime(decltype(nullptr)));1966  static_assert(!__builtin_is_implicit_lifetime(void));1967  static_assert(!__builtin_is_implicit_lifetime(const void));1968  static_assert(!__builtin_is_implicit_lifetime(volatile void));1969  static_assert(__builtin_is_implicit_lifetime(int));1970  static_assert(!__builtin_is_implicit_lifetime(int&));1971  static_assert(!__builtin_is_implicit_lifetime(int&&));1972  static_assert(__builtin_is_implicit_lifetime(float));1973  static_assert(__builtin_is_implicit_lifetime(double));1974  static_assert(__builtin_is_implicit_lifetime(long double));1975  static_assert(__builtin_is_implicit_lifetime(int*));1976  static_assert(__builtin_is_implicit_lifetime(int[]));1977  static_assert(__builtin_is_implicit_lifetime(int[5]));1978  static_assert(__builtin_is_implicit_lifetime(int[n]));1979  // expected-error@-1 {{variable length arrays are not supported in '__builtin_is_implicit_lifetime'}}1980  static_assert(__builtin_is_implicit_lifetime(Enum));1981  static_assert(__builtin_is_implicit_lifetime(EnumClass));1982  static_assert(!__builtin_is_implicit_lifetime(void()));1983  static_assert(!__builtin_is_implicit_lifetime(void() &));1984  static_assert(!__builtin_is_implicit_lifetime(void() const));1985  static_assert(!__builtin_is_implicit_lifetime(void(&)()));1986  static_assert(__builtin_is_implicit_lifetime(void(*)()));1987  static_assert(__builtin_is_implicit_lifetime(decltype(nullptr)));1988  static_assert(__builtin_is_implicit_lifetime(int UserDeclaredDestructor::*));1989  static_assert(__builtin_is_implicit_lifetime(int (UserDeclaredDestructor::*)()));1990  static_assert(__builtin_is_implicit_lifetime(int (UserDeclaredDestructor::*)() const));1991  static_assert(__builtin_is_implicit_lifetime(int (UserDeclaredDestructor::*)() &));1992  static_assert(__builtin_is_implicit_lifetime(int (UserDeclaredDestructor::*)() &&));1993  static_assert(!__builtin_is_implicit_lifetime(IncompleteStruct));1994  // expected-error@-1 {{incomplete type 'IncompleteStruct' used in type trait expression}}1995  static_assert(__builtin_is_implicit_lifetime(IncompleteStruct[]));1996  static_assert(__builtin_is_implicit_lifetime(IncompleteStruct[5]));1997  static_assert(__builtin_is_implicit_lifetime(UserDeclaredDestructor));1998  static_assert(__builtin_is_implicit_lifetime(const UserDeclaredDestructor));1999  static_assert(__builtin_is_implicit_lifetime(volatile UserDeclaredDestructor));2000  static_assert(!__builtin_is_implicit_lifetime(UserProvidedDestructor));2001  static_assert(!__builtin_is_implicit_lifetime(NoEligibleTrivialContructor));2002  static_assert(__builtin_is_implicit_lifetime(OnlyDefaultConstructorIsTrivial));2003  static_assert(__builtin_is_implicit_lifetime(AllContstructorsAreTrivial));2004  static_assert(!__builtin_is_implicit_lifetime(InheritedNoEligibleTrivialConstructor));2005  static_assert(__builtin_is_implicit_lifetime(InheritedOnlyDefaultConstructorIsTrivial));2006  static_assert(__builtin_is_implicit_lifetime(InheritedAllContstructorsAreTrivial));2007  static_assert(__builtin_is_implicit_lifetime(UserDeletedDestructorInAggregate));2008  static_assert(!__builtin_is_implicit_lifetime(UserDeletedDestructorInNonAggregate));2009  static_assert(__builtin_is_implicit_lifetime(DeletedDestructorViaBaseInAggregate) == __cplusplus >= 201703L);2010  static_assert(!__builtin_is_implicit_lifetime(DeletedDestructorViaBaseInNonAggregate));2011#if __cplusplus >= 202002L2012  static_assert(__builtin_is_implicit_lifetime(ConstrainedUserDeclaredDefaultConstructor<true>));2013  static_assert(!__builtin_is_implicit_lifetime(ConstrainedUserDeclaredDefaultConstructor<false>));2014  static_assert(!__builtin_is_implicit_lifetime(ConstrainedUserProvidedDestructor<true>));2015  static_assert(__builtin_is_implicit_lifetime(ConstrainedUserProvidedDestructor<false>));2016#endif2017 2018  static_assert(__builtin_is_implicit_lifetime(__int128));2019  static_assert(__builtin_is_implicit_lifetime(_BitInt(8)));2020  static_assert(__builtin_is_implicit_lifetime(_BitInt(128)));2021  static_assert(__builtin_is_implicit_lifetime(int[0]));2022  static_assert(__builtin_is_implicit_lifetime(StructWithFAM));2023  static_assert(__builtin_is_implicit_lifetime(StructWithZeroSizedArray));2024  static_assert(__builtin_is_implicit_lifetime(__fp16));2025  static_assert(__builtin_is_implicit_lifetime(__bf16));2026  static_assert(__builtin_is_implicit_lifetime(_Complex double));2027  static_assert(__builtin_is_implicit_lifetime(float4));2028  static_assert(__builtin_is_implicit_lifetime(align_value_int));2029  static_assert(__builtin_is_implicit_lifetime(int[[clang::annotate_type("category2")]] *));2030  static_assert(__builtin_is_implicit_lifetime(EnforceReadOnlyPlacement));2031  static_assert(__builtin_is_implicit_lifetime(int __attribute__((noderef)) *));2032  static_assert(__builtin_is_implicit_lifetime(TypeVisibility));2033  static_assert(__builtin_is_implicit_lifetime(int * _Nonnull));2034  static_assert(__builtin_is_implicit_lifetime(int * _Null_unspecified));2035  static_assert(__builtin_is_implicit_lifetime(int * _Nullable));2036  static_assert(!__builtin_is_implicit_lifetime(_Atomic int));2037  // expected-error@-1 {{atomic types are not supported in '__builtin_is_implicit_lifetime'}}2038  static_assert(__builtin_is_implicit_lifetime(int * __restrict));2039}2040 2041namespace GH160610 {2042class NonAggregate {2043public:2044    NonAggregate() = default;2045 2046    NonAggregate(const NonAggregate&)            = delete;2047    NonAggregate& operator=(const NonAggregate&) = delete;2048private:2049    int num;2050};2051 2052class DataMemberInitializer {2053public:2054    DataMemberInitializer() = default;2055 2056    DataMemberInitializer(const DataMemberInitializer&)            = delete;2057    DataMemberInitializer& operator=(const DataMemberInitializer&) = delete;2058private:2059    int num = 0;2060};2061 2062class UserProvidedConstructor {2063public:2064    UserProvidedConstructor() {}2065 2066    UserProvidedConstructor(const UserProvidedConstructor&)            = delete;2067    UserProvidedConstructor& operator=(const UserProvidedConstructor&) = delete;2068};2069struct Ctr {2070  Ctr();2071};2072struct Ctr2 {2073  Ctr2();2074private:2075  NoEligibleTrivialContructor inner;2076};2077 2078struct NonCopyable{2079    NonCopyable() = default;2080    NonCopyable(const NonCopyable&) = delete;2081};2082 2083class C {2084    NonCopyable nc;2085};2086 2087static_assert(__builtin_is_implicit_lifetime(Ctr));2088static_assert(!__builtin_is_implicit_lifetime(Ctr2));2089static_assert(__builtin_is_implicit_lifetime(C));2090static_assert(!__builtin_is_implicit_lifetime(NoEligibleTrivialContructor));2091static_assert(__builtin_is_implicit_lifetime(NonAggregate));2092static_assert(!__builtin_is_implicit_lifetime(DataMemberInitializer));2093static_assert(!__builtin_is_implicit_lifetime(UserProvidedConstructor));2094 2095#if __cplusplus >= 202002L2096template <typename T>2097class Tpl {2098    Tpl() requires false = default ;2099};2100static_assert(__builtin_is_implicit_lifetime(Tpl<int>));2101 2102template <typename>2103class MultipleDefaults {2104  MultipleDefaults() {};2105  MultipleDefaults() requires true = default;2106};2107static_assert(__builtin_is_implicit_lifetime(MultipleDefaults<int>));2108template <typename>2109class MultipleDefaults2 {2110  MultipleDefaults2() requires true {};2111  MultipleDefaults2() = default;2112};2113 2114static_assert(__builtin_is_implicit_lifetime(MultipleDefaults2<int>));2115 2116 2117#endif2118 2119 2120 2121}2122 2123void is_signed()2124{2125  //static_assert(__is_signed(char));2126  static_assert(__is_signed(int));2127  static_assert(__is_signed(long));2128  static_assert(__is_signed(short));2129  static_assert(__is_signed(signed char));2130  static_assert(__is_signed(wchar_t));2131  static_assert(__is_signed(float));2132  static_assert(__is_signed(double));2133  static_assert(__is_signed(long double));2134 2135  static_assert(!__is_signed(bool));2136  static_assert(!__is_signed(cvoid));2137  static_assert(!__is_signed(unsigned char));2138  static_assert(!__is_signed(unsigned int));2139  static_assert(!__is_signed(unsigned long long));2140  static_assert(!__is_signed(unsigned long));2141  static_assert(!__is_signed(unsigned short));2142  static_assert(!__is_signed(void));2143  static_assert(!__is_signed(ClassType));2144  static_assert(!__is_signed(Derives));2145  static_assert(!__is_signed(Enum));2146  static_assert(!__is_signed(SignedEnum));2147  static_assert(!__is_signed(IntArNB));2148  static_assert(!__is_signed(Union));2149  static_assert(!__is_signed(UnionAr));2150  static_assert(!__is_signed(UnsignedEnum));2151}2152 2153void is_unsigned()2154{2155  static_assert(__is_unsigned(bool));2156  static_assert(__is_unsigned(unsigned char));2157  static_assert(__is_unsigned(unsigned short));2158  static_assert(__is_unsigned(unsigned int));2159  static_assert(__is_unsigned(unsigned long));2160  static_assert(__is_unsigned(unsigned long long));2161 2162  static_assert(!__is_unsigned(void));2163  static_assert(!__is_unsigned(cvoid));2164  static_assert(!__is_unsigned(float));2165  static_assert(!__is_unsigned(double));2166  static_assert(!__is_unsigned(long double));2167  static_assert(!__is_unsigned(char));2168  static_assert(!__is_unsigned(signed char));2169  static_assert(!__is_unsigned(wchar_t));2170  static_assert(!__is_unsigned(short));2171  static_assert(!__is_unsigned(int));2172  static_assert(!__is_unsigned(long));2173  static_assert(!__is_unsigned(Union));2174  static_assert(!__is_unsigned(UnionAr));2175  static_assert(!__is_unsigned(Derives));2176  static_assert(!__is_unsigned(ClassType));2177  static_assert(!__is_unsigned(IntArNB));2178  static_assert(!__is_unsigned(Enum));2179  static_assert(!__is_unsigned(UnsignedEnum));2180  static_assert(!__is_unsigned(SignedEnum));2181}2182 2183typedef Int& IntRef;2184typedef const IntAr ConstIntAr;2185typedef ConstIntAr ConstIntArAr[4];2186 2187struct HasCopy {2188  HasCopy(HasCopy& cp);2189};2190 2191struct HasMove {2192  HasMove(HasMove&& cp);2193};2194 2195struct HasTemplateCons {2196  HasVirt Annoying;2197 2198  template <typename T>2199  HasTemplateCons(const T&);2200};2201 2202void has_trivial_default_constructor() {2203  static_assert(__has_trivial_constructor(Int));2204  static_assert(__has_trivial_constructor(IntAr));2205  static_assert(__has_trivial_constructor(Union));2206  static_assert(__has_trivial_constructor(UnionAr));2207  static_assert(__has_trivial_constructor(POD));2208  static_assert(__has_trivial_constructor(Derives));2209  static_assert(__has_trivial_constructor(DerivesAr));2210  static_assert(__has_trivial_constructor(ConstIntAr));2211  static_assert(__has_trivial_constructor(ConstIntArAr));2212  static_assert(__has_trivial_constructor(HasDest));2213  static_assert(__has_trivial_constructor(HasPriv));2214  static_assert(__has_trivial_constructor(HasCopyAssign));2215  static_assert(__has_trivial_constructor(HasMoveAssign));2216  static_assert(__has_trivial_constructor(const Int));2217  static_assert(__has_trivial_constructor(AllDefaulted));2218  static_assert(__has_trivial_constructor(AllDeleted));2219  static_assert(__has_trivial_constructor(ACompleteType[]));2220 2221  static_assert(!__has_trivial_constructor(AnIncompleteType[])); // expected-error {{incomplete type}}2222  static_assert(!__has_trivial_constructor(HasCons));2223  static_assert(!__has_trivial_constructor(HasRef));2224  static_assert(!__has_trivial_constructor(HasCopy));2225  static_assert(!__has_trivial_constructor(IntRef));2226  static_assert(!__has_trivial_constructor(VirtAr));2227  static_assert(!__has_trivial_constructor(void));2228  static_assert(!__has_trivial_constructor(cvoid));2229  static_assert(!__has_trivial_constructor(HasTemplateCons));2230  static_assert(!__has_trivial_constructor(AllPrivate));2231  static_assert(!__has_trivial_constructor(ExtDefaulted));2232}2233 2234void has_trivial_move_constructor() {2235  // n3376 12.8 [class.copy]/122236  // A copy/move constructor for class X is trivial if it is not2237  // user-provided, its declared parameter type is the same as2238  // if it had been implicitly declared, and if2239  //   - class X has no virtual functions (10.3) and no virtual2240  //     base classes (10.1), and2241  //   - the constructor selected to copy/move each direct base2242  //     class subobject is trivial, and2243  //   - for each non-static data member of X that is of class2244  //     type (or array thereof), the constructor selected2245  //     to copy/move that member is trivial;2246  // otherwise the copy/move constructor is non-trivial.2247  static_assert(__has_trivial_move_constructor(POD));2248  static_assert(__has_trivial_move_constructor(Union));2249  static_assert(__has_trivial_move_constructor(HasCons));2250  static_assert(__has_trivial_move_constructor(HasStaticMemberMoveCtor));2251  static_assert(__has_trivial_move_constructor(AllDeleted));2252  static_assert(__has_trivial_move_constructor(ACompleteType[]));2253 2254  static_assert(!__has_trivial_move_constructor(AnIncompleteType[])); // expected-error {{incomplete type}}2255  static_assert(!__has_trivial_move_constructor(HasVirt));2256  static_assert(!__has_trivial_move_constructor(DerivesVirt));2257  static_assert(!__has_trivial_move_constructor(HasMoveCtor));2258  static_assert(!__has_trivial_move_constructor(DerivesHasMoveCtor));2259  static_assert(!__has_trivial_move_constructor(HasMemberMoveCtor));2260}2261 2262void has_trivial_copy_constructor() {2263  static_assert(__has_trivial_copy(Int));2264  static_assert(__has_trivial_copy(IntAr));2265  static_assert(__has_trivial_copy(Union));2266  static_assert(__has_trivial_copy(UnionAr));2267  static_assert(__has_trivial_copy(POD));2268  static_assert(__has_trivial_copy(Derives));2269  static_assert(__has_trivial_copy(ConstIntAr));2270  static_assert(__has_trivial_copy(ConstIntArAr));2271  static_assert(__has_trivial_copy(HasDest));2272  static_assert(__has_trivial_copy(HasPriv));2273  static_assert(__has_trivial_copy(HasCons));2274  static_assert(__has_trivial_copy(HasRef));2275  static_assert(__has_trivial_copy(HasMove));2276  static_assert(__has_trivial_copy(IntRef));2277  static_assert(__has_trivial_copy(HasCopyAssign));2278  static_assert(__has_trivial_copy(HasMoveAssign));2279  static_assert(__has_trivial_copy(const Int));2280  static_assert(__has_trivial_copy(AllDefaulted));2281  static_assert(__has_trivial_copy(AllDeleted));2282  static_assert(__has_trivial_copy(DerivesAr));2283  static_assert(__has_trivial_copy(DerivesHasRef));2284  static_assert(__has_trivial_copy(ACompleteType[]));2285 2286  static_assert(!__has_trivial_copy(AnIncompleteType[])); // expected-error {{incomplete type}}2287  static_assert(!__has_trivial_copy(HasCopy));2288  static_assert(!__has_trivial_copy(HasTemplateCons));2289  static_assert(!__has_trivial_copy(VirtAr));2290  static_assert(!__has_trivial_copy(void));2291  static_assert(!__has_trivial_copy(cvoid));2292  static_assert(!__has_trivial_copy(AllPrivate));2293  static_assert(!__has_trivial_copy(ExtDefaulted));2294}2295 2296void has_trivial_copy_assignment() {2297  static_assert(__has_trivial_assign(Int));2298  static_assert(__has_trivial_assign(IntAr));2299  static_assert(__has_trivial_assign(Union));2300  static_assert(__has_trivial_assign(UnionAr));2301  static_assert(__has_trivial_assign(POD));2302  static_assert(__has_trivial_assign(Derives));2303  static_assert(__has_trivial_assign(HasDest));2304  static_assert(__has_trivial_assign(HasPriv));2305  static_assert(__has_trivial_assign(HasCons));2306  static_assert(__has_trivial_assign(HasRef));2307  static_assert(__has_trivial_assign(HasCopy));2308  static_assert(__has_trivial_assign(HasMove));2309  static_assert(__has_trivial_assign(HasMoveAssign));2310  static_assert(__has_trivial_assign(AllDefaulted));2311  static_assert(__has_trivial_assign(AllDeleted));2312  static_assert(__has_trivial_assign(DerivesAr));2313  static_assert(__has_trivial_assign(DerivesHasRef));2314  static_assert(__has_trivial_assign(ACompleteType[]));2315 2316  static_assert(!__has_trivial_assign(AnIncompleteType[])); // expected-error {{incomplete type}}2317  static_assert(!__has_trivial_assign(IntRef));2318  static_assert(!__has_trivial_assign(HasCopyAssign));2319  static_assert(!__has_trivial_assign(const Int));2320  static_assert(!__has_trivial_assign(ConstIntAr));2321  static_assert(!__has_trivial_assign(ConstIntArAr));2322  static_assert(!__has_trivial_assign(VirtAr));2323  static_assert(!__has_trivial_assign(void));2324  static_assert(!__has_trivial_assign(cvoid));2325  static_assert(!__has_trivial_assign(AllPrivate));2326  static_assert(!__has_trivial_assign(ExtDefaulted));2327}2328 2329void has_trivial_destructor() {2330  static_assert(__has_trivial_destructor(Int));2331  static_assert(__has_trivial_destructor(IntAr));2332  static_assert(__has_trivial_destructor(Union));2333  static_assert(__has_trivial_destructor(UnionAr));2334  static_assert(__has_trivial_destructor(POD));2335  static_assert(__has_trivial_destructor(Derives));2336  static_assert(__has_trivial_destructor(ConstIntAr));2337  static_assert(__has_trivial_destructor(ConstIntArAr));2338  static_assert(__has_trivial_destructor(HasPriv));2339  static_assert(__has_trivial_destructor(HasCons));2340  static_assert(__has_trivial_destructor(HasRef));2341  static_assert(__has_trivial_destructor(HasCopy));2342  static_assert(__has_trivial_destructor(HasMove));2343  static_assert(__has_trivial_destructor(IntRef));2344  static_assert(__has_trivial_destructor(HasCopyAssign));2345  static_assert(__has_trivial_destructor(HasMoveAssign));2346  static_assert(__has_trivial_destructor(const Int));2347  static_assert(__has_trivial_destructor(DerivesAr));2348  static_assert(__has_trivial_destructor(VirtAr));2349  static_assert(__has_trivial_destructor(AllDefaulted));2350  static_assert(__has_trivial_destructor(AllDeleted));2351  static_assert(__has_trivial_destructor(DerivesHasRef));2352  static_assert(__has_trivial_destructor(ACompleteType[]));2353 2354  static_assert(!__has_trivial_destructor(HasDest));2355  static_assert(!__has_trivial_destructor(AnIncompleteType[])); // expected-error {{incomplete type}}2356  static_assert(!__has_trivial_destructor(void));2357  static_assert(!__has_trivial_destructor(cvoid));2358  static_assert(!__has_trivial_destructor(AllPrivate));2359  static_assert(!__has_trivial_destructor(ExtDefaulted));2360}2361 2362struct A { ~A() {} };2363template<typename> struct B : A { };2364 2365void f() {2366  static_assert(!__has_trivial_destructor(A));2367  static_assert(!__has_trivial_destructor(B<int>));2368}2369 2370class PR11110 {2371  template <int> int operator=( int );2372  int operator=(PR11110);2373};2374 2375class UsingAssign;2376 2377class UsingAssignBase {2378protected:2379  UsingAssign &operator=(const UsingAssign&) throw();2380};2381 2382class UsingAssign : public UsingAssignBase {2383public:2384  using UsingAssignBase::operator=;2385};2386 2387void has_nothrow_assign() {2388  static_assert(__has_nothrow_assign(Int));2389  static_assert(__has_nothrow_assign(IntAr));2390  static_assert(__has_nothrow_assign(Union));2391  static_assert(__has_nothrow_assign(UnionAr));2392  static_assert(__has_nothrow_assign(POD));2393  static_assert(__has_nothrow_assign(Derives));2394  static_assert(__has_nothrow_assign(HasDest));2395  static_assert(__has_nothrow_assign(HasPriv));2396  static_assert(__has_nothrow_assign(HasCons));2397  static_assert(__has_nothrow_assign(HasRef));2398  static_assert(__has_nothrow_assign(HasCopy));2399  static_assert(__has_nothrow_assign(HasMove));2400  static_assert(__has_nothrow_assign(HasMoveAssign));2401  static_assert(__has_nothrow_assign(HasNoThrowCopyAssign));2402  static_assert(__has_nothrow_assign(HasMultipleNoThrowCopyAssign));2403  static_assert(__has_nothrow_assign(HasVirtDest));2404  static_assert(__has_nothrow_assign(AllPrivate));2405  static_assert(__has_nothrow_assign(UsingAssign));2406  static_assert(__has_nothrow_assign(DerivesAr));2407  static_assert(__has_nothrow_assign(ACompleteType[]));2408 2409  static_assert(!__has_nothrow_assign(AnIncompleteType[])); // expected-error {{incomplete type}}2410  static_assert(!__has_nothrow_assign(IntRef));2411  static_assert(!__has_nothrow_assign(HasCopyAssign));2412  static_assert(!__has_nothrow_assign(HasMultipleCopyAssign));2413  static_assert(!__has_nothrow_assign(const Int));2414  static_assert(!__has_nothrow_assign(ConstIntAr));2415  static_assert(!__has_nothrow_assign(ConstIntArAr));2416  static_assert(!__has_nothrow_assign(VirtAr));2417  static_assert(!__has_nothrow_assign(void));2418  static_assert(!__has_nothrow_assign(cvoid));2419  static_assert(!__has_nothrow_assign(PR11110));2420}2421 2422void has_nothrow_move_assign() {2423  static_assert(__has_nothrow_move_assign(Int));2424  static_assert(__has_nothrow_move_assign(Enum));2425  static_assert(__has_nothrow_move_assign(Int*));2426  static_assert(__has_nothrow_move_assign(Enum POD::*));2427  static_assert(__has_nothrow_move_assign(POD));2428  static_assert(__has_nothrow_move_assign(HasPriv));2429  static_assert(__has_nothrow_move_assign(HasNoThrowMoveAssign));2430  static_assert(__has_nothrow_move_assign(HasNoExceptNoThrowMoveAssign));2431  static_assert(__has_nothrow_move_assign(HasMemberNoThrowMoveAssign));2432  static_assert(__has_nothrow_move_assign(HasMemberNoExceptNoThrowMoveAssign));2433  static_assert(__has_nothrow_move_assign(AllDeleted));2434  static_assert(__has_nothrow_move_assign(ACompleteType[]));2435 2436  static_assert(!__has_nothrow_move_assign(AnIncompleteType[])); // expected-error {{incomplete type}}2437  static_assert(!__has_nothrow_move_assign(HasThrowMoveAssign));2438  static_assert(!__has_nothrow_move_assign(HasNoExceptFalseMoveAssign));2439  static_assert(!__has_nothrow_move_assign(HasMemberThrowMoveAssign));2440  static_assert(!__has_nothrow_move_assign(HasMemberNoExceptFalseMoveAssign));2441  static_assert(!__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyCtor));2442  static_assert(!__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyAssign));2443  static_assert(!__has_nothrow_move_assign(NoDefaultMoveAssignDueToDtor));2444 2445 2446  static_assert(__is_nothrow_assignable(HasNoThrowMoveAssign, HasNoThrowMoveAssign));2447  static_assert(!__is_nothrow_assignable(HasThrowMoveAssign, HasThrowMoveAssign));2448 2449  static_assert(__is_assignable(HasNoThrowMoveAssign, HasNoThrowMoveAssign));2450  static_assert(__is_assignable(HasThrowMoveAssign, HasThrowMoveAssign));2451}2452 2453void has_trivial_move_assign() {2454  // n3376 12.8 [class.copy]/252455  // A copy/move assignment operator for class X is trivial if it2456  // is not user-provided, its declared parameter type is the same2457  // as if it had been implicitly declared, and if:2458  //  - class X has no virtual functions (10.3) and no virtual base2459  //    classes (10.1), and2460  //  - the assignment operator selected to copy/move each direct2461  //    base class subobject is trivial, and2462  //  - for each non-static data member of X that is of class type2463  //    (or array thereof), the assignment operator2464  //    selected to copy/move that member is trivial;2465  static_assert(__has_trivial_move_assign(Int));2466  static_assert(__has_trivial_move_assign(HasStaticMemberMoveAssign));2467  static_assert(__has_trivial_move_assign(AllDeleted));2468  static_assert(__has_trivial_move_assign(ACompleteType[]));2469 2470  static_assert(!__has_trivial_move_assign(AnIncompleteType[])); // expected-error {{incomplete type}}2471  static_assert(!__has_trivial_move_assign(HasVirt));2472  static_assert(!__has_trivial_move_assign(DerivesVirt));2473  static_assert(!__has_trivial_move_assign(HasMoveAssign));2474  static_assert(!__has_trivial_move_assign(DerivesHasMoveAssign));2475  static_assert(!__has_trivial_move_assign(HasMemberMoveAssign));2476  static_assert(!__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyCtor));2477  static_assert(!__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyAssign));2478}2479 2480void has_nothrow_copy() {2481  static_assert(__has_nothrow_copy(Int));2482  static_assert(__has_nothrow_copy(IntAr));2483  static_assert(__has_nothrow_copy(Union));2484  static_assert(__has_nothrow_copy(UnionAr));2485  static_assert(__has_nothrow_copy(POD));2486  static_assert(__has_nothrow_copy(const Int));2487  static_assert(__has_nothrow_copy(ConstIntAr));2488  static_assert(__has_nothrow_copy(ConstIntArAr));2489  static_assert(__has_nothrow_copy(Derives));2490  static_assert(__has_nothrow_copy(IntRef));2491  static_assert(__has_nothrow_copy(HasDest));2492  static_assert(__has_nothrow_copy(HasPriv));2493  static_assert(__has_nothrow_copy(HasCons));2494  static_assert(__has_nothrow_copy(HasRef));2495  static_assert(__has_nothrow_copy(HasMove));2496  static_assert(__has_nothrow_copy(HasCopyAssign));2497  static_assert(__has_nothrow_copy(HasMoveAssign));2498  static_assert(__has_nothrow_copy(HasNoThrowCopy));2499  static_assert(__has_nothrow_copy(HasMultipleNoThrowCopy));2500  static_assert(__has_nothrow_copy(HasVirtDest));2501  static_assert(__has_nothrow_copy(HasTemplateCons));2502  static_assert(__has_nothrow_copy(AllPrivate));2503  static_assert(__has_nothrow_copy(DerivesAr));2504  static_assert(__has_nothrow_copy(ACompleteType[]));2505 2506  static_assert(!__has_nothrow_copy(AnIncompleteType[])); // expected-error {{incomplete type}}2507  static_assert(!__has_nothrow_copy(HasCopy));2508  static_assert(!__has_nothrow_copy(HasMultipleCopy));2509  static_assert(!__has_nothrow_copy(VirtAr));2510  static_assert(!__has_nothrow_copy(void));2511  static_assert(!__has_nothrow_copy(cvoid));2512}2513 2514void has_nothrow_constructor() {2515  static_assert(__has_nothrow_constructor(Int));2516  static_assert(__has_nothrow_constructor(IntAr));2517  static_assert(__has_nothrow_constructor(Union));2518  static_assert(__has_nothrow_constructor(UnionAr));2519  static_assert(__has_nothrow_constructor(POD));2520  static_assert(__has_nothrow_constructor(Derives));2521  static_assert(__has_nothrow_constructor(DerivesAr));2522  static_assert(__has_nothrow_constructor(ConstIntAr));2523  static_assert(__has_nothrow_constructor(ConstIntArAr));2524  static_assert(__has_nothrow_constructor(HasDest));2525  static_assert(__has_nothrow_constructor(HasPriv));2526  static_assert(__has_nothrow_constructor(HasCopyAssign));2527  static_assert(__has_nothrow_constructor(const Int));2528  static_assert(__has_nothrow_constructor(HasNoThrowConstructor));2529  static_assert(__has_nothrow_constructor(HasVirtDest));2530  // static_assert(__has_nothrow_constructor(VirtAr)); // not implemented2531  static_assert(__has_nothrow_constructor(AllPrivate));2532  static_assert(__has_nothrow_constructor(ACompleteType[]));2533 2534  static_assert(!__has_nothrow_constructor(AnIncompleteType[])); // expected-error {{incomplete type}}2535  static_assert(!__has_nothrow_constructor(HasCons));2536  static_assert(!__has_nothrow_constructor(HasRef));2537  static_assert(!__has_nothrow_constructor(HasCopy));2538  static_assert(!__has_nothrow_constructor(HasMove));2539  static_assert(!__has_nothrow_constructor(HasNoThrowConstructorWithArgs));2540  static_assert(!__has_nothrow_constructor(IntRef));2541  static_assert(!__has_nothrow_constructor(void));2542  static_assert(!__has_nothrow_constructor(cvoid));2543  static_assert(!__has_nothrow_constructor(HasTemplateCons));2544 2545  static_assert(!__has_nothrow_constructor(HasMultipleDefaultConstructor1));2546  static_assert(!__has_nothrow_constructor(HasMultipleDefaultConstructor2));2547}2548 2549void has_virtual_destructor() {2550  static_assert(!__has_virtual_destructor(Int));2551  static_assert(!__has_virtual_destructor(IntAr));2552  static_assert(!__has_virtual_destructor(Union));2553  static_assert(!__has_virtual_destructor(UnionAr));2554  static_assert(!__has_virtual_destructor(POD));2555  static_assert(!__has_virtual_destructor(Derives));2556  static_assert(!__has_virtual_destructor(DerivesAr));2557  static_assert(!__has_virtual_destructor(const Int));2558  static_assert(!__has_virtual_destructor(ConstIntAr));2559  static_assert(!__has_virtual_destructor(ConstIntArAr));2560  static_assert(!__has_virtual_destructor(HasDest));2561  static_assert(!__has_virtual_destructor(HasPriv));2562  static_assert(!__has_virtual_destructor(HasCons));2563  static_assert(!__has_virtual_destructor(HasRef));2564  static_assert(!__has_virtual_destructor(HasCopy));2565  static_assert(!__has_virtual_destructor(HasMove));2566  static_assert(!__has_virtual_destructor(HasCopyAssign));2567  static_assert(!__has_virtual_destructor(HasMoveAssign));2568  static_assert(!__has_virtual_destructor(IntRef));2569  static_assert(!__has_virtual_destructor(VirtAr));2570  static_assert(!__has_virtual_destructor(ACompleteType[]));2571 2572  static_assert(!__has_virtual_destructor(AnIncompleteType[])); // expected-error {{incomplete type}}2573  static_assert(__has_virtual_destructor(HasVirtDest));2574  static_assert(__has_virtual_destructor(DerivedVirtDest));2575  static_assert(!__has_virtual_destructor(VirtDestAr));2576  static_assert(!__has_virtual_destructor(void));2577  static_assert(!__has_virtual_destructor(cvoid));2578  static_assert(!__has_virtual_destructor(AllPrivate));2579}2580 2581 2582class Base {};2583class Derived : Base {};2584class Derived2a : Derived {};2585class Derived2b : Derived {};2586class Derived3 : virtual Derived2a, virtual Derived2b {};2587template<typename T> struct BaseA { T a;  };2588template<typename T> struct DerivedB : BaseA<T> { };2589template<typename T> struct CrazyDerived : T { };2590 2591 2592class class_forward; // expected-note 4 {{forward declaration of 'class_forward'}}2593 2594template <class T> class DerivedTemp : Base {};2595template <class T> class NonderivedTemp {};2596template <class T> class UndefinedTemp; // expected-note 2 {{declared here}}2597 2598void is_base_of() {2599  static_assert(__is_base_of(Base, Derived));2600  static_assert(__is_base_of(const Base, Derived));2601  static_assert(!__is_base_of(Derived, Base));2602  static_assert(!__is_base_of(Derived, int));2603  static_assert(__is_base_of(Base, Base));2604  static_assert(__is_base_of(Base, Derived3));2605  static_assert(__is_base_of(Derived, Derived3));2606  static_assert(__is_base_of(Derived2b, Derived3));2607  static_assert(__is_base_of(Derived2a, Derived3));2608  static_assert(__is_base_of(BaseA<int>, DerivedB<int>));2609  static_assert(!__is_base_of(DerivedB<int>, BaseA<int>));2610  static_assert(__is_base_of(Base, CrazyDerived<Base>));2611  static_assert(!__is_base_of(Union, Union));2612  static_assert(__is_base_of(Empty, Empty));2613  static_assert(__is_base_of(class_forward, class_forward));2614  static_assert(!__is_base_of(Empty, class_forward)); // expected-error {{incomplete type 'class_forward' used in type trait expression}}2615  static_assert(!__is_base_of(Base&, Derived&));2616  static_assert(!__is_base_of(Base[10], Derived[10]));2617  static_assert(!__is_base_of(int, int));2618  static_assert(!__is_base_of(long, int));2619  static_assert(__is_base_of(Base, DerivedTemp<int>));2620  static_assert(!__is_base_of(Base, NonderivedTemp<int>));2621  static_assert(!__is_base_of(Base, UndefinedTemp<int>)); // expected-error {{implicit instantiation of undefined template 'UndefinedTemp<int>'}}2622 2623  static_assert(!__is_base_of(IncompleteUnion, IncompleteUnion));2624  static_assert(!__is_base_of(Union, IncompleteUnion));2625  static_assert(!__is_base_of(IncompleteUnion, Union));2626  static_assert(!__is_base_of(IncompleteStruct, IncompleteUnion));2627  static_assert(!__is_base_of(IncompleteUnion, IncompleteStruct));2628  static_assert(!__is_base_of(Empty, IncompleteUnion));2629  static_assert(!__is_base_of(IncompleteUnion, Empty));2630  static_assert(!__is_base_of(int, IncompleteUnion));2631  static_assert(!__is_base_of(IncompleteUnion, int));2632  static_assert(!__is_base_of(Empty, Union));2633  static_assert(!__is_base_of(Union, Empty));2634  static_assert(!__is_base_of(int, Empty));2635  static_assert(!__is_base_of(Union, int));2636 2637  static_assert(__is_base_of(Base, Derived));2638  static_assert(!__is_base_of(Derived, Base));2639 2640  static_assert(__is_base_of(Base, CrazyDerived<Base>));2641  static_assert(!__is_base_of(CrazyDerived<Base>, Base));2642 2643  static_assert(__is_base_of(BaseA<int>, DerivedB<int>));2644  static_assert(!__is_base_of(DerivedB<int>, BaseA<int>));2645}2646 2647struct DerivedTransitiveViaNonVirtual : Derived3 {};2648struct DerivedTransitiveViaVirtual : virtual Derived3 {};2649 2650template <typename T>2651struct CrazyDerivedVirtual : virtual T {};2652 2653struct DerivedPrivate : private virtual Base {};2654struct DerivedProtected : protected virtual Base {};2655struct DerivedPrivatePrivate : private DerivedPrivate {};2656struct DerivedPrivateProtected : private DerivedProtected {};2657struct DerivedProtectedPrivate : protected DerivedProtected {};2658struct DerivedProtectedProtected : protected DerivedProtected {};2659 2660void is_virtual_base_of(int n) {2661  static_assert(!__builtin_is_virtual_base_of(Base, Derived));2662  static_assert(!__builtin_is_virtual_base_of(const Base, Derived));2663  static_assert(!__builtin_is_virtual_base_of(Derived, Base));2664  static_assert(!__builtin_is_virtual_base_of(Derived, int));2665  static_assert(!__builtin_is_virtual_base_of(Base, Base));2666  static_assert(!__builtin_is_virtual_base_of(Base, Derived3));2667  static_assert(!__builtin_is_virtual_base_of(Derived, Derived3));2668  static_assert(__builtin_is_virtual_base_of(Derived2b, Derived3));2669  static_assert(__builtin_is_virtual_base_of(Derived2a, Derived3));2670  static_assert(!__builtin_is_virtual_base_of(BaseA<int>, DerivedB<int>));2671  static_assert(!__builtin_is_virtual_base_of(DerivedB<int>, BaseA<int>));2672  static_assert(!__builtin_is_virtual_base_of(Union, Union));2673  static_assert(!__builtin_is_virtual_base_of(Empty, Empty));2674  static_assert(!__builtin_is_virtual_base_of(class_forward, class_forward)); // expected-error {{incomplete type 'class_forward' where a complete type is required}}2675  static_assert(!__builtin_is_virtual_base_of(Empty, class_forward)); // expected-error {{incomplete type 'class_forward' where a complete type is required}}2676  static_assert(!__builtin_is_virtual_base_of(class_forward, Empty));2677  static_assert(!__builtin_is_virtual_base_of(Base&, Derived&));2678  static_assert(!__builtin_is_virtual_base_of(Base[10], Derived[10]));2679  static_assert(!__builtin_is_virtual_base_of(Base[n], Derived[n])); // expected-error 2 {{variable length arrays are not supported in '__builtin_is_virtual_base_of'}}2680  static_assert(!__builtin_is_virtual_base_of(int, int));2681  static_assert(!__builtin_is_virtual_base_of(int[], int[]));2682  static_assert(!__builtin_is_virtual_base_of(long, int));2683  static_assert(!__builtin_is_virtual_base_of(Base, DerivedTemp<int>));2684  static_assert(!__builtin_is_virtual_base_of(Base, NonderivedTemp<int>));2685  static_assert(!__builtin_is_virtual_base_of(Base, UndefinedTemp<int>)); // expected-error {{implicit instantiation of undefined template 'UndefinedTemp<int>'}}2686  static_assert(__builtin_is_virtual_base_of(Base, DerivedPrivate));2687  static_assert(__builtin_is_virtual_base_of(Base, DerivedProtected));2688  static_assert(__builtin_is_virtual_base_of(Base, DerivedPrivatePrivate));2689  static_assert(__builtin_is_virtual_base_of(Base, DerivedPrivateProtected));2690  static_assert(__builtin_is_virtual_base_of(Base, DerivedProtectedPrivate));2691  static_assert(__builtin_is_virtual_base_of(Base, DerivedProtectedProtected));2692  static_assert(__builtin_is_virtual_base_of(Derived2a, DerivedTransitiveViaNonVirtual));2693  static_assert(__builtin_is_virtual_base_of(Derived2b, DerivedTransitiveViaNonVirtual));2694  static_assert(__builtin_is_virtual_base_of(Derived2a, DerivedTransitiveViaVirtual));2695  static_assert(__builtin_is_virtual_base_of(Derived2b, DerivedTransitiveViaVirtual));2696  static_assert(!__builtin_is_virtual_base_of(Base, CrazyDerived<Base>));2697  static_assert(!__builtin_is_virtual_base_of(CrazyDerived<Base>, Base));2698  static_assert(__builtin_is_virtual_base_of(Base, CrazyDerivedVirtual<Base>));2699  static_assert(!__builtin_is_virtual_base_of(CrazyDerivedVirtual<Base>, Base));2700 2701  static_assert(!__builtin_is_virtual_base_of(IncompleteUnion, IncompleteUnion));2702  static_assert(!__builtin_is_virtual_base_of(Union, IncompleteUnion));2703  static_assert(!__builtin_is_virtual_base_of(IncompleteUnion, Union));2704  static_assert(!__builtin_is_virtual_base_of(IncompleteStruct, IncompleteUnion));2705  static_assert(!__builtin_is_virtual_base_of(IncompleteUnion, IncompleteStruct));2706  static_assert(!__builtin_is_virtual_base_of(Empty, IncompleteUnion));2707  static_assert(!__builtin_is_virtual_base_of(IncompleteUnion, Empty));2708  static_assert(!__builtin_is_virtual_base_of(int, IncompleteUnion));2709  static_assert(!__builtin_is_virtual_base_of(IncompleteUnion, int));2710  static_assert(!__builtin_is_virtual_base_of(Empty, Union));2711  static_assert(!__builtin_is_virtual_base_of(Union, Empty));2712  static_assert(!__builtin_is_virtual_base_of(int, Empty));2713  static_assert(!__builtin_is_virtual_base_of(Union, int));2714  static_assert(!__builtin_is_virtual_base_of(IncompleteStruct, IncompleteStruct[n])); // expected-error {{variable length arrays are not supported in '__builtin_is_virtual_base_of'}}2715}2716 2717template<class T, class U>2718class TemplateClass {};2719 2720template<class T>2721using TemplateAlias = TemplateClass<T, int>;2722 2723typedef class Base BaseTypedef;2724 2725void is_same()2726{2727  static_assert(__is_same(Base, Base));2728  static_assert(__is_same(Base, BaseTypedef));2729  static_assert(__is_same(TemplateClass<int, int>, TemplateAlias<int>));2730 2731  static_assert(!__is_same(Base, const Base));2732  static_assert(!__is_same(Base, Base&));2733  static_assert(!__is_same(Base, Derived));2734 2735  // __is_same_as is a GCC compatibility synonym for __is_same.2736  static_assert(__is_same_as(int, int));2737  static_assert(!__is_same_as(int, float));2738}2739 2740struct IntWrapper2741{2742  int value;2743  IntWrapper(int _value) : value(_value) {}2744  operator int() const noexcept {2745    return value;2746  }2747};2748 2749struct FloatWrapper2750{2751  float value;2752  FloatWrapper(float _value) noexcept : value(_value) {}2753  FloatWrapper(const IntWrapper& obj)2754    : value(static_cast<float>(obj.value)) {}2755  operator float() const {2756    return value;2757  }2758  operator IntWrapper() const {2759    return IntWrapper(static_cast<int>(value));2760  }2761};2762 2763template<typename A, typename B, bool result = __is_convertible(A, B)>2764static constexpr bool is_convertible_sfinae() { return result; }2765 2766void is_convertible()2767{2768  static_assert(__is_convertible(IntWrapper, IntWrapper));2769  static_assert(__is_convertible(IntWrapper, const IntWrapper));2770  static_assert(__is_convertible(IntWrapper, int));2771  static_assert(__is_convertible(int, IntWrapper));2772  static_assert(__is_convertible(IntWrapper, FloatWrapper));2773  static_assert(__is_convertible(FloatWrapper, IntWrapper));2774  static_assert(__is_convertible(FloatWrapper, float));2775  static_assert(__is_convertible(float, FloatWrapper));2776  static_assert(__is_convertible(IntWrapper, IntWrapper&&));2777  static_assert(__is_convertible(IntWrapper, const IntWrapper&));2778  static_assert(__is_convertible(IntWrapper, int&&));2779  static_assert(__is_convertible(IntWrapper, const int&));2780  static_assert(__is_convertible(int, IntWrapper&&));2781  static_assert(__is_convertible(int, const IntWrapper&));2782  static_assert(__is_convertible(IntWrapper, FloatWrapper&&));2783  static_assert(__is_convertible(IntWrapper, const FloatWrapper&));2784  static_assert(__is_convertible(FloatWrapper, IntWrapper&&));2785  static_assert(__is_convertible(FloatWrapper, const IntWrapper&&));2786  static_assert(__is_convertible(FloatWrapper, float&&));2787  static_assert(__is_convertible(FloatWrapper, const float&));2788  static_assert(__is_convertible(float, FloatWrapper&&));2789  static_assert(__is_convertible(float, const FloatWrapper&));2790 2791  static_assert(!__is_convertible(AllPrivate, AllPrivate));2792  // Make sure we don't emit "calling a private constructor" in SFINAE context.2793  static_assert(!is_convertible_sfinae<AllPrivate, AllPrivate>());2794}2795 2796void is_nothrow_convertible()2797{2798  static_assert(__is_nothrow_convertible(IntWrapper, IntWrapper));2799  static_assert(__is_nothrow_convertible(IntWrapper, const IntWrapper));2800  static_assert(__is_nothrow_convertible(IntWrapper, int));2801  static_assert(!__is_nothrow_convertible(int, IntWrapper));2802  static_assert(!__is_nothrow_convertible(IntWrapper, FloatWrapper));2803  static_assert(!__is_nothrow_convertible(FloatWrapper, IntWrapper));2804  static_assert(!__is_nothrow_convertible(FloatWrapper, float));2805  static_assert(__is_nothrow_convertible(float, FloatWrapper));2806  static_assert(__is_nothrow_convertible(IntWrapper, IntWrapper&&));2807  static_assert(__is_nothrow_convertible(IntWrapper, const IntWrapper&));2808  static_assert(__is_nothrow_convertible(IntWrapper, int&&));2809  static_assert(__is_nothrow_convertible(IntWrapper, const int&));2810  static_assert(!__is_nothrow_convertible(int, IntWrapper&&));2811  static_assert(!__is_nothrow_convertible(int, const IntWrapper&));2812  static_assert(!__is_nothrow_convertible(IntWrapper, FloatWrapper&&));2813  static_assert(!__is_nothrow_convertible(IntWrapper, const FloatWrapper&));2814  static_assert(!__is_nothrow_convertible(FloatWrapper, IntWrapper&&));2815  static_assert(!__is_nothrow_convertible(FloatWrapper, const IntWrapper&));2816  static_assert(!__is_nothrow_convertible(FloatWrapper, float&&));2817  static_assert(!__is_nothrow_convertible(FloatWrapper, const float&));2818  static_assert(__is_nothrow_convertible(float, FloatWrapper&&));2819  static_assert(__is_nothrow_convertible(float, const FloatWrapper&));2820}2821 2822struct FromInt { FromInt(int); };2823struct ToInt { operator int(); };2824typedef void Function();2825 2826void is_convertible_to();2827class PrivateCopy {2828  PrivateCopy(const PrivateCopy&);2829  friend void is_convertible_to();2830};2831 2832template<typename T>2833struct X0 {2834  template<typename U> X0(const X0<U>&);2835};2836 2837struct Abstract { virtual void f() = 0; };2838 2839void is_convertible_to() {2840  static_assert(__is_convertible_to(Int, Int));2841  static_assert(!__is_convertible_to(Int, IntAr));2842  static_assert(!__is_convertible_to(IntAr, IntAr));2843  static_assert(__is_convertible_to(void, void));2844  static_assert(__is_convertible_to(cvoid, void));2845  static_assert(__is_convertible_to(void, cvoid));2846  static_assert(__is_convertible_to(cvoid, cvoid));2847  static_assert(__is_convertible_to(int, FromInt));2848  static_assert(__is_convertible_to(long, FromInt));2849  static_assert(__is_convertible_to(double, FromInt));2850  static_assert(__is_convertible_to(const int, FromInt));2851  static_assert(__is_convertible_to(const int&, FromInt));2852  static_assert(__is_convertible_to(ToInt, int));2853  static_assert(__is_convertible_to(ToInt, const int&));2854  static_assert(__is_convertible_to(ToInt, long));2855  static_assert(!__is_convertible_to(ToInt, int&));2856  static_assert(!__is_convertible_to(ToInt, FromInt));2857  static_assert(__is_convertible_to(IntAr&, IntAr&));2858  static_assert(__is_convertible_to(IntAr&, const IntAr&));2859  static_assert(!__is_convertible_to(const IntAr&, IntAr&));2860  static_assert(!__is_convertible_to(Function, Function));2861  static_assert(!__is_convertible_to(PrivateCopy, PrivateCopy));2862  static_assert(__is_convertible_to(X0<int>, X0<float>));2863  static_assert(!__is_convertible_to(Abstract, Abstract));2864}2865 2866namespace is_convertible_to_instantiate {2867  // Make sure we don't try to instantiate the constructor.2868  template<int x> class A { A(int) { int a[x]; } };2869  int x = __is_convertible_to(int, A<-1>);2870}2871 2872void is_trivial()2873{2874  static_assert(__is_trivial(int));2875  static_assert(__is_trivial(Enum));2876  static_assert(__is_trivial(POD));2877  static_assert(__is_trivial(Int));2878  static_assert(__is_trivial(IntAr));2879  static_assert(__is_trivial(IntArNB));2880  static_assert(__is_trivial(Statics));2881  static_assert(__is_trivial(Empty));2882  static_assert(__is_trivial(EmptyUnion));2883  static_assert(__is_trivial(Union));2884  static_assert(__is_trivial(Derives));2885  static_assert(__is_trivial(DerivesAr));2886  static_assert(__is_trivial(DerivesArNB));2887  static_assert(__is_trivial(DerivesEmpty));2888  static_assert(__is_trivial(HasFunc));2889  static_assert(__is_trivial(HasOp));2890  static_assert(__is_trivial(HasConv));2891  static_assert(__is_trivial(HasAssign));2892  static_assert(__is_trivial(HasAnonymousUnion));2893  static_assert(__is_trivial(HasPriv));2894  static_assert(__is_trivial(HasProt));2895  static_assert(__is_trivial(DerivesHasPriv));2896  static_assert(__is_trivial(DerivesHasProt));2897  static_assert(__is_trivial(Vector));2898  static_assert(__is_trivial(VectorExt));2899 2900  static_assert(!__is_trivial(HasCons));2901  static_assert(!__is_trivial(HasCopyAssign));2902  static_assert(!__is_trivial(HasMoveAssign));2903  static_assert(!__is_trivial(HasDest));2904  static_assert(!__is_trivial(HasRef));2905  static_assert(!__is_trivial(HasNonPOD));2906  static_assert(!__is_trivial(HasVirt));2907  static_assert(!__is_trivial(DerivesHasCons));2908  static_assert(!__is_trivial(DerivesHasCopyAssign));2909  static_assert(!__is_trivial(DerivesHasMoveAssign));2910  static_assert(!__is_trivial(DerivesHasDest));2911  static_assert(!__is_trivial(DerivesHasRef));2912  static_assert(!__is_trivial(DerivesHasVirt));2913  static_assert(!__is_trivial(void));2914  static_assert(!__is_trivial(cvoid));2915}2916 2917template<typename T> struct TriviallyConstructibleTemplate {};2918 2919template<typename A, typename B, bool result = __is_assignable(A, B)>2920static constexpr bool is_assignable_sfinae() { return result; }2921 2922void trivial_checks()2923{2924  static_assert(__is_trivially_copyable(int));2925  static_assert(__is_trivially_copyable(Enum));2926  static_assert(__is_trivially_copyable(POD));2927  static_assert(__is_trivially_copyable(Int));2928  static_assert(__is_trivially_copyable(IntAr));2929  static_assert(__is_trivially_copyable(IntArNB));2930  static_assert(__is_trivially_copyable(Statics));2931  static_assert(__is_trivially_copyable(Empty));2932  static_assert(__is_trivially_copyable(EmptyUnion));2933  static_assert(__is_trivially_copyable(Union));2934  static_assert(__is_trivially_copyable(Derives));2935  static_assert(__is_trivially_copyable(DerivesAr));2936  static_assert(__is_trivially_copyable(DerivesArNB));2937  static_assert(__is_trivially_copyable(DerivesEmpty));2938  static_assert(__is_trivially_copyable(HasFunc));2939  static_assert(__is_trivially_copyable(HasOp));2940  static_assert(__is_trivially_copyable(HasConv));2941  static_assert(__is_trivially_copyable(HasAssign));2942  static_assert(__is_trivially_copyable(HasAnonymousUnion));2943  static_assert(__is_trivially_copyable(HasPriv));2944  static_assert(__is_trivially_copyable(HasProt));2945  static_assert(__is_trivially_copyable(DerivesHasPriv));2946  static_assert(__is_trivially_copyable(DerivesHasProt));2947  static_assert(__is_trivially_copyable(Vector));2948  static_assert(__is_trivially_copyable(VectorExt));2949  static_assert(__is_trivially_copyable(HasCons));2950  static_assert(__is_trivially_copyable(HasRef));2951  static_assert(__is_trivially_copyable(HasNonPOD));2952  static_assert(__is_trivially_copyable(DerivesHasCons));2953  static_assert(__is_trivially_copyable(DerivesHasRef));2954  static_assert(__is_trivially_copyable(NonTrivialDefault));2955  static_assert(__is_trivially_copyable(NonTrivialDefault[]));2956  static_assert(__is_trivially_copyable(NonTrivialDefault[3]));2957 2958  static_assert(!__is_trivially_copyable(HasCopyAssign));2959  static_assert(!__is_trivially_copyable(HasMoveAssign));2960  static_assert(!__is_trivially_copyable(HasDest));2961  static_assert(!__is_trivially_copyable(HasVirt));2962  static_assert(!__is_trivially_copyable(DerivesHasCopyAssign));2963  static_assert(!__is_trivially_copyable(DerivesHasMoveAssign));2964  static_assert(!__is_trivially_copyable(DerivesHasDest));2965  static_assert(!__is_trivially_copyable(DerivesHasVirt));2966  static_assert(!__is_trivially_copyable(void));2967  static_assert(!__is_trivially_copyable(cvoid));2968 2969  static_assert((__is_trivially_constructible(int)));2970  static_assert((__is_trivially_constructible(int, int)));2971  static_assert((__is_trivially_constructible(int, float)));2972  static_assert((__is_trivially_constructible(int, int&)));2973  static_assert((__is_trivially_constructible(int, const int&)));2974  static_assert((__is_trivially_constructible(int, int)));2975  static_assert((__is_trivially_constructible(HasCopyAssign, HasCopyAssign)));2976  static_assert((__is_trivially_constructible(HasCopyAssign, const HasCopyAssign&)));2977  static_assert((__is_trivially_constructible(HasCopyAssign, HasCopyAssign&&)));2978  static_assert((__is_trivially_constructible(HasCopyAssign)));2979  static_assert((__is_trivially_constructible(NonTrivialDefault,2980                                            const NonTrivialDefault&)));2981  static_assert((__is_trivially_constructible(NonTrivialDefault,2982                                            NonTrivialDefault&&)));2983  static_assert((__is_trivially_constructible(AllDefaulted)));2984  static_assert((__is_trivially_constructible(AllDefaulted,2985                                            const AllDefaulted &)));2986  static_assert((__is_trivially_constructible(AllDefaulted,2987                                            AllDefaulted &&)));2988 2989  static_assert(!(__is_trivially_constructible(int, int*)));2990  static_assert(!(__is_trivially_constructible(NonTrivialDefault)));2991  static_assert(!(__is_trivially_constructible(ThreeArgCtor, int*, char*, int&)));2992  static_assert(!(__is_trivially_constructible(AllDeleted)));2993  static_assert(!(__is_trivially_constructible(AllDeleted,2994                                            const AllDeleted &)));2995  static_assert(!(__is_trivially_constructible(AllDeleted,2996                                            AllDeleted &&)));2997  static_assert(!(__is_trivially_constructible(ExtDefaulted)));2998  static_assert(!(__is_trivially_constructible(ExtDefaulted,2999                                            const ExtDefaulted &)));3000  static_assert(!(__is_trivially_constructible(ExtDefaulted,3001                                            ExtDefaulted &&)));3002 3003  static_assert((__is_trivially_constructible(TriviallyConstructibleTemplate<int>)));3004  static_assert(!(__is_trivially_constructible(class_forward))); // expected-error {{incomplete type 'class_forward' used in type trait expression}}3005  static_assert(!(__is_trivially_constructible(class_forward[])));3006  static_assert(!(__is_trivially_constructible(void)));3007 3008  static_assert((__is_trivially_assignable(int&, int)));3009  static_assert((__is_trivially_assignable(int&, int&)));3010  static_assert((__is_trivially_assignable(int&, int&&)));3011  static_assert((__is_trivially_assignable(int&, const int&)));3012  static_assert((__is_trivially_assignable(POD&, POD)));3013  static_assert((__is_trivially_assignable(POD&, POD&)));3014  static_assert((__is_trivially_assignable(POD&, POD&&)));3015  static_assert((__is_trivially_assignable(POD&, const POD&)));3016  static_assert((__is_trivially_assignable(int*&, int*)));3017  static_assert((__is_trivially_assignable(AllDefaulted,3018                                         const AllDefaulted &)));3019  static_assert((__is_trivially_assignable(AllDefaulted,3020                                         AllDefaulted &&)));3021 3022  static_assert(!(__is_trivially_assignable(int*&, float*)));3023  static_assert(!(__is_trivially_assignable(HasCopyAssign&, HasCopyAssign)));3024  static_assert(!(__is_trivially_assignable(HasCopyAssign&, HasCopyAssign&)));3025  static_assert(!(__is_trivially_assignable(HasCopyAssign&, const HasCopyAssign&)));3026  static_assert(!(__is_trivially_assignable(HasCopyAssign&, HasCopyAssign&&)));3027  static_assert(!(__is_trivially_assignable(TrivialMoveButNotCopy&,3028                                        TrivialMoveButNotCopy&)));3029  static_assert(!(__is_trivially_assignable(TrivialMoveButNotCopy&,3030                                        const TrivialMoveButNotCopy&)));3031  static_assert(!(__is_trivially_assignable(AllDeleted,3032                                         const AllDeleted &)));3033  static_assert(!(__is_trivially_assignable(AllDeleted,3034                                         AllDeleted &&)));3035  static_assert(!(__is_trivially_assignable(ExtDefaulted,3036                                         const ExtDefaulted &)));3037  static_assert(!(__is_trivially_assignable(ExtDefaulted,3038                                         ExtDefaulted &&)));3039 3040  static_assert((__is_trivially_assignable(HasDefaultTrivialCopyAssign&,3041                                         HasDefaultTrivialCopyAssign&)));3042  static_assert((__is_trivially_assignable(HasDefaultTrivialCopyAssign&,3043                                       const HasDefaultTrivialCopyAssign&)));3044  static_assert((__is_trivially_assignable(TrivialMoveButNotCopy&,3045                                         TrivialMoveButNotCopy)));3046  static_assert((__is_trivially_assignable(TrivialMoveButNotCopy&,3047                                         TrivialMoveButNotCopy&&)));3048  static_assert((__is_trivially_assignable(int&, int)));3049  static_assert((__is_trivially_assignable(int&, int&)));3050  static_assert((__is_trivially_assignable(int&, int&&)));3051  static_assert((__is_trivially_assignable(int&, const int&)));3052  static_assert((__is_trivially_assignable(POD&, POD)));3053  static_assert((__is_trivially_assignable(POD&, POD&)));3054  static_assert((__is_trivially_assignable(POD&, POD&&)));3055  static_assert((__is_trivially_assignable(POD&, const POD&)));3056  static_assert((__is_trivially_assignable(int*&, int*)));3057  static_assert((__is_trivially_assignable(AllDefaulted,3058                                         const AllDefaulted &)));3059  static_assert((__is_trivially_assignable(AllDefaulted,3060                                         AllDefaulted &&)));3061 3062  static_assert(!(__is_assignable(int *&, float *)));3063  static_assert((__is_assignable(HasCopyAssign &, HasCopyAssign)));3064  static_assert((__is_assignable(HasCopyAssign &, HasCopyAssign &)));3065  static_assert((__is_assignable(HasCopyAssign &, const HasCopyAssign &)));3066  static_assert((__is_assignable(HasCopyAssign &, HasCopyAssign &&)));3067  static_assert((__is_assignable(TrivialMoveButNotCopy &,3068                               TrivialMoveButNotCopy &)));3069  static_assert((__is_assignable(TrivialMoveButNotCopy &,3070                               const TrivialMoveButNotCopy &)));3071  static_assert(!(__is_assignable(AllDeleted,3072                               const AllDeleted &)));3073  static_assert(!(__is_assignable(AllDeleted,3074                               AllDeleted &&)));3075  static_assert((__is_assignable(ExtDefaulted,3076                               const ExtDefaulted &)));3077  static_assert((__is_assignable(ExtDefaulted,3078                               ExtDefaulted &&)));3079 3080  static_assert((__is_assignable(HasDefaultTrivialCopyAssign &,3081                               HasDefaultTrivialCopyAssign &)));3082  static_assert((__is_assignable(HasDefaultTrivialCopyAssign &,3083                               const HasDefaultTrivialCopyAssign &)));3084  static_assert((__is_assignable(TrivialMoveButNotCopy &,3085                               TrivialMoveButNotCopy)));3086  static_assert((__is_assignable(TrivialMoveButNotCopy &,3087                               TrivialMoveButNotCopy &&)));3088 3089  static_assert(__is_assignable(ACompleteType, ACompleteType));3090  static_assert(!__is_assignable(AnIncompleteType, AnIncompleteType)); // expected-error {{incomplete type}}3091  static_assert(!__is_assignable(AnIncompleteType[], AnIncompleteType[]));3092  static_assert(!__is_assignable(AnIncompleteType[1], AnIncompleteType[1])); // expected-error {{incomplete type}}3093  static_assert(!__is_assignable(void, void));3094  static_assert(!__is_assignable(const volatile void, const volatile void));3095 3096  static_assert(!__is_assignable(AllPrivate, AllPrivate));3097  // Make sure we don't emit "'operator=' is a private member" in SFINAE context.3098  static_assert(!is_assignable_sfinae<AllPrivate, AllPrivate>());3099}3100 3101void constructible_checks() {3102  static_assert(__is_constructible(HasNoThrowConstructorWithArgs));3103  static_assert(!__is_nothrow_constructible(HasNoThrowConstructorWithArgs)); // MSVC doesn't look into default args and gets this wrong.3104 3105  static_assert(__is_constructible(HasNoThrowConstructorWithArgs, HasCons));3106  static_assert(__is_nothrow_constructible(HasNoThrowConstructorWithArgs, HasCons));3107 3108  static_assert(__is_constructible(NonTrivialDefault));3109  static_assert(!__is_nothrow_constructible(NonTrivialDefault));3110 3111  static_assert(__is_constructible(int));3112  static_assert(__is_nothrow_constructible(int));3113 3114  static_assert(!__is_constructible(NonPOD));3115  static_assert(!__is_nothrow_constructible(NonPOD));3116 3117  static_assert(__is_constructible(NonPOD, int));3118  static_assert(!__is_nothrow_constructible(NonPOD, int));3119 3120  // PR191783121  static_assert(!__is_constructible(Abstract));3122  static_assert(!__is_nothrow_constructible(Abstract));3123 3124  // PR202283125  static_assert(__is_constructible(VariadicCtor,3126                                 int, int, int, int, int, int, int, int, int));3127 3128  // PR255133129  static_assert(!__is_constructible(int(int)));3130  static_assert(__is_constructible(int const &, long));3131 3132  static_assert(__is_constructible(ACompleteType));3133  static_assert(__is_nothrow_constructible(ACompleteType));3134  static_assert(!__is_constructible(AnIncompleteType)); // expected-error {{incomplete type}}3135  static_assert(!__is_nothrow_constructible(AnIncompleteType)); // expected-error {{incomplete type}}3136  static_assert(!__is_constructible(AnIncompleteType[]));3137  static_assert(!__is_nothrow_constructible(AnIncompleteType[]));3138  static_assert(!__is_constructible(AnIncompleteType[1])); // expected-error {{incomplete type}}3139  static_assert(!__is_nothrow_constructible(AnIncompleteType[1])); // expected-error {{incomplete type}}3140  static_assert(!__is_constructible(void));3141  static_assert(!__is_nothrow_constructible(void));3142  static_assert(!__is_constructible(const volatile void));3143  static_assert(!__is_nothrow_constructible(const volatile void));3144}3145 3146// Instantiation of __is_trivially_constructible3147template<typename T, typename ...Args>3148struct is_trivially_constructible {3149  static const bool value = __is_trivially_constructible(T, Args...);3150};3151 3152void is_trivially_constructible_test() {3153  static_assert((is_trivially_constructible<int>::value));3154  static_assert((is_trivially_constructible<int, int>::value));3155  static_assert((is_trivially_constructible<int, float>::value));3156  static_assert((is_trivially_constructible<int, int&>::value));3157  static_assert((is_trivially_constructible<int, const int&>::value));3158  static_assert((is_trivially_constructible<int, int>::value));3159  static_assert((is_trivially_constructible<HasCopyAssign, HasCopyAssign>::value));3160  static_assert((is_trivially_constructible<HasCopyAssign, const HasCopyAssign&>::value));3161  static_assert((is_trivially_constructible<HasCopyAssign, HasCopyAssign&&>::value));3162  static_assert((is_trivially_constructible<HasCopyAssign>::value));3163  static_assert((is_trivially_constructible<NonTrivialDefault,3164                                            const NonTrivialDefault&>::value));3165  static_assert((is_trivially_constructible<NonTrivialDefault,3166                                            NonTrivialDefault&&>::value));3167 3168  static_assert(!(is_trivially_constructible<int, int*>::value));3169  static_assert(!(is_trivially_constructible<NonTrivialDefault>::value));3170  static_assert(!(is_trivially_constructible<ThreeArgCtor, int*, char*, int&>::value));3171  static_assert(!(is_trivially_constructible<Abstract>::value)); // PR191783172 3173  static_assert(__is_trivially_constructible(ACompleteType));3174  static_assert(!__is_trivially_constructible(AnIncompleteType)); // expected-error {{incomplete type}}3175  static_assert(!__is_trivially_constructible(AnIncompleteType[]));3176  static_assert(!__is_trivially_constructible(AnIncompleteType[1])); // expected-error {{incomplete type}}3177  static_assert(!__is_trivially_constructible(void));3178  static_assert(!__is_trivially_constructible(const volatile void));3179}3180 3181template <class T, class RefType = T &>3182struct ConvertsToRef {3183  operator RefType() const { return static_cast<RefType>(obj); }3184  mutable T obj = 42;3185};3186template <class T, class RefType = T &>3187class ConvertsToRefPrivate {3188  operator RefType() const { return static_cast<RefType>(obj); }3189  mutable T obj = 42;3190};3191 3192 3193void reference_binds_to_temporary_checks() {3194  static_assert(!(__reference_binds_to_temporary(int &, int &)));3195  static_assert(!(__reference_binds_to_temporary(int &, int &&)));3196 3197  static_assert(!(__reference_binds_to_temporary(int const &, int &)));3198  static_assert(!(__reference_binds_to_temporary(int const &, int const &)));3199  static_assert(!(__reference_binds_to_temporary(int const &, int &&)));3200 3201  static_assert(!(__reference_binds_to_temporary(int &, long &))); // doesn't construct3202  static_assert((__reference_binds_to_temporary(int const &, long &)));3203  static_assert((__reference_binds_to_temporary(int const &, long &&)));3204  static_assert((__reference_binds_to_temporary(int &&, long &)));3205 3206  using LRef = ConvertsToRef<int, int &>;3207  using RRef = ConvertsToRef<int, int &&>;3208  using CLRef = ConvertsToRef<int, const int &>;3209  using LongRef = ConvertsToRef<long, long &>;3210  static_assert((__is_constructible(int &, LRef)));3211  static_assert(!(__reference_binds_to_temporary(int &, LRef)));3212 3213  static_assert((__is_constructible(int &&, RRef)));3214  static_assert(!(__reference_binds_to_temporary(int &&, RRef)));3215 3216  static_assert((__is_constructible(int const &, CLRef)));3217  static_assert(!(__reference_binds_to_temporary(int &&, CLRef)));3218 3219  static_assert((__is_constructible(int const &, LongRef)));3220  static_assert((__reference_binds_to_temporary(int const &, LongRef)));3221  static_assert(!__reference_binds_to_temporary(int const &, ConvertsToRefPrivate<long, long &>));3222 3223 3224  // Test that it doesn't accept non-reference types as input.3225  static_assert(!(__reference_binds_to_temporary(int, long)));3226 3227  static_assert((__reference_binds_to_temporary(const int &, long)));3228 3229  // Test that function references are never considered bound to temporaries.3230  static_assert(!__reference_binds_to_temporary(void(&)(), void()));3231  static_assert(!__reference_binds_to_temporary(void(&&)(), void()));3232}3233 3234 3235struct ExplicitConversionRvalueRef {3236    operator int();3237    explicit operator int&&();3238};3239 3240struct ExplicitConversionRef {3241    operator int();3242    explicit operator int&();3243};3244 3245struct NonMovable {3246  NonMovable(NonMovable&&) = delete;3247};3248 3249struct ConvertsFromNonMovable {3250  ConvertsFromNonMovable(NonMovable);3251};3252 3253void reference_constructs_from_temporary_checks() {3254  static_assert(!__reference_constructs_from_temporary(int &, int &));3255  static_assert(!__reference_constructs_from_temporary(int &, int &&));3256 3257  static_assert(!__reference_constructs_from_temporary(int const &, int &));3258  static_assert(!__reference_constructs_from_temporary(int const &, int const &));3259  static_assert(!__reference_constructs_from_temporary(int const &, int &&));3260 3261  static_assert(!__reference_constructs_from_temporary(int &, long &)); // doesn't construct3262 3263  static_assert(__reference_constructs_from_temporary(int const &, long &));3264  static_assert(__reference_constructs_from_temporary(int const &, long &&));3265  static_assert(__reference_constructs_from_temporary(int &&, long &));3266 3267  using LRef = ConvertsToRef<int, int &>;3268  using RRef = ConvertsToRef<int, int &&>;3269  using CLRef = ConvertsToRef<int, const int &>;3270  using LongRef = ConvertsToRef<long, long &>;3271  static_assert(__is_constructible(int &, LRef));3272  static_assert(!__reference_constructs_from_temporary(int &, LRef));3273 3274  static_assert(__is_constructible(int &&, RRef));3275  static_assert(!__reference_constructs_from_temporary(int &&, RRef));3276 3277  static_assert(__is_constructible(int const &, CLRef));3278  static_assert(!__reference_constructs_from_temporary(int &&, CLRef));3279 3280  static_assert(__is_constructible(int const &, LongRef));3281  static_assert(__reference_constructs_from_temporary(int const &, LongRef));3282  static_assert(!__reference_constructs_from_temporary(int const &, ConvertsToRefPrivate<long, long &>));3283 3284 3285  // Test that it doesn't accept non-reference types as input.3286  static_assert(!__reference_constructs_from_temporary(int, long));3287 3288  static_assert(__reference_constructs_from_temporary(const int &, long));3289 3290  // Test that function references are never considered bound to temporaries.3291  static_assert(!__reference_constructs_from_temporary(void(&&)(), void()));3292  static_assert(!__reference_constructs_from_temporary(void(&)(), void()));3293 3294  // LWG3819: reference_meows_from_temporary should not use is_meowible3295  static_assert(__reference_constructs_from_temporary(ConvertsFromNonMovable&&, NonMovable) == __cplusplus >= 201703L);3296  // For scalar types, cv-qualifications are dropped first for prvalues.3297  static_assert(__reference_constructs_from_temporary(int&&, const int));3298  static_assert(__reference_constructs_from_temporary(int&&, volatile int));3299 3300  // Additional checks3301  static_assert(__reference_constructs_from_temporary(POD const&, Derives));3302  static_assert(__reference_constructs_from_temporary(int&&, int));3303  static_assert(__reference_constructs_from_temporary(const int&, int));3304  static_assert(!__reference_constructs_from_temporary(int&&, int&&));3305  static_assert(!__reference_constructs_from_temporary(const int&, int&&));3306  static_assert(__reference_constructs_from_temporary(int&&, long&&));3307  static_assert(__reference_constructs_from_temporary(int&&, long));3308 3309 3310  static_assert(!__reference_constructs_from_temporary(int&, ExplicitConversionRef));3311  static_assert(!__reference_constructs_from_temporary(const int&, ExplicitConversionRef));3312  static_assert(!__reference_constructs_from_temporary(int&&, ExplicitConversionRvalueRef));3313 3314 3315}3316 3317template<typename A, typename B, bool result = __reference_converts_from_temporary(A, B)>3318static constexpr bool reference_converts_from_temporary_sfinae() { return result; }3319 3320void reference_converts_from_temporary_checks() {3321  static_assert(!__reference_converts_from_temporary(int &, int &));3322  static_assert(!__reference_converts_from_temporary(int &, int &&));3323 3324  static_assert(!__reference_converts_from_temporary(int const &, int &));3325  static_assert(!__reference_converts_from_temporary(int const &, int const &));3326  static_assert(!__reference_converts_from_temporary(int const &, int &&));3327 3328  static_assert(!__reference_converts_from_temporary(int &, long &)); // doesn't construct3329 3330  static_assert(__reference_converts_from_temporary(int const &, long &));3331  static_assert(__reference_converts_from_temporary(int const &, long &&));3332  static_assert(__reference_converts_from_temporary(int &&, long &));3333 3334  using LRef = ConvertsToRef<int, int &>;3335  using RRef = ConvertsToRef<int, int &&>;3336  using CLRef = ConvertsToRef<int, const int &>;3337  using LongRef = ConvertsToRef<long, long &>;3338  static_assert(__is_constructible(int &, LRef));3339  static_assert(!__reference_converts_from_temporary(int &, LRef));3340 3341  static_assert(__is_constructible(int &&, RRef));3342  static_assert(!__reference_converts_from_temporary(int &&, RRef));3343 3344  static_assert(__is_constructible(int const &, CLRef));3345  static_assert(!__reference_converts_from_temporary(int &&, CLRef));3346 3347  static_assert(__is_constructible(int const &, LongRef));3348  static_assert(__reference_converts_from_temporary(int const &, LongRef));3349  static_assert(!__reference_converts_from_temporary(int const &, ConvertsToRefPrivate<long, long &>));3350 3351 3352  // Test that it doesn't accept non-reference types as input.3353  static_assert(!__reference_converts_from_temporary(int, long));3354 3355  static_assert(__reference_converts_from_temporary(const int &, long));3356 3357  // Test that function references are never considered bound to temporaries.3358  static_assert(!__reference_converts_from_temporary(void(&)(), void()));3359  static_assert(!__reference_converts_from_temporary(void(&&)(), void()));3360 3361  // LWG3819: reference_meows_from_temporary should not use is_meowible3362  static_assert(__reference_converts_from_temporary(ConvertsFromNonMovable&&, NonMovable) == __cplusplus >= 201703L);3363  // For scalar types, cv-qualifications are dropped first for prvalues.3364  static_assert(__reference_converts_from_temporary(int&&, const int));3365  static_assert(__reference_converts_from_temporary(int&&, volatile int));3366 3367  // Additional checks3368  static_assert(__reference_converts_from_temporary(POD const&, Derives));3369  static_assert(__reference_converts_from_temporary(int&&, int));3370  static_assert(__reference_converts_from_temporary(const int&, int));3371  static_assert(!__reference_converts_from_temporary(int&&, int&&));3372  static_assert(!__reference_converts_from_temporary(const int&, int&&));3373  static_assert(__reference_converts_from_temporary(int&&, long&&));3374  static_assert(__reference_converts_from_temporary(int&&, long));3375 3376  static_assert(!__reference_converts_from_temporary(int&, ExplicitConversionRef));3377  static_assert(__reference_converts_from_temporary(const int&, ExplicitConversionRef));3378  static_assert(__reference_converts_from_temporary(int&&, ExplicitConversionRvalueRef));3379 3380  static_assert(!__reference_converts_from_temporary(AllPrivate, AllPrivate));3381  // Make sure we don't emit "calling a private constructor" in SFINAE context.3382  static_assert(!reference_converts_from_temporary_sfinae<AllPrivate, AllPrivate>());3383}3384 3385void array_rank() {3386  static_assert(__array_rank(IntAr) == 1);3387  static_assert(__array_rank(ConstIntArAr) == 2);3388}3389 3390void array_extent() {3391  static_assert(__array_extent(IntAr, 0) == 10);3392  static_assert(__array_extent(ConstIntArAr, 0) == 4);3393  static_assert(__array_extent(ConstIntArAr, 1) == 10);3394}3395 3396void is_destructible_test() {3397  static_assert(__is_destructible(int));3398  static_assert(__is_destructible(int[2]));3399  static_assert(!__is_destructible(int[]));3400  static_assert(!__is_destructible(void));3401  static_assert(__is_destructible(int &));3402  static_assert(__is_destructible(HasDest));3403  static_assert(!__is_destructible(AllPrivate));3404  static_assert(__is_destructible(SuperNonTrivialStruct));3405  static_assert(__is_destructible(AllDefaulted));3406  static_assert(!__is_destructible(AllDeleted));3407  static_assert(__is_destructible(ThrowingDtor));3408  static_assert(__is_destructible(NoThrowDtor));3409 3410  static_assert(__is_destructible(ACompleteType));3411  static_assert(!__is_destructible(AnIncompleteType)); // expected-error {{incomplete type}}3412  static_assert(!__is_destructible(AnIncompleteType[]));3413  static_assert(!__is_destructible(AnIncompleteType[1])); // expected-error {{incomplete type}}3414  static_assert(!__is_destructible(void));3415  static_assert(!__is_destructible(const volatile void));3416}3417 3418void is_nothrow_destructible_test() {3419  static_assert(__is_nothrow_destructible(int));3420  static_assert(__is_nothrow_destructible(int[2]));3421  static_assert(!__is_nothrow_destructible(int[]));3422  static_assert(!__is_nothrow_destructible(void));3423  static_assert(__is_nothrow_destructible(int &));3424  static_assert(__is_nothrow_destructible(HasDest));3425  static_assert(!__is_nothrow_destructible(AllPrivate));3426  static_assert(__is_nothrow_destructible(SuperNonTrivialStruct));3427  static_assert(__is_nothrow_destructible(AllDefaulted));3428  static_assert(!__is_nothrow_destructible(AllDeleted));3429  static_assert(!__is_nothrow_destructible(ThrowingDtor));3430  static_assert(__is_nothrow_destructible(NoExceptDtor));3431  static_assert(__is_nothrow_destructible(NoThrowDtor));3432 3433  static_assert(__is_nothrow_destructible(ACompleteType));3434  static_assert(!__is_nothrow_destructible(AnIncompleteType)); // expected-error {{incomplete type}}3435  static_assert(!__is_nothrow_destructible(AnIncompleteType[]));3436  static_assert(!__is_nothrow_destructible(AnIncompleteType[1])); // expected-error {{incomplete type}}3437  static_assert(!__is_nothrow_destructible(void));3438  static_assert(!__is_nothrow_destructible(const volatile void));3439}3440 3441void is_trivially_destructible_test() {3442  static_assert(__is_trivially_destructible(int));3443  static_assert(__is_trivially_destructible(int[2]));3444  static_assert(!__is_trivially_destructible(int[]));3445  static_assert(!__is_trivially_destructible(void));3446  static_assert(__is_trivially_destructible(int &));3447  static_assert(!__is_trivially_destructible(HasDest));3448  static_assert(!__is_trivially_destructible(AllPrivate));3449  static_assert(!__is_trivially_destructible(SuperNonTrivialStruct));3450  static_assert(__is_trivially_destructible(AllDefaulted));3451  static_assert(!__is_trivially_destructible(AllDeleted));3452  static_assert(!__is_trivially_destructible(ThrowingDtor));3453  static_assert(!__is_trivially_destructible(NoThrowDtor));3454 3455  static_assert(__is_trivially_destructible(ACompleteType));3456  static_assert(!__is_trivially_destructible(AnIncompleteType)); // expected-error {{incomplete type}}3457  static_assert(!__is_trivially_destructible(AnIncompleteType[]));3458  static_assert(!__is_trivially_destructible(AnIncompleteType[1])); // expected-error {{incomplete type}}3459  static_assert(!__is_trivially_destructible(void));3460  static_assert(!__is_trivially_destructible(const volatile void));3461}3462 3463static_assert(!__has_unique_object_representations(void), "void is never unique");3464static_assert(!__has_unique_object_representations(const void), "void is never unique");3465static_assert(!__has_unique_object_representations(volatile void), "void is never unique");3466static_assert(!__has_unique_object_representations(const volatile void), "void is never unique");3467 3468static_assert(__has_unique_object_representations(int), "integrals are");3469static_assert(__has_unique_object_representations(const int), "integrals are");3470static_assert(__has_unique_object_representations(volatile int), "integrals are");3471static_assert(__has_unique_object_representations(const volatile int), "integrals are");3472 3473static_assert(__has_unique_object_representations(void *), "as are pointers");3474static_assert(__has_unique_object_representations(const void *), "as are pointers");3475static_assert(__has_unique_object_representations(volatile void *), "are pointers");3476static_assert(__has_unique_object_representations(const volatile void *), "as are pointers");3477 3478static_assert(__has_unique_object_representations(int *), "as are pointers");3479static_assert(__has_unique_object_representations(const int *), "as are pointers");3480static_assert(__has_unique_object_representations(volatile int *), "as are pointers");3481static_assert(__has_unique_object_representations(const volatile int *), "as are pointers");3482 3483class C {};3484using FP = int (*)(int);3485using PMF = int (C::*)(int);3486using PMD = int C::*;3487 3488static_assert(__has_unique_object_representations(FP), "even function pointers");3489static_assert(__has_unique_object_representations(const FP), "even function pointers");3490static_assert(__has_unique_object_representations(volatile FP), "even function pointers");3491static_assert(__has_unique_object_representations(const volatile FP), "even function pointers");3492 3493static_assert(__has_unique_object_representations(PMF), "and pointer to members");3494static_assert(__has_unique_object_representations(const PMF), "and pointer to members");3495static_assert(__has_unique_object_representations(volatile PMF), "and pointer to members");3496static_assert(__has_unique_object_representations(const volatile PMF), "and pointer to members");3497 3498static_assert(__has_unique_object_representations(PMD), "and pointer to members");3499static_assert(__has_unique_object_representations(const PMD), "and pointer to members");3500static_assert(__has_unique_object_representations(volatile PMD), "and pointer to members");3501static_assert(__has_unique_object_representations(const volatile PMD), "and pointer to members");3502 3503static_assert(__has_unique_object_representations(bool), "yes, all integral types");3504static_assert(__has_unique_object_representations(char), "yes, all integral types");3505static_assert(__has_unique_object_representations(signed char), "yes, all integral types");3506static_assert(__has_unique_object_representations(unsigned char), "yes, all integral types");3507static_assert(__has_unique_object_representations(short), "yes, all integral types");3508static_assert(__has_unique_object_representations(unsigned short), "yes, all integral types");3509static_assert(__has_unique_object_representations(int), "yes, all integral types");3510static_assert(__has_unique_object_representations(unsigned int), "yes, all integral types");3511static_assert(__has_unique_object_representations(long), "yes, all integral types");3512static_assert(__has_unique_object_representations(unsigned long), "yes, all integral types");3513static_assert(__has_unique_object_representations(long long), "yes, all integral types");3514static_assert(__has_unique_object_representations(unsigned long long), "yes, all integral types");3515static_assert(__has_unique_object_representations(wchar_t), "yes, all integral types");3516static_assert(__has_unique_object_representations(char16_t), "yes, all integral types");3517static_assert(__has_unique_object_representations(char32_t), "yes, all integral types");3518 3519static_assert(!__has_unique_object_representations(void), "but not void!");3520static_assert(!__has_unique_object_representations(decltype(nullptr)), "or nullptr_t");3521static_assert(!__has_unique_object_representations(float), "definitely not Floating Point");3522static_assert(!__has_unique_object_representations(double), "definitely not Floating Point");3523static_assert(!__has_unique_object_representations(long double), "definitely not Floating Point");3524 3525 3526static_assert(!__has_unique_object_representations(AnIncompleteType[]));3527//expected-error@-1 {{incomplete type 'AnIncompleteType' used in type trait expression}}3528static_assert(!__has_unique_object_representations(AnIncompleteType[][1]));3529//expected-error@-1 {{incomplete type 'AnIncompleteType' used in type trait expression}}3530static_assert(!__has_unique_object_representations(AnIncompleteType[1]));3531//expected-error@-1 {{incomplete type 'AnIncompleteType' used in type trait expression}}3532static_assert(!__has_unique_object_representations(AnIncompleteType));3533//expected-error@-1 {{incomplete type 'AnIncompleteType' used in type trait expression}}3534 3535struct NoPadding {3536  int a;3537  int b;3538};3539 3540static_assert(__has_unique_object_representations(NoPadding), "types without padding are");3541 3542struct InheritsFromNoPadding : NoPadding {3543  int c;3544  int d;3545};3546 3547static_assert(__has_unique_object_representations(InheritsFromNoPadding), "types without padding are");3548 3549struct VirtuallyInheritsFromNoPadding : virtual NoPadding {3550  int c;3551  int d;3552};3553 3554static_assert(!__has_unique_object_representations(VirtuallyInheritsFromNoPadding), "No virtual inheritance");3555 3556struct Padding {3557  char a;3558  int b;3559};3560 3561//static_assert(!__has_unique_object_representations(Padding), "but not with padding");3562 3563struct InheritsFromPadding : Padding {3564  int c;3565  int d;3566};3567 3568static_assert(!__has_unique_object_representations(InheritsFromPadding), "or its subclasses");3569 3570struct TailPadding {3571  int a;3572  char b;3573};3574 3575static_assert(!__has_unique_object_representations(TailPadding), "even at the end");3576 3577struct TinyStruct {3578  char a;3579};3580 3581static_assert(__has_unique_object_representations(TinyStruct), "Should be no padding");3582 3583struct InheritsFromTinyStruct : TinyStruct {3584  int b;3585};3586 3587static_assert(!__has_unique_object_representations(InheritsFromTinyStruct), "Inherit causes padding");3588 3589union NoPaddingUnion {3590  int a;3591  unsigned int b;3592};3593 3594static_assert(__has_unique_object_representations(NoPaddingUnion), "unions follow the same rules as structs");3595 3596union PaddingUnion {3597  int a;3598  long long b;3599};3600 3601static_assert(!__has_unique_object_representations(PaddingUnion), "unions follow the same rules as structs");3602 3603struct NotTriviallyCopyable {3604  int x;3605  NotTriviallyCopyable(const NotTriviallyCopyable &) {}3606};3607 3608static_assert(!__has_unique_object_representations(NotTriviallyCopyable), "must be trivially copyable");3609 3610struct HasNonUniqueMember {3611  float x;3612};3613 3614static_assert(!__has_unique_object_representations(HasNonUniqueMember), "all members must be unique");3615 3616enum ExampleEnum { xExample,3617                   yExample };3618enum LLEnum : long long { xLongExample,3619                          yLongExample };3620 3621static_assert(__has_unique_object_representations(ExampleEnum), "Enums are integrals, so unique!");3622static_assert(__has_unique_object_representations(LLEnum), "Enums are integrals, so unique!");3623 3624enum class ExampleEnumClass { xExample,3625                              yExample };3626enum class LLEnumClass : long long { xLongExample,3627                                     yLongExample };3628 3629static_assert(__has_unique_object_representations(ExampleEnumClass), "Enums are integrals, so unique!");3630static_assert(__has_unique_object_representations(LLEnumClass), "Enums are integrals, so unique!");3631 3632// because references aren't trivially copyable.3633static_assert(!__has_unique_object_representations(int &), "No references!");3634static_assert(!__has_unique_object_representations(const int &), "No references!");3635static_assert(!__has_unique_object_representations(volatile int &), "No references!");3636static_assert(!__has_unique_object_representations(const volatile int &), "No references!");3637static_assert(!__has_unique_object_representations(Empty), "No empty types!");3638static_assert(!__has_unique_object_representations(EmptyUnion), "No empty types!");3639 3640class Compressed : Empty {3641  int x;3642};3643 3644static_assert(__has_unique_object_representations(Compressed), "But inheriting from one is ok");3645 3646class EmptyInheritor : Compressed {};3647 3648static_assert(__has_unique_object_representations(EmptyInheritor), "As long as the base has items, empty is ok");3649 3650class Dynamic {3651  virtual void A();3652  int i;3653};3654 3655static_assert(!__has_unique_object_representations(Dynamic), "Dynamic types are not valid");3656 3657class InheritsDynamic : Dynamic {3658  int j;3659};3660 3661static_assert(!__has_unique_object_representations(InheritsDynamic), "Dynamic types are not valid");3662 3663static_assert(__has_unique_object_representations(int[42]), "Arrays are fine, as long as their value type is");3664static_assert(__has_unique_object_representations(int[]), "Arrays are fine, as long as their value type is");3665static_assert(__has_unique_object_representations(int[][42]), "Arrays are fine, as long as their value type is");3666static_assert(!__has_unique_object_representations(double[42]), "So no array of doubles!");3667static_assert(!__has_unique_object_representations(double[]), "So no array of doubles!");3668static_assert(!__has_unique_object_representations(double[][42]), "So no array of doubles!");3669 3670struct __attribute__((aligned(16))) WeirdAlignment {3671  int i;3672};3673union __attribute__((aligned(16))) WeirdAlignmentUnion {3674  int i;3675};3676static_assert(!__has_unique_object_representations(WeirdAlignment), "Alignment causes padding");3677static_assert(!__has_unique_object_representations(WeirdAlignmentUnion), "Alignment causes padding");3678static_assert(!__has_unique_object_representations(WeirdAlignment[42]), "Also no arrays that have padding");3679 3680struct __attribute__((packed)) PackedNoPadding1 {3681  short i;3682  int j;3683};3684struct __attribute__((packed)) PackedNoPadding2 {3685  int j;3686  short i;3687};3688static_assert(__has_unique_object_representations(PackedNoPadding1), "Packed structs have no padding");3689static_assert(__has_unique_object_representations(PackedNoPadding2), "Packed structs have no padding");3690 3691static_assert(!__has_unique_object_representations(int(int)), "Functions are not unique");3692static_assert(!__has_unique_object_representations(int(int) const), "Functions are not unique");3693static_assert(!__has_unique_object_representations(int(int) volatile), "Functions are not unique");3694static_assert(!__has_unique_object_representations(int(int) const volatile), "Functions are not unique");3695static_assert(!__has_unique_object_representations(int(int) &), "Functions are not unique");3696static_assert(!__has_unique_object_representations(int(int) const &), "Functions are not unique");3697static_assert(!__has_unique_object_representations(int(int) volatile &), "Functions are not unique");3698static_assert(!__has_unique_object_representations(int(int) const volatile &), "Functions are not unique");3699static_assert(!__has_unique_object_representations(int(int) &&), "Functions are not unique");3700static_assert(!__has_unique_object_representations(int(int) const &&), "Functions are not unique");3701static_assert(!__has_unique_object_representations(int(int) volatile &&), "Functions are not unique");3702static_assert(!__has_unique_object_representations(int(int) const volatile &&), "Functions are not unique");3703 3704static_assert(!__has_unique_object_representations(int(int, ...)), "Functions are not unique");3705static_assert(!__has_unique_object_representations(int(int, ...) const), "Functions are not unique");3706static_assert(!__has_unique_object_representations(int(int, ...) volatile), "Functions are not unique");3707static_assert(!__has_unique_object_representations(int(int, ...) const volatile), "Functions are not unique");3708static_assert(!__has_unique_object_representations(int(int, ...) &), "Functions are not unique");3709static_assert(!__has_unique_object_representations(int(int, ...) const &), "Functions are not unique");3710static_assert(!__has_unique_object_representations(int(int, ...) volatile &), "Functions are not unique");3711static_assert(!__has_unique_object_representations(int(int, ...) const volatile &), "Functions are not unique");3712static_assert(!__has_unique_object_representations(int(int, ...) &&), "Functions are not unique");3713static_assert(!__has_unique_object_representations(int(int, ...) const &&), "Functions are not unique");3714static_assert(!__has_unique_object_representations(int(int, ...) volatile &&), "Functions are not unique");3715static_assert(!__has_unique_object_representations(int(int, ...) const volatile &&), "Functions are not unique");3716 3717void foo(){3718  static auto lambda = []() {};3719  static_assert(!__has_unique_object_representations(decltype(lambda)), "Lambdas follow struct rules");3720  int i;3721  static auto lambda2 = [i]() {};3722  static_assert(__has_unique_object_representations(decltype(lambda2)), "Lambdas follow struct rules");3723}3724 3725struct PaddedBitfield {3726  char c : 6;3727  char d : 1;3728};3729 3730struct UnPaddedBitfield {3731  char c : 6;3732  char d : 2;3733};3734 3735struct AlignedPaddedBitfield {3736  char c : 6;3737  __attribute__((aligned(1)))3738  char d : 2;3739};3740 3741struct UnnamedBitfield {3742  int named : 8;3743  int : 24;3744};3745 3746struct __attribute__((packed)) UnnamedBitfieldPacked {3747  int named : 8;3748  int : 24;3749};3750 3751struct UnnamedEmptyBitfield {3752  int named;3753  int : 0;3754};3755 3756struct UnnamedEmptyBitfieldSplit {3757  short named;3758  int : 0;3759  short also_named;3760};3761 3762static_assert(!__has_unique_object_representations(PaddedBitfield), "Bitfield padding");3763static_assert(__has_unique_object_representations(UnPaddedBitfield), "Bitfield padding");3764static_assert(!__has_unique_object_representations(AlignedPaddedBitfield), "Bitfield padding");3765static_assert(!__has_unique_object_representations(UnnamedBitfield), "Bitfield padding");3766static_assert(!__has_unique_object_representations(UnnamedBitfieldPacked), "Bitfield padding");3767static_assert(__has_unique_object_representations(UnnamedEmptyBitfield), "Bitfield padding");3768static_assert(sizeof(UnnamedEmptyBitfieldSplit) != (sizeof(short) * 2), "Wrong size");3769static_assert(!__has_unique_object_representations(UnnamedEmptyBitfieldSplit), "Bitfield padding");3770 3771struct BoolBitfield {3772  bool b : 8;3773};3774 3775static_assert(__has_unique_object_representations(BoolBitfield), "Bitfield bool");3776 3777struct BoolBitfield2 {3778  bool b : 16;3779};3780 3781static_assert(!__has_unique_object_representations(BoolBitfield2), "Bitfield bool");3782 3783struct GreaterSizeBitfield {3784  //expected-warning@+1 {{width of bit-field 'n'}}3785  int n : 1024;3786};3787 3788static_assert(sizeof(GreaterSizeBitfield) == 128, "Bitfield Size");3789static_assert(!__has_unique_object_representations(GreaterSizeBitfield), "Bitfield padding");3790 3791struct StructWithRef {3792  int &I;3793};3794 3795static_assert(__has_unique_object_representations(StructWithRef), "References are still unique");3796 3797struct NotUniqueBecauseTailPadding {3798  int &r;3799  char a;3800};3801struct CanBeUniqueIfNoPadding : NotUniqueBecauseTailPadding {3802  char b[7];3803};3804 3805static_assert(!__has_unique_object_representations(NotUniqueBecauseTailPadding),3806              "non trivial");3807// Can be unique on Itanium, since the is child class' data is 'folded' into the3808// parent's tail padding.3809static_assert(sizeof(CanBeUniqueIfNoPadding) != 16 ||3810              __has_unique_object_representations(CanBeUniqueIfNoPadding),3811              "inherit from std layout");3812 3813namespace ErrorType {3814  struct S; //expected-note{{forward declaration of 'ErrorType::S'}}3815 3816  struct T {3817        S t; //expected-error{{field has incomplete type 'S'}}3818  };3819  bool b = __has_unique_object_representations(T);3820};3821 3822static_assert(!__has_unique_object_representations(_BitInt(7)), "BitInt:");3823static_assert(__has_unique_object_representations(_BitInt(8)), "BitInt:");3824static_assert(!__has_unique_object_representations(_BitInt(127)), "BitInt:");3825static_assert(__has_unique_object_representations(_BitInt(128)), "BitInt:");3826 3827namespace GH95311 {3828 3829template <int>3830class Foo {3831  int x;3832};3833static_assert(__has_unique_object_representations(Foo<0>[]));3834class Bar; // expected-note {{forward declaration of 'GH95311::Bar'}}3835static_assert(__has_unique_object_representations(Bar[])); // expected-error {{incomplete type}}3836 3837}3838 3839namespace PR46209 {3840  // Foo has both a trivial assignment operator and a non-trivial one.3841  struct Foo {3842    Foo &operator=(const Foo &) & { return *this; }3843    Foo &operator=(const Foo &) && = default;3844  };3845 3846  // Bar's copy assignment calls Foo's non-trivial assignment.3847  struct Bar {3848    Foo foo;3849  };3850 3851  static_assert(!__is_trivially_assignable(Foo &, const Foo &));3852  static_assert(!__is_trivially_assignable(Bar &, const Bar &));3853 3854  // Foo2 has both a trivial assignment operator and a non-trivial one.3855  struct Foo2 {3856    Foo2 &operator=(const Foo2 &) & = default;3857    Foo2 &operator=(const Foo2 &) && { return *this; }3858  };3859 3860  // Bar2's copy assignment calls Foo2's trivial assignment.3861  struct Bar2 {3862    Foo2 foo;3863  };3864 3865  static_assert(__is_trivially_assignable(Foo2 &, const Foo2 &));3866  static_assert(__is_trivially_assignable(Bar2 &, const Bar2 &));3867}3868 3869namespace ConstClass {3870  struct A {3871    A &operator=(const A&) = default;3872  };3873  struct B {3874    const A a;3875  };3876  static_assert(!__is_trivially_assignable(B&, const B&));3877}3878 3879namespace type_trait_expr_numargs_overflow {3880// Make sure that TypeTraitExpr can store 16 bits worth of arguments.3881#define T4(X) X,X,X,X3882#define T16(X) T4(X),T4(X),T4(X),T4(X)3883#define T64(X) T16(X),T16(X),T16(X),T16(X)3884#define T256(X) T64(X),T64(X),T64(X),T64(X)3885#define T1024(X) T256(X),T256(X),T256(X),T256(X)3886#define T4096(X) T1024(X),T1024(X),T1024(X),T1024(X)3887#define T16384(X) T4096(X),T4096(X),T4096(X),T4096(X)3888#define T32768(X) T16384(X),T16384(X)3889void test() { (void) __is_constructible(int, T32768(int)); }3890#undef T43891#undef T163892#undef T643893#undef T2563894#undef T10243895#undef T40963896#undef T163843897#undef T327683898} // namespace type_trait_expr_numargs_overflow3899 3900namespace is_trivially_relocatable {3901 3902static_assert(!__is_trivially_relocatable(void));3903static_assert(__is_trivially_relocatable(int));3904static_assert(__is_trivially_relocatable(int[]));3905static_assert(__is_trivially_relocatable(const int));3906static_assert(__is_trivially_relocatable(volatile int));3907 3908enum Enum {};3909static_assert(__is_trivially_relocatable(Enum));3910static_assert(__is_trivially_relocatable(Enum[]));3911 3912union Union {int x;};3913static_assert(__is_trivially_relocatable(Union));3914static_assert(__is_trivially_relocatable(Union[]));3915 3916struct Trivial {};3917static_assert(__is_trivially_relocatable(Trivial));3918static_assert(__is_trivially_relocatable(const Trivial));3919static_assert(__is_trivially_relocatable(volatile Trivial));3920 3921static_assert(__is_trivially_relocatable(Trivial[]));3922static_assert(__is_trivially_relocatable(const Trivial[]));3923static_assert(__is_trivially_relocatable(volatile Trivial[]));3924 3925static_assert(__is_trivially_relocatable(int[10]));3926static_assert(__is_trivially_relocatable(const int[10]));3927static_assert(__is_trivially_relocatable(volatile int[10]));3928 3929static_assert(__is_trivially_relocatable(int[10][10]));3930static_assert(__is_trivially_relocatable(const int[10][10]));3931static_assert(__is_trivially_relocatable(volatile int[10][10]));3932 3933static_assert(__is_trivially_relocatable(int[]));3934static_assert(__is_trivially_relocatable(const int[]));3935static_assert(__is_trivially_relocatable(volatile int[]));3936 3937static_assert(__is_trivially_relocatable(int[][10]));3938static_assert(__is_trivially_relocatable(const int[][10]));3939static_assert(__is_trivially_relocatable(volatile int[][10]));3940 3941struct Incomplete; // expected-note {{forward declaration of 'is_trivially_relocatable::Incomplete'}}3942bool unused = __is_trivially_relocatable(Incomplete); // expected-error {{incomplete type}}3943 3944struct NontrivialDtor {3945  ~NontrivialDtor() {}3946};3947static_assert(!__is_trivially_relocatable(NontrivialDtor));3948static_assert(!__is_trivially_relocatable(NontrivialDtor[]));3949static_assert(!__is_trivially_relocatable(const NontrivialDtor));3950static_assert(!__is_trivially_relocatable(volatile NontrivialDtor));3951 3952struct NontrivialCopyCtor {3953  NontrivialCopyCtor(const NontrivialCopyCtor&) {}3954};3955static_assert(!__is_trivially_relocatable(NontrivialCopyCtor));3956static_assert(!__is_trivially_relocatable(NontrivialCopyCtor[]));3957 3958struct NontrivialMoveCtor {3959  NontrivialMoveCtor(NontrivialMoveCtor&&) {}3960};3961static_assert(!__is_trivially_relocatable(NontrivialMoveCtor));3962static_assert(!__is_trivially_relocatable(NontrivialMoveCtor[]));3963 3964struct [[clang::trivial_abi]] TrivialAbiNontrivialDtor {3965  ~TrivialAbiNontrivialDtor() {}3966};3967static_assert(__is_trivially_relocatable(TrivialAbiNontrivialDtor));3968static_assert(__is_trivially_relocatable(TrivialAbiNontrivialDtor[]));3969static_assert(__is_trivially_relocatable(const TrivialAbiNontrivialDtor));3970static_assert(__is_trivially_relocatable(volatile TrivialAbiNontrivialDtor));3971 3972struct [[clang::trivial_abi]] TrivialAbiNontrivialCopyCtor {3973  TrivialAbiNontrivialCopyCtor(const TrivialAbiNontrivialCopyCtor&) {}3974};3975static_assert(__is_trivially_relocatable(TrivialAbiNontrivialCopyCtor));3976static_assert(__is_trivially_relocatable(TrivialAbiNontrivialCopyCtor[]));3977static_assert(__is_trivially_relocatable(const TrivialAbiNontrivialCopyCtor));3978static_assert(__is_trivially_relocatable(volatile TrivialAbiNontrivialCopyCtor));3979 3980// A more complete set of tests for the behavior of trivial_abi can be found in3981// clang/test/SemaCXX/attr-trivial-abi.cpp3982struct [[clang::trivial_abi]] TrivialAbiNontrivialMoveCtor {3983  TrivialAbiNontrivialMoveCtor(TrivialAbiNontrivialMoveCtor&&) {}3984};3985static_assert(__is_trivially_relocatable(TrivialAbiNontrivialMoveCtor));3986static_assert(__is_trivially_relocatable(TrivialAbiNontrivialMoveCtor[]));3987static_assert(__is_trivially_relocatable(const TrivialAbiNontrivialMoveCtor));3988static_assert(__is_trivially_relocatable(volatile TrivialAbiNontrivialMoveCtor));3989 3990} // namespace is_trivially_relocatable3991 3992namespace is_trivially_equality_comparable {3993struct ForwardDeclared; // expected-note {{forward declaration of 'is_trivially_equality_comparable::ForwardDeclared'}}3994static_assert(!__is_trivially_equality_comparable(ForwardDeclared)); // expected-error {{incomplete type 'ForwardDeclared' used in type trait expression}}3995 3996static_assert(!__is_trivially_equality_comparable(void));3997static_assert(__is_trivially_equality_comparable(int));3998static_assert(!__is_trivially_equality_comparable(int[]));3999static_assert(!__is_trivially_equality_comparable(int[3]));4000static_assert(!__is_trivially_equality_comparable(float));4001static_assert(!__is_trivially_equality_comparable(double));4002static_assert(!__is_trivially_equality_comparable(long double));4003 4004struct NonTriviallyEqualityComparableNoComparator {4005  int i;4006  int j;4007};4008static_assert(!__is_trivially_equality_comparable(NonTriviallyEqualityComparableNoComparator));4009 4010struct NonTriviallyEqualityComparableConvertibleToBuiltin {4011  int i;4012  operator unsigned() const;4013};4014static_assert(!__is_trivially_equality_comparable(NonTriviallyEqualityComparableConvertibleToBuiltin));4015 4016struct NonTriviallyEqualityComparableNonDefaultedComparator {4017  int i;4018  int j;4019  bool operator==(const NonTriviallyEqualityComparableNonDefaultedComparator&);4020};4021static_assert(!__is_trivially_equality_comparable(NonTriviallyEqualityComparableNonDefaultedComparator));4022 4023#if __cplusplus >= 202002L4024 4025struct TriviallyEqualityComparable {4026  int i;4027  int j;4028 4029  void func();4030  bool operator==(int) const { return false; }4031 4032  bool operator==(const TriviallyEqualityComparable&) const = default;4033};4034static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable));4035 4036struct TriviallyEqualityComparableContainsArray {4037  int a[4];4038 4039  bool operator==(const TriviallyEqualityComparableContainsArray&) const = default;4040};4041static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparableContainsArray));4042 4043struct TriviallyEqualityComparableContainsMultiDimensionArray {4044  int a[4][4];4045 4046  bool operator==(const TriviallyEqualityComparableContainsMultiDimensionArray&) const = default;4047};4048static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparableContainsMultiDimensionArray));4049 4050auto GetNonCapturingLambda() { return [](){ return 42; }; }4051 4052struct TriviallyEqualityComparableContainsLambda {4053  [[no_unique_address]] decltype(GetNonCapturingLambda()) l;4054  int i;4055 4056  bool operator==(const TriviallyEqualityComparableContainsLambda&) const = default;4057};4058static_assert(!__is_trivially_equality_comparable(decltype(GetNonCapturingLambda()))); // padding4059static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparableContainsLambda));4060 4061struct TriviallyEqualityComparableNonTriviallyCopyable {4062  TriviallyEqualityComparableNonTriviallyCopyable(const TriviallyEqualityComparableNonTriviallyCopyable&);4063  ~TriviallyEqualityComparableNonTriviallyCopyable();4064  bool operator==(const TriviallyEqualityComparableNonTriviallyCopyable&) const = default;4065  int i;4066};4067static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparableNonTriviallyCopyable));4068 4069struct NotTriviallyEqualityComparableHasPadding {4070  short i;4071  int j;4072 4073  bool operator==(const NotTriviallyEqualityComparableHasPadding&) const = default;4074};4075static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasPadding));4076 4077struct NotTriviallyEqualityComparableHasFloat {4078  float i;4079  int j;4080 4081  bool operator==(const NotTriviallyEqualityComparableHasFloat&) const = default;4082};4083static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasFloat));4084 4085struct NotTriviallyEqualityComparableHasTailPadding {4086  int i;4087  char j;4088 4089  bool operator==(const NotTriviallyEqualityComparableHasTailPadding&) const = default;4090};4091static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasTailPadding));4092 4093struct NotTriviallyEqualityComparableBase : NotTriviallyEqualityComparableHasTailPadding {4094  char j;4095 4096  bool operator==(const NotTriviallyEqualityComparableBase&) const = default;4097};4098static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBase));4099 4100class TriviallyEqualityComparablePaddedOutBase {4101  int i;4102  char c;4103 4104public:4105  bool operator==(const TriviallyEqualityComparablePaddedOutBase&) const = default;4106};4107static_assert(!__is_trivially_equality_comparable(TriviallyEqualityComparablePaddedOutBase));4108 4109struct TriviallyEqualityComparablePaddedOut : TriviallyEqualityComparablePaddedOutBase {4110  char j[3];4111 4112  bool operator==(const TriviallyEqualityComparablePaddedOut&) const = default;4113};4114static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparablePaddedOut));4115 4116struct TriviallyEqualityComparable1 {4117  char i;4118 4119  bool operator==(const TriviallyEqualityComparable1&) const = default;4120};4121static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable1));4122 4123struct TriviallyEqualityComparable2 {4124  int i;4125 4126  bool operator==(const TriviallyEqualityComparable2&) const = default;4127};4128static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable2));4129 4130struct NotTriviallyEqualityComparableTriviallyEqualityComparableBases4131    : TriviallyEqualityComparable1, TriviallyEqualityComparable2 {4132  bool operator==(const NotTriviallyEqualityComparableTriviallyEqualityComparableBases&) const = default;4133};4134static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableTriviallyEqualityComparableBases));4135 4136struct NotTriviallyEqualityComparableBitfield {4137  int i : 1;4138 4139  bool operator==(const NotTriviallyEqualityComparableBitfield&) const = default;4140};4141static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBitfield));4142 4143// TODO: This is trivially equality comparable4144struct NotTriviallyEqualityComparableBitfieldFilled {4145  char i : __CHAR_BIT__;4146 4147  bool operator==(const NotTriviallyEqualityComparableBitfieldFilled&) const = default;4148};4149static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBitfield));4150 4151union U {4152  int i;4153 4154  bool operator==(const U&) const = default;4155};4156 4157struct NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion {4158  U u;4159 4160  bool operator==(const NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion&) const = default;4161};4162static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion));4163 4164struct NotTriviallyEqualityComparableExplicitlyDeleted {4165  int i;4166 4167  bool operator==(const NotTriviallyEqualityComparableExplicitlyDeleted&) const = delete;4168};4169 4170struct NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct {4171  NotTriviallyEqualityComparableExplicitlyDeleted u;4172 4173  bool operator==(const NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct&) const = default;4174};4175static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct));4176 4177struct NotTriviallyEqualityComparableHasReferenceMember {4178  int& i;4179 4180  bool operator==(const NotTriviallyEqualityComparableHasReferenceMember&) const = default;4181};4182static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasReferenceMember));4183 4184struct NotTriviallyEqualityComparableNonTriviallyComparableBaseBase {4185  int i;4186 4187  bool operator==(const NotTriviallyEqualityComparableNonTriviallyComparableBaseBase&) const {4188    return true;4189  }4190};4191 4192struct NotTriviallyEqualityComparableNonTriviallyComparableBase : NotTriviallyEqualityComparableNonTriviallyComparableBaseBase {4193  int i;4194 4195  bool operator==(const NotTriviallyEqualityComparableNonTriviallyComparableBase&) const = default;4196};4197static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableNonTriviallyComparableBase));4198 4199enum E {4200  a,4201  b4202};4203bool operator==(E, E) { return false; }4204static_assert(!__is_trivially_equality_comparable(E));4205 4206struct NotTriviallyEqualityComparableHasEnum {4207  E e;4208  bool operator==(const NotTriviallyEqualityComparableHasEnum&) const = default;4209};4210static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasEnum));4211 4212struct NotTriviallyEqualityComparableNonTriviallyEqualityComparableArrs {4213  E e[1];4214 4215  bool operator==(const NotTriviallyEqualityComparableNonTriviallyEqualityComparableArrs&) const = default;4216};4217static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableNonTriviallyEqualityComparableArrs));4218 4219struct NotTriviallyEqualityComparableNonTriviallyEqualityComparableArrs2 {4220  E e[1][1];4221 4222  bool operator==(const NotTriviallyEqualityComparableNonTriviallyEqualityComparableArrs2&) const = default;4223};4224 4225static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableNonTriviallyEqualityComparableArrs2));4226 4227struct NotTriviallyEqualityComparablePrivateComparison {4228  int i;4229 4230private:4231  bool operator==(const NotTriviallyEqualityComparablePrivateComparison&) const = default;4232};4233static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparablePrivateComparison));4234 4235template<typename T, bool result = __is_trivially_equality_comparable(T)>4236static constexpr bool is_trivially_equality_comparable_sfinae() { return result; }4237 4238// Make sure we don't emit "'operator==' is a private member" in SFINAE context.4239static_assert(!is_trivially_equality_comparable_sfinae<NotTriviallyEqualityComparablePrivateComparison>());4240 4241template<bool B>4242struct MaybeTriviallyEqualityComparable {4243    int i;4244    bool operator==(const MaybeTriviallyEqualityComparable&) const requires B = default;4245    bool operator==(const MaybeTriviallyEqualityComparable& rhs) const { return (i % 3) == (rhs.i % 3); }4246};4247static_assert(__is_trivially_equality_comparable(MaybeTriviallyEqualityComparable<true>));4248static_assert(!__is_trivially_equality_comparable(MaybeTriviallyEqualityComparable<false>));4249 4250struct NotTriviallyEqualityComparableMoreConstrainedExternalOp {4251  int i;4252  bool operator==(const NotTriviallyEqualityComparableMoreConstrainedExternalOp&) const = default;4253};4254 4255bool operator==(const NotTriviallyEqualityComparableMoreConstrainedExternalOp&,4256                const NotTriviallyEqualityComparableMoreConstrainedExternalOp&) __attribute__((enable_if(true, ""))) {}4257 4258static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableMoreConstrainedExternalOp));4259 4260struct TriviallyEqualityComparableExternalDefaultedOp {4261  int i;4262  friend bool operator==(TriviallyEqualityComparableExternalDefaultedOp, TriviallyEqualityComparableExternalDefaultedOp);4263};4264bool operator==(TriviallyEqualityComparableExternalDefaultedOp, TriviallyEqualityComparableExternalDefaultedOp) = default;4265 4266static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparableExternalDefaultedOp));4267 4268struct EqualityComparableBase {4269  bool operator==(const EqualityComparableBase&) const = default;4270};4271 4272struct ComparingBaseOnly : EqualityComparableBase {4273  int j_ = 0;4274};4275static_assert(!__is_trivially_equality_comparable(ComparingBaseOnly));4276 4277template <class>4278class Template {};4279 4280// Make sure we don't crash when instantiating a type4281static_assert(!__is_trivially_equality_comparable(Template<Template<int>>));4282 4283 4284struct S operator==(S, S);4285 4286template <class> struct basic_string_view {};4287 4288struct basic_string {4289  operator basic_string_view<int>() const;4290};4291 4292template <class T>4293const bool is_trivially_equality_comparable = __is_trivially_equality_comparable(T);4294 4295template <int = is_trivially_equality_comparable<basic_string> >4296void find();4297 4298void func() { find(); }4299 4300 4301namespace hidden_friend {4302 4303struct TriviallyEqualityComparable {4304  int i;4305  int j;4306 4307  void func();4308  bool operator==(int) const { return false; }4309 4310  friend bool operator==(const TriviallyEqualityComparable&, const TriviallyEqualityComparable&) = default;4311};4312static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable));4313 4314struct TriviallyEqualityComparableNonTriviallyCopyable {4315  TriviallyEqualityComparableNonTriviallyCopyable(const TriviallyEqualityComparableNonTriviallyCopyable&);4316  ~TriviallyEqualityComparableNonTriviallyCopyable();4317  friend bool operator==(const TriviallyEqualityComparableNonTriviallyCopyable&, const TriviallyEqualityComparableNonTriviallyCopyable&) = default;4318  int i;4319};4320static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparableNonTriviallyCopyable));4321 4322struct NotTriviallyEqualityComparableHasPadding {4323  short i;4324  int j;4325 4326  friend bool operator==(const NotTriviallyEqualityComparableHasPadding&, const NotTriviallyEqualityComparableHasPadding&) = default;4327};4328static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasPadding));4329 4330struct NotTriviallyEqualityComparableHasFloat {4331  float i;4332  int j;4333 4334  friend bool operator==(const NotTriviallyEqualityComparableHasFloat&, const NotTriviallyEqualityComparableHasFloat&) = default;4335};4336static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasFloat));4337 4338struct NotTriviallyEqualityComparableHasTailPadding {4339  int i;4340  char j;4341 4342  friend bool operator==(const NotTriviallyEqualityComparableHasTailPadding&, const NotTriviallyEqualityComparableHasTailPadding&) = default;4343};4344static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasTailPadding));4345 4346struct NotTriviallyEqualityComparableBase : NotTriviallyEqualityComparableHasTailPadding {4347  char j;4348 4349  friend bool operator==(const NotTriviallyEqualityComparableBase&, const NotTriviallyEqualityComparableBase&) = default;4350};4351static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBase));4352 4353class TriviallyEqualityComparablePaddedOutBase {4354  int i;4355  char c;4356 4357public:4358  friend bool operator==(const TriviallyEqualityComparablePaddedOutBase&, const TriviallyEqualityComparablePaddedOutBase&) = default;4359};4360static_assert(!__is_trivially_equality_comparable(TriviallyEqualityComparablePaddedOutBase));4361 4362struct TriviallyEqualityComparablePaddedOut : TriviallyEqualityComparablePaddedOutBase {4363  char j[3];4364 4365  friend bool operator==(const TriviallyEqualityComparablePaddedOut&, const TriviallyEqualityComparablePaddedOut&) = default;4366};4367static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparablePaddedOut));4368 4369struct TriviallyEqualityComparable1 {4370  char i;4371 4372  friend bool operator==(const TriviallyEqualityComparable1&, const TriviallyEqualityComparable1&) = default;4373};4374static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable1));4375 4376struct TriviallyEqualityComparable2 {4377  int i;4378 4379  friend bool operator==(const TriviallyEqualityComparable2&, const TriviallyEqualityComparable2&) = default;4380};4381static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable2));4382 4383struct NotTriviallyEqualityComparableTriviallyEqualityComparableBases4384    : TriviallyEqualityComparable1, TriviallyEqualityComparable2 {4385  friend bool operator==(const NotTriviallyEqualityComparableTriviallyEqualityComparableBases&, const NotTriviallyEqualityComparableTriviallyEqualityComparableBases&) = default;4386};4387static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableTriviallyEqualityComparableBases));4388 4389struct NotTriviallyEqualityComparableBitfield {4390  int i : 1;4391 4392  friend bool operator==(const NotTriviallyEqualityComparableBitfield&, const NotTriviallyEqualityComparableBitfield&) = default;4393};4394static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBitfield));4395 4396// TODO: This is trivially equality comparable4397struct NotTriviallyEqualityComparableBitfieldFilled {4398  char i : __CHAR_BIT__;4399 4400  friend bool operator==(const NotTriviallyEqualityComparableBitfieldFilled&, const NotTriviallyEqualityComparableBitfieldFilled&) = default;4401};4402static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBitfield));4403 4404union U {4405  int i;4406 4407  friend bool operator==(const U&, const U&) = default;4408};4409 4410struct NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion {4411  U u;4412 4413  friend bool operator==(const NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion&, const NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion&) = default;4414};4415static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion));4416 4417struct NotTriviallyEqualityComparableExplicitlyDeleted {4418  int i;4419 4420  friend bool operator==(const NotTriviallyEqualityComparableExplicitlyDeleted&, const NotTriviallyEqualityComparableExplicitlyDeleted&) = delete;4421};4422 4423struct NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct {4424  NotTriviallyEqualityComparableExplicitlyDeleted u;4425 4426  friend bool operator==(const NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct&, const NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct&) = default;4427};4428static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct));4429 4430struct NotTriviallyEqualityComparableHasReferenceMember {4431  int& i;4432 4433  friend bool operator==(const NotTriviallyEqualityComparableHasReferenceMember&, const NotTriviallyEqualityComparableHasReferenceMember&) = default;4434};4435static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasReferenceMember));4436 4437enum E {4438  a,4439  b4440};4441bool operator==(E, E) { return false; }4442static_assert(!__is_trivially_equality_comparable(E));4443 4444struct NotTriviallyEqualityComparableHasEnum {4445  E e;4446  friend bool operator==(const NotTriviallyEqualityComparableHasEnum&, const NotTriviallyEqualityComparableHasEnum&) = default;4447};4448static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasEnum));4449 4450struct NonTriviallyEqualityComparableValueComparisonNonTriviallyCopyable {4451  int i;4452  NonTriviallyEqualityComparableValueComparisonNonTriviallyCopyable(const NonTriviallyEqualityComparableValueComparisonNonTriviallyCopyable&);4453 4454  friend bool operator==(NonTriviallyEqualityComparableValueComparisonNonTriviallyCopyable, NonTriviallyEqualityComparableValueComparisonNonTriviallyCopyable) = default;4455};4456static_assert(!__is_trivially_equality_comparable(NonTriviallyEqualityComparableValueComparisonNonTriviallyCopyable));4457 4458struct TriviallyEqualityComparableRefComparisonNonTriviallyCopyable {4459  int i;4460  TriviallyEqualityComparableRefComparisonNonTriviallyCopyable(const TriviallyEqualityComparableRefComparisonNonTriviallyCopyable&);4461 4462  friend bool operator==(const TriviallyEqualityComparableRefComparisonNonTriviallyCopyable&, const TriviallyEqualityComparableRefComparisonNonTriviallyCopyable&) = default;4463};4464static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparableRefComparisonNonTriviallyCopyable));4465}4466 4467#endif // __cplusplus >= 202002L4468};4469 4470namespace can_pass_in_regs {4471 4472struct A { };4473 4474struct B {4475  ~B();4476};4477 4478struct C; // expected-note {{forward declaration}}4479 4480union D {4481  int x;4482};4483 4484static_assert(__can_pass_in_regs(A));4485static_assert(__can_pass_in_regs(A));4486static_assert(!__can_pass_in_regs(B));4487static_assert(__can_pass_in_regs(D));4488 4489void test_errors() {4490  (void)__can_pass_in_regs(const A); // expected-error {{not an unqualified class type}}4491  (void)__can_pass_in_regs(A&); // expected-error {{not an unqualified class type}}4492  (void)__can_pass_in_regs(A&&); // expected-error {{not an unqualified class type}}4493  (void)__can_pass_in_regs(const A&); // expected-error {{not an unqualified class type}}4494  (void)__can_pass_in_regs(C); // expected-error {{incomplete type}}4495  (void)__can_pass_in_regs(int); // expected-error {{not an unqualified class type}}4496  (void)__can_pass_in_regs(int&); // expected-error {{not an unqualified class type}}4497}4498}4499 4500struct S {};4501template <class T> using remove_const_t = __remove_const(T);4502 4503void check_remove_const() {4504  static_assert(__is_same(remove_const_t<void>, void));4505  static_assert(__is_same(remove_const_t<const void>, void));4506  static_assert(__is_same(remove_const_t<int>, int));4507  static_assert(__is_same(remove_const_t<const int>, int));4508  static_assert(__is_same(remove_const_t<volatile int>, volatile int));4509  static_assert(__is_same(remove_const_t<const volatile int>, volatile int));4510  static_assert(__is_same(remove_const_t<int *>, int *));4511  static_assert(__is_same(remove_const_t<int *const>, int *));4512  static_assert(__is_same(remove_const_t<int const *const>, int const *));4513  static_assert(__is_same(remove_const_t<int const *const __restrict>, int const *__restrict));4514  static_assert(__is_same(remove_const_t<int &>, int &));4515  static_assert(__is_same(remove_const_t<int const &>, int const &));4516  static_assert(__is_same(remove_const_t<int &&>, int &&));4517  static_assert(__is_same(remove_const_t<int const &&>, int const &&));4518  static_assert(__is_same(remove_const_t<int()>, int()));4519  static_assert(__is_same(remove_const_t<int (*const)()>, int (*)()));4520  static_assert(__is_same(remove_const_t<int (&)()>, int (&)()));4521 4522  static_assert(__is_same(remove_const_t<S>, S));4523  static_assert(__is_same(remove_const_t<const S>, S));4524  static_assert(__is_same(remove_const_t<volatile S>, volatile S));4525  static_assert(__is_same(remove_const_t<S *__restrict>, S *__restrict));4526  static_assert(__is_same(remove_const_t<const volatile S>, volatile S));4527  static_assert(__is_same(remove_const_t<S *const volatile __restrict>, S *volatile __restrict));4528  static_assert(__is_same(remove_const_t<int S::*const>, int S::*));4529  static_assert(__is_same(remove_const_t<int (S::*const)()>, int(S::*)()));4530}4531 4532template <class T> using remove_restrict_t = __remove_restrict(T);4533 4534void check_remove_restrict() {4535  static_assert(__is_same(remove_restrict_t<void>, void));4536  static_assert(__is_same(remove_restrict_t<int>, int));4537  static_assert(__is_same(remove_restrict_t<const int>, const int));4538  static_assert(__is_same(remove_restrict_t<volatile int>, volatile int));4539  static_assert(__is_same(remove_restrict_t<int *__restrict>, int *));4540  static_assert(__is_same(remove_restrict_t<int *const volatile __restrict>, int *const volatile));4541  static_assert(__is_same(remove_restrict_t<int *>, int *));4542  static_assert(__is_same(remove_restrict_t<int *__restrict>, int *));4543  static_assert(__is_same(remove_restrict_t<int &>, int &));4544  static_assert(__is_same(remove_restrict_t<int &__restrict>, int &));4545  static_assert(__is_same(remove_restrict_t<int &&>, int &&));4546  static_assert(__is_same(remove_restrict_t<int &&__restrict>, int &&));4547  static_assert(__is_same(remove_restrict_t<int()>, int()));4548  static_assert(__is_same(remove_restrict_t<int (*const volatile)()>, int (*const volatile)()));4549  static_assert(__is_same(remove_restrict_t<int (&)()>, int (&)()));4550 4551  static_assert(__is_same(remove_restrict_t<S>, S));4552  static_assert(__is_same(remove_restrict_t<const S>, const S));4553  static_assert(__is_same(remove_restrict_t<volatile S>, volatile S));4554  static_assert(__is_same(remove_restrict_t<S *__restrict>, S *));4555  static_assert(__is_same(remove_restrict_t<S *const volatile __restrict>, S *const volatile));4556  static_assert(__is_same(remove_restrict_t<int S::*__restrict>, int S::*));4557  static_assert(__is_same(remove_restrict_t<int (S::*const volatile)()>, int(S::*const volatile)()));4558}4559 4560template <class T> using remove_volatile_t = __remove_volatile(T);4561 4562void check_remove_volatile() {4563  static_assert(__is_same(remove_volatile_t<void>, void));4564  static_assert(__is_same(remove_volatile_t<volatile void>, void));4565  static_assert(__is_same(remove_volatile_t<int>, int));4566  static_assert(__is_same(remove_volatile_t<const int>, const int));4567  static_assert(__is_same(remove_volatile_t<volatile int>, int));4568  static_assert(__is_same(remove_volatile_t<int *__restrict>, int *__restrict));4569  static_assert(__is_same(remove_volatile_t<const volatile int>, const int));4570  static_assert(__is_same(remove_volatile_t<int *const volatile __restrict>, int *const __restrict));4571  static_assert(__is_same(remove_volatile_t<int *>, int *));4572  static_assert(__is_same(remove_volatile_t<int *volatile>, int *));4573  static_assert(__is_same(remove_volatile_t<int volatile *volatile>, int volatile *));4574  static_assert(__is_same(remove_volatile_t<int &>, int &));4575  static_assert(__is_same(remove_volatile_t<int volatile &>, int volatile &));4576  static_assert(__is_same(remove_volatile_t<int &&>, int &&));4577  static_assert(__is_same(remove_volatile_t<int volatile &&>, int volatile &&));4578  static_assert(__is_same(remove_volatile_t<int()>, int()));4579  static_assert(__is_same(remove_volatile_t<int (*volatile)()>, int (*)()));4580  static_assert(__is_same(remove_volatile_t<int (&)()>, int (&)()));4581 4582  static_assert(__is_same(remove_volatile_t<S>, S));4583  static_assert(__is_same(remove_volatile_t<const S>, const S));4584  static_assert(__is_same(remove_volatile_t<volatile S>, S));4585  static_assert(__is_same(remove_volatile_t<const volatile S>, const S));4586  static_assert(__is_same(remove_volatile_t<int S::*volatile>, int S::*));4587  static_assert(__is_same(remove_volatile_t<int (S::*volatile)()>, int(S::*)()));4588}4589 4590template <class T> using remove_cv_t = __remove_cv(T);4591 4592void check_remove_cv() {4593  static_assert(__is_same(remove_cv_t<void>, void));4594  static_assert(__is_same(remove_cv_t<const volatile void>, void));4595  static_assert(__is_same(remove_cv_t<int>, int));4596  static_assert(__is_same(remove_cv_t<const int>, int));4597  static_assert(__is_same(remove_cv_t<volatile int>, int));4598  static_assert(__is_same(remove_cv_t<const volatile int>, int));4599  static_assert(__is_same(remove_cv_t<int *>, int *));4600  static_assert(__is_same(remove_cv_t<int *const volatile>, int *));4601  static_assert(__is_same(remove_cv_t<int const *const volatile>, int const *));4602  static_assert(__is_same(remove_cv_t<int const *const volatile __restrict>, int const *__restrict));4603  static_assert(__is_same(remove_cv_t<int const *const volatile _Nonnull>, int const *_Nonnull));4604  static_assert(__is_same(remove_cv_t<int &>, int &));4605  static_assert(__is_same(remove_cv_t<int const volatile &>, int const volatile &));4606  static_assert(__is_same(remove_cv_t<int &&>, int &&));4607  static_assert(__is_same(remove_cv_t<int const volatile &&>, int const volatile &&));4608  static_assert(__is_same(remove_cv_t<int()>, int()));4609  static_assert(__is_same(remove_cv_t<int (*const volatile)()>, int (*)()));4610  static_assert(__is_same(remove_cv_t<int (&)()>, int (&)()));4611 4612  static_assert(__is_same(remove_cv_t<S>, S));4613  static_assert(__is_same(remove_cv_t<const S>, S));4614  static_assert(__is_same(remove_cv_t<volatile S>, S));4615  static_assert(__is_same(remove_cv_t<const volatile S>, S));4616  static_assert(__is_same(remove_cv_t<int S::*const volatile>, int S::*));4617  static_assert(__is_same(remove_cv_t<int (S::*const volatile)()>, int(S::*)()));4618}4619 4620template <class T> using add_pointer_t = __add_pointer(T);4621 4622void add_pointer() {4623  static_assert(__is_same(add_pointer_t<void>, void *));4624  static_assert(__is_same(add_pointer_t<const void>, const void *));4625  static_assert(__is_same(add_pointer_t<volatile void>, volatile void *));4626  static_assert(__is_same(add_pointer_t<const volatile void>, const volatile void *));4627  static_assert(__is_same(add_pointer_t<int>, int *));4628  static_assert(__is_same(add_pointer_t<const int>, const int *));4629  static_assert(__is_same(add_pointer_t<volatile int>, volatile int *));4630  static_assert(__is_same(add_pointer_t<const volatile int>, const volatile int *));4631  static_assert(__is_same(add_pointer_t<int *>, int **));4632  static_assert(__is_same(add_pointer_t<int &>, int *));4633  static_assert(__is_same(add_pointer_t<int &&>, int *));4634  static_assert(__is_same(add_pointer_t<int()>, int (*)()));4635  static_assert(__is_same(add_pointer_t<int (*)()>, int (**)()));4636  static_assert(__is_same(add_pointer_t<int (&)()>, int (*)()));4637 4638  static_assert(__is_same(add_pointer_t<S>, S *));4639  static_assert(__is_same(add_pointer_t<const S>, const S *));4640  static_assert(__is_same(add_pointer_t<volatile S>, volatile S *));4641  static_assert(__is_same(add_pointer_t<const volatile S>, const volatile S *));4642  static_assert(__is_same(add_pointer_t<int S::*>, int S::**));4643  static_assert(__is_same(add_pointer_t<int (S::*)()>, int(S::**)()));4644 4645  static_assert(__is_same(add_pointer_t<int __attribute__((address_space(1)))>, int __attribute__((address_space(1))) *));4646  static_assert(__is_same(add_pointer_t<S __attribute__((address_space(2)))>, S __attribute__((address_space(2))) *));4647}4648 4649template <class T> using remove_pointer_t = __remove_pointer(T);4650 4651void remove_pointer() {4652  static_assert(__is_same(remove_pointer_t<void>, void));4653  static_assert(__is_same(remove_pointer_t<const void>, const void));4654  static_assert(__is_same(remove_pointer_t<volatile void>, volatile void));4655  static_assert(__is_same(remove_pointer_t<const volatile void>, const volatile void));4656  static_assert(__is_same(remove_pointer_t<int>, int));4657  static_assert(__is_same(remove_pointer_t<const int>, const int));4658  static_assert(__is_same(remove_pointer_t<volatile int>, volatile int));4659  static_assert(__is_same(remove_pointer_t<const volatile int>, const volatile int));4660  static_assert(__is_same(remove_pointer_t<int *>, int));4661  static_assert(__is_same(remove_pointer_t<const int *>, const int));4662  static_assert(__is_same(remove_pointer_t<volatile int *>, volatile int));4663  static_assert(__is_same(remove_pointer_t<const volatile int *>, const volatile int));4664  static_assert(__is_same(remove_pointer_t<int *const>, int));4665  static_assert(__is_same(remove_pointer_t<int *volatile>, int));4666  static_assert(__is_same(remove_pointer_t<int *const volatile>, int));4667  static_assert(__is_same(remove_pointer_t<int &>, int &));4668  static_assert(__is_same(remove_pointer_t<int &&>, int &&));4669  static_assert(__is_same(remove_pointer_t<int()>, int()));4670  static_assert(__is_same(remove_pointer_t<int (*)()>, int()));4671  static_assert(__is_same(remove_pointer_t<int (&)()>, int (&)()));4672 4673  static_assert(__is_same(remove_pointer_t<S>, S));4674  static_assert(__is_same(remove_pointer_t<const S>, const S));4675  static_assert(__is_same(remove_pointer_t<volatile S>, volatile S));4676  static_assert(__is_same(remove_pointer_t<const volatile S>, const volatile S));4677  static_assert(__is_same(remove_pointer_t<int S::*>, int S::*));4678  static_assert(__is_same(remove_pointer_t<int (S::*)()>, int(S::*)()));4679 4680  static_assert(__is_same(remove_pointer_t<int __attribute__((address_space(1))) *>, int __attribute__((address_space(1)))));4681  static_assert(__is_same(remove_pointer_t<S __attribute__((address_space(2))) *>, S  __attribute__((address_space(2)))));4682 4683  static_assert(__is_same(remove_pointer_t<int (^)(char)>, int (^)(char)));4684}4685 4686template <class T> using add_lvalue_reference_t = __add_lvalue_reference(T);4687 4688void add_lvalue_reference() {4689  static_assert(__is_same(add_lvalue_reference_t<void>, void));4690  static_assert(__is_same(add_lvalue_reference_t<const void>, const void));4691  static_assert(__is_same(add_lvalue_reference_t<volatile void>, volatile void));4692  static_assert(__is_same(add_lvalue_reference_t<const volatile void>, const volatile void));4693  static_assert(__is_same(add_lvalue_reference_t<int>, int &));4694  static_assert(__is_same(add_lvalue_reference_t<const int>, const int &));4695  static_assert(__is_same(add_lvalue_reference_t<volatile int>, volatile int &));4696  static_assert(__is_same(add_lvalue_reference_t<const volatile int>, const volatile int &));4697  static_assert(__is_same(add_lvalue_reference_t<int *>, int *&));4698  static_assert(__is_same(add_lvalue_reference_t<int &>, int &));4699  static_assert(__is_same(add_lvalue_reference_t<int &&>, int &)); // reference collapsing4700  static_assert(__is_same(add_lvalue_reference_t<int()>, int (&)()));4701  static_assert(__is_same(add_lvalue_reference_t<int (*)()>, int (*&)()));4702  static_assert(__is_same(add_lvalue_reference_t<int (&)()>, int (&)()));4703 4704  static_assert(__is_same(add_lvalue_reference_t<S>, S &));4705  static_assert(__is_same(add_lvalue_reference_t<const S>, const S &));4706  static_assert(__is_same(add_lvalue_reference_t<volatile S>, volatile S &));4707  static_assert(__is_same(add_lvalue_reference_t<const volatile S>, const volatile S &));4708  static_assert(__is_same(add_lvalue_reference_t<int S::*>, int S::*&));4709  static_assert(__is_same(add_lvalue_reference_t<int (S::*)()>, int(S::*&)()));4710}4711 4712template <class T> using add_rvalue_reference_t = __add_rvalue_reference(T);4713 4714void add_rvalue_reference() {4715  static_assert(__is_same(add_rvalue_reference_t<void>, void));4716  static_assert(__is_same(add_rvalue_reference_t<const void>, const void));4717  static_assert(__is_same(add_rvalue_reference_t<volatile void>, volatile void));4718  static_assert(__is_same(add_rvalue_reference_t<const volatile void>, const volatile void));4719  static_assert(__is_same(add_rvalue_reference_t<int>, int &&));4720  static_assert(__is_same(add_rvalue_reference_t<const int>, const int &&));4721  static_assert(__is_same(add_rvalue_reference_t<volatile int>, volatile int &&));4722  static_assert(__is_same(add_rvalue_reference_t<const volatile int>, const volatile int &&));4723  static_assert(__is_same(add_rvalue_reference_t<int *>, int *&&));4724  static_assert(__is_same(add_rvalue_reference_t<int &>, int &)); // reference collapsing4725  static_assert(__is_same(add_rvalue_reference_t<int &&>, int &&));4726  static_assert(__is_same(add_rvalue_reference_t<int()>, int(&&)()));4727  static_assert(__is_same(add_rvalue_reference_t<int (*)()>, int (*&&)()));4728  static_assert(__is_same(add_rvalue_reference_t<int (&)()>, int (&)())); // reference collapsing4729 4730  static_assert(__is_same(add_rvalue_reference_t<S>, S &&));4731  static_assert(__is_same(add_rvalue_reference_t<const S>, const S &&));4732  static_assert(__is_same(add_rvalue_reference_t<volatile S>, volatile S &&));4733  static_assert(__is_same(add_rvalue_reference_t<const volatile S>, const volatile S &&));4734  static_assert(__is_same(add_rvalue_reference_t<int S::*>, int S::*&&));4735  static_assert(__is_same(add_rvalue_reference_t<int (S::*)()>, int(S::* &&)()));4736}4737 4738template <class T> using remove_reference_t = __remove_reference_t(T);4739 4740void check_remove_reference() {4741  static_assert(__is_same(remove_reference_t<void>, void));4742  static_assert(__is_same(remove_reference_t<const volatile void>, const volatile void));4743  static_assert(__is_same(remove_reference_t<int>, int));4744  static_assert(__is_same(remove_reference_t<const int>, const int));4745  static_assert(__is_same(remove_reference_t<volatile int>, volatile int));4746  static_assert(__is_same(remove_reference_t<const volatile int>, const volatile int));4747  static_assert(__is_same(remove_reference_t<int *>, int *));4748  static_assert(__is_same(remove_reference_t<int *const volatile>, int *const volatile));4749  static_assert(__is_same(remove_reference_t<int const *const volatile>, int const *const volatile));4750  static_assert(__is_same(remove_reference_t<int &>, int));4751  static_assert(__is_same(remove_reference_t<int const volatile &>, int const volatile));4752  static_assert(__is_same(remove_reference_t<int &&>, int));4753  static_assert(__is_same(remove_reference_t<int const volatile &&>, int const volatile));4754  static_assert(__is_same(remove_reference_t<int()>, int()));4755  static_assert(__is_same(remove_reference_t<int (*const volatile)()>, int (*const volatile)()));4756  static_assert(__is_same(remove_reference_t<int (&)()>, int()));4757 4758  static_assert(__is_same(remove_reference_t<S>, S));4759  static_assert(__is_same(remove_reference_t<S &>, S));4760  static_assert(__is_same(remove_reference_t<S &&>, S));4761  static_assert(__is_same(remove_reference_t<const S>, const S));4762  static_assert(__is_same(remove_reference_t<const S &>, const S));4763  static_assert(__is_same(remove_reference_t<const S &&>, const S));4764  static_assert(__is_same(remove_reference_t<volatile S>, volatile S));4765  static_assert(__is_same(remove_reference_t<volatile S &>, volatile S));4766  static_assert(__is_same(remove_reference_t<volatile S &&>, volatile S));4767  static_assert(__is_same(remove_reference_t<const volatile S>, const volatile S));4768  static_assert(__is_same(remove_reference_t<const volatile S &>, const volatile S));4769  static_assert(__is_same(remove_reference_t<const volatile S &&>, const volatile S));4770  static_assert(__is_same(remove_reference_t<int S::*const volatile &>, int S::*const volatile));4771  static_assert(__is_same(remove_reference_t<int (S::*const volatile &)()>, int(S::*const volatile)()));4772  static_assert(__is_same(remove_reference_t<int (S::*const volatile &&)() &>, int(S::*const volatile)() &));4773}4774 4775template <class T> using remove_cvref_t = __remove_cvref(T);4776 4777void check_remove_cvref() {4778  static_assert(__is_same(remove_cvref_t<void>, void));4779  static_assert(__is_same(remove_cvref_t<const volatile void>, void));4780  static_assert(__is_same(remove_cvref_t<int>, int));4781  static_assert(__is_same(remove_cvref_t<const int>, int));4782  static_assert(__is_same(remove_cvref_t<volatile int>, int));4783  static_assert(__is_same(remove_cvref_t<const volatile int>, int));4784  static_assert(__is_same(remove_cvref_t<int *>, int *));4785  static_assert(__is_same(remove_cvref_t<int *const volatile>, int *));4786  static_assert(__is_same(remove_cvref_t<int const *const volatile>, int const *));4787  static_assert(__is_same(remove_cvref_t<int const *const volatile __restrict>, int const *__restrict));4788  static_assert(__is_same(remove_cvref_t<int const *const volatile _Nonnull>, int const *_Nonnull));4789  static_assert(__is_same(remove_cvref_t<int &>, int));4790  static_assert(__is_same(remove_cvref_t<int const volatile &>, int));4791  static_assert(__is_same(remove_cvref_t<int &&>, int));4792  static_assert(__is_same(remove_cvref_t<int const volatile &&>, int));4793  static_assert(__is_same(remove_cvref_t<int()>, int()));4794  static_assert(__is_same(remove_cvref_t<int (*const volatile)()>, int (*)()));4795  static_assert(__is_same(remove_cvref_t<int (&)()>, int()));4796 4797  static_assert(__is_same(remove_cvref_t<S>, S));4798  static_assert(__is_same(remove_cvref_t<S &>, S));4799  static_assert(__is_same(remove_cvref_t<S &&>, S));4800  static_assert(__is_same(remove_cvref_t<const S>, S));4801  static_assert(__is_same(remove_cvref_t<const S &>, S));4802  static_assert(__is_same(remove_cvref_t<const S &&>, S));4803  static_assert(__is_same(remove_cvref_t<volatile S>, S));4804  static_assert(__is_same(remove_cvref_t<volatile S &>, S));4805  static_assert(__is_same(remove_cvref_t<volatile S &&>, S));4806  static_assert(__is_same(remove_cvref_t<const volatile S>, S));4807  static_assert(__is_same(remove_cvref_t<const volatile S &>, S));4808  static_assert(__is_same(remove_cvref_t<const volatile S &&>, S));4809  static_assert(__is_same(remove_cvref_t<int S::*const volatile>, int S::*));4810  static_assert(__is_same(remove_cvref_t<int (S::*const volatile)()>, int(S::*)()));4811  static_assert(__is_same(remove_cvref_t<int (S::*const volatile)() &>, int(S::*)() &));4812  static_assert(__is_same(remove_cvref_t<int (S::*const volatile)() &&>, int(S::*)() &&));4813}4814 4815template <class T> using decay_t = __decay(T);4816 4817void check_decay() {4818  static_assert(__is_same(decay_t<void>, void));4819  static_assert(__is_same(decay_t<const volatile void>, void));4820  static_assert(__is_same(decay_t<int>, int));4821  static_assert(__is_same(decay_t<const int>, int));4822  static_assert(__is_same(decay_t<volatile int>, int));4823  static_assert(__is_same(decay_t<const volatile int>, int));4824  static_assert(__is_same(decay_t<int *>, int *));4825  static_assert(__is_same(decay_t<int *const volatile>, int *));4826  static_assert(__is_same(decay_t<int *const volatile __restrict>, int *));4827  static_assert(__is_same(decay_t<int const *const volatile>, int const *));4828  static_assert(__is_same(decay_t<int const *const volatile _Nonnull>, int const *));4829  static_assert(__is_same(decay_t<int &>, int));4830  static_assert(__is_same(decay_t<int const volatile &>, int));4831  static_assert(__is_same(decay_t<int &&>, int));4832  static_assert(__is_same(decay_t<int const volatile &&>, int));4833  static_assert(__is_same(decay_t<int()>, int (*)()));4834  static_assert(__is_same(decay_t<int (*)()>, int (*)()));4835  static_assert(__is_same(decay_t<int (*const)()>, int (*)()));4836  static_assert(__is_same(decay_t<int (*volatile)()>, int (*)()));4837  static_assert(__is_same(decay_t<int (*const volatile)()>, int (*)()));4838  static_assert(__is_same(decay_t<int (&)()>, int (*)()));4839  static_assert(__is_same(decay_t<IntAr>, int *));4840  static_assert(__is_same(decay_t<IntArNB>, int *));4841 4842  static_assert(__is_same(decay_t<S>, S));4843  static_assert(__is_same(decay_t<S &>, S));4844  static_assert(__is_same(decay_t<S &&>, S));4845  static_assert(__is_same(decay_t<const S>, S));4846  static_assert(__is_same(decay_t<const S &>, S));4847  static_assert(__is_same(decay_t<const S &&>, S));4848  static_assert(__is_same(decay_t<volatile S>, S));4849  static_assert(__is_same(decay_t<volatile S &>, S));4850  static_assert(__is_same(decay_t<volatile S &&>, S));4851  static_assert(__is_same(decay_t<const volatile S>, S));4852  static_assert(__is_same(decay_t<const volatile S &>, S));4853  static_assert(__is_same(decay_t<const volatile S &&>, S));4854  static_assert(__is_same(decay_t<int S::*const volatile>, int S::*));4855  static_assert(__is_same(decay_t<int (S::*const volatile)()>, int(S::*)()));4856  static_assert(__is_same(decay_t<int S::*const volatile &>, int S::*));4857  static_assert(__is_same(decay_t<int (S::*const volatile &)()>, int(S::*)()));4858  static_assert(__is_same(decay_t<int S::*const volatile &&>, int S::*));4859}4860 4861template <class T> struct CheckAbominableFunction {};4862template <class M>4863struct CheckAbominableFunction<M S::*> {4864  static void checks() {4865    static_assert(__is_same(add_lvalue_reference_t<M>, M));4866    static_assert(__is_same(add_pointer_t<M>, M));4867    static_assert(__is_same(add_rvalue_reference_t<M>, M));4868    static_assert(__is_same(decay_t<M>, M));4869    static_assert(__is_same(remove_const_t<M>, M));4870    static_assert(__is_same(remove_volatile_t<M>, M));4871    static_assert(__is_same(remove_cv_t<M>, M));4872    static_assert(__is_same(remove_cvref_t<M>, M));4873    static_assert(__is_same(remove_pointer_t<M>, M));4874    static_assert(__is_same(remove_reference_t<M>, M));4875  }4876};4877 4878void check_abominable_function() {4879  { CheckAbominableFunction<int (S::*)() &> x; }4880  { CheckAbominableFunction<int (S::*)() &&> x; }4881  { CheckAbominableFunction<int (S::*)() const> x; }4882  { CheckAbominableFunction<int (S::*)() const &> x; }4883  { CheckAbominableFunction<int (S::*)() const &&> x; }4884  { CheckAbominableFunction<int (S::*)() volatile> x; }4885  { CheckAbominableFunction<int (S::*)() volatile &> x; }4886  { CheckAbominableFunction<int (S::*)() volatile &&> x; }4887  { CheckAbominableFunction<int (S::*)() const volatile> x; }4888  { CheckAbominableFunction<int (S::*)() const volatile &> x; }4889  { CheckAbominableFunction<int (S::*)() const volatile &&> x; }4890}4891 4892template <class T> using make_signed_t = __make_signed(T);4893template <class T, class Expected>4894void check_make_signed() {4895  static_assert(__is_same(make_signed_t<T>, Expected));4896  static_assert(__is_same(make_signed_t<const T>, const Expected));4897  static_assert(__is_same(make_signed_t<volatile T>, volatile Expected));4898  static_assert(__is_same(make_signed_t<const volatile T>, const volatile Expected));4899}4900 4901#if defined(__ILP32__) || defined(__LLP64__)4902  using Int64 = long long;4903  using UInt64 = unsigned long long;4904#elif defined(__LP64__) || defined(__ILP64__) || defined(__SILP64__)4905  using Int64 = long;4906  using UInt64 = unsigned long;4907#else4908#error Programming model currently unsupported; please add a new entry.4909#endif4910 4911enum UnscopedBool : bool {}; // deliberately char4912enum class ScopedBool : bool {}; // deliberately char4913enum UnscopedChar : char {}; // deliberately char4914enum class ScopedChar : char {}; // deliberately char4915enum UnscopedUChar : unsigned char {};4916enum class ScopedUChar : unsigned char {};4917enum UnscopedLongLong : long long {};4918enum UnscopedULongLong : unsigned long long {};4919enum class ScopedLongLong : long long {};4920enum class ScopedULongLong : unsigned long long {};4921enum class UnscopedInt128 : __int128 {};4922enum class ScopedInt128 : __int128 {};4923enum class UnscopedUInt128 : unsigned __int128 {};4924enum class ScopedUInt128 : unsigned __int128 {};4925 4926void make_signed() {4927  check_make_signed<char, signed char>();4928  check_make_signed<signed char, signed char>();4929  check_make_signed<unsigned char, signed char>();4930  check_make_signed<short, short>();4931  check_make_signed<unsigned short, short>();4932  check_make_signed<int, int>();4933  check_make_signed<unsigned int, int>();4934  check_make_signed<long, long>();4935  check_make_signed<unsigned long, long>();4936  check_make_signed<long long, long long>();4937  check_make_signed<unsigned long long, long long>();4938  check_make_signed<__int128, __int128>();4939  check_make_signed<__uint128_t, __int128>();4940  check_make_signed<_BitInt(65), _BitInt(65)>();4941  check_make_signed<unsigned _BitInt(65), _BitInt(65)>();4942 4943  check_make_signed<wchar_t, int>();4944#if __cplusplus >= 202002L4945  check_make_signed<char8_t, signed char>();4946#endif4947#if __cplusplus >= 201103L4948  check_make_signed<char16_t, short>();4949  check_make_signed<char32_t, int>();4950#endif4951 4952  check_make_signed<UnscopedChar, signed char>();4953  check_make_signed<ScopedChar, signed char>();4954  check_make_signed<UnscopedUChar, signed char>();4955  check_make_signed<ScopedUChar, signed char>();4956 4957  check_make_signed<UnscopedLongLong, Int64>();4958  check_make_signed<UnscopedULongLong, Int64>();4959  check_make_signed<ScopedLongLong, Int64>();4960  check_make_signed<ScopedULongLong, Int64>();4961 4962  check_make_signed<UnscopedInt128, __int128>();4963  check_make_signed<ScopedInt128, __int128>();4964  check_make_signed<UnscopedUInt128, __int128>();4965  check_make_signed<ScopedUInt128, __int128>();4966 4967  { using ExpectedError = __make_signed(bool); }4968  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'bool'}}4969  { using ExpectedError = __make_signed(UnscopedBool); }4970  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'UnscopedBool' whose underlying type is 'bool'}}4971  { using ExpectedError = __make_signed(ScopedBool); }4972  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'ScopedBool' whose underlying type is 'bool'}}4973  { using ExpectedError = __make_signed(unsigned _BitInt(1)); }4974  // expected-error@*:*{{'make_signed' is only compatible with non-_BitInt(1) integers and enum types, but was given 'unsigned _BitInt(1)'}}4975  { using ExpectedError = __make_signed(int[]); }4976  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int[]'}}4977  { using ExpectedError = __make_signed(int[5]); }4978  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int[5]'}}4979  { using ExpectedError = __make_signed(void); }4980  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'void'}}4981  { using ExpectedError = __make_signed(int *); }4982  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int *'}}4983  { using ExpectedError = __make_signed(int &); }4984  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int &'}}4985  { using ExpectedError = __make_signed(int &&); }4986  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int &&'}}4987  { using ExpectedError = __make_signed(float); }4988  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'float'}}4989  { using ExpectedError = __make_signed(double); }4990  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'double'}}4991  { using ExpectedError = __make_signed(long double); }4992  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'long double'}}4993  { using ExpectedError = __make_signed(S); }4994  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'S'}}4995  { using ExpectedError = __make_signed(S *); }4996  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'S *'}}4997  { using ExpectedError = __make_signed(int S::*); }4998  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int S::*'}}4999  { using ExpectedError = __make_signed(int(S::*)()); }5000  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int (S::*)()'}}5001}5002 5003template <class T>5004using make_unsigned_t = __make_unsigned(T);5005 5006template <class T, class Expected>5007void check_make_unsigned() {5008  static_assert(__is_same(make_unsigned_t<T>, Expected));5009  static_assert(__is_same(make_unsigned_t<const T>, const Expected));5010  static_assert(__is_same(make_unsigned_t<volatile T>, volatile Expected));5011  static_assert(__is_same(make_unsigned_t<const volatile T>, const volatile Expected));5012}5013 5014void make_unsigned() {5015  check_make_unsigned<char, unsigned char>();5016  check_make_unsigned<signed char, unsigned char>();5017  check_make_unsigned<unsigned char, unsigned char>();5018  check_make_unsigned<short, unsigned short>();5019  check_make_unsigned<unsigned short, unsigned short>();5020  check_make_unsigned<int, unsigned int>();5021  check_make_unsigned<unsigned int, unsigned int>();5022  check_make_unsigned<long, unsigned long>();5023  check_make_unsigned<unsigned long, unsigned long>();5024  check_make_unsigned<long long, unsigned long long>();5025  check_make_unsigned<unsigned long long, unsigned long long>();5026  check_make_unsigned<__int128, __uint128_t>();5027  check_make_unsigned<__uint128_t, __uint128_t>();5028  check_make_unsigned<_BitInt(65), unsigned _BitInt(65)>();5029  check_make_unsigned<unsigned _BitInt(65), unsigned _BitInt(65)>();5030 5031  check_make_unsigned<wchar_t, unsigned int>();5032#if __cplusplus >= 202002L5033  check_make_unsigned<char8_t, unsigned char>();5034#endif5035#if __cplusplus >= 201103L5036  check_make_unsigned<char16_t, unsigned short>();5037  check_make_unsigned<char32_t, unsigned int>();5038#endif5039 5040  check_make_unsigned<UnscopedChar, unsigned char>();5041  check_make_unsigned<ScopedChar, unsigned char>();5042  check_make_unsigned<UnscopedUChar, unsigned char>();5043  check_make_unsigned<ScopedUChar, unsigned char>();5044 5045  check_make_unsigned<UnscopedLongLong, UInt64>();5046  check_make_unsigned<UnscopedULongLong, UInt64>();5047  check_make_unsigned<ScopedLongLong, UInt64>();5048  check_make_unsigned<ScopedULongLong, UInt64>();5049 5050  check_make_unsigned<UnscopedInt128, unsigned __int128>();5051  check_make_unsigned<ScopedInt128, unsigned __int128>();5052  check_make_unsigned<UnscopedUInt128, unsigned __int128>();5053  check_make_unsigned<ScopedUInt128, unsigned __int128>();5054 5055  { using ExpectedError = __make_unsigned(bool); }5056  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'bool'}}5057  { using ExpectedError = __make_unsigned(UnscopedBool); }5058  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'UnscopedBool' whose underlying type is 'bool'}}5059  { using ExpectedError = __make_unsigned(ScopedBool); }5060  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'ScopedBool' whose underlying type is 'bool'}}5061  { using ExpectedError = __make_unsigned(unsigned _BitInt(1)); }5062  // expected-error@*:*{{'make_unsigned' is only compatible with non-_BitInt(1) integers and enum types, but was given 'unsigned _BitInt(1)'}}5063  { using ExpectedError = __make_unsigned(int[]); }5064  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int[]'}}5065  { using ExpectedError = __make_unsigned(int[5]); }5066  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int[5]'}}5067  { using ExpectedError = __make_unsigned(void); }5068  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'void'}}5069  { using ExpectedError = __make_unsigned(int *); }5070  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int *'}}5071  { using ExpectedError = __make_unsigned(int &); }5072  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int &'}}5073  { using ExpectedError = __make_unsigned(int &&); }5074  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int &&'}}5075  { using ExpectedError = __make_unsigned(float); }5076  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'float'}}5077  { using ExpectedError = __make_unsigned(double); }5078  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'double'}}5079  { using ExpectedError = __make_unsigned(long double); }5080  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'long double'}}5081  { using ExpectedError = __make_unsigned(S); }5082  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'S'}}5083  { using ExpectedError = __make_unsigned(S *); }5084  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'S *'}}5085  { using ExpectedError = __make_unsigned(int S::*); }5086  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int S::*'}}5087  { using ExpectedError = __make_unsigned(int(S::*)()); }5088  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int (S::*)()'}}5089}5090 5091template <class T> using remove_extent_t = __remove_extent(T);5092 5093void remove_extent() {5094  static_assert(__is_same(remove_extent_t<void>, void));5095  static_assert(__is_same(remove_extent_t<int>, int));5096  static_assert(__is_same(remove_extent_t<int[]>, int));5097  static_assert(__is_same(remove_extent_t<int[1]>, int));5098  static_assert(__is_same(remove_extent_t<int[1][2]>, int[2]));5099  static_assert(__is_same(remove_extent_t<int[][2]>, int[2]));5100  static_assert(__is_same(remove_extent_t<const int[]>, const int));5101  static_assert(__is_same(remove_extent_t<const int[1]>, const int));5102  static_assert(__is_same(remove_extent_t<const int[1][2]>, const int[2]));5103  static_assert(__is_same(remove_extent_t<const int[][2]>, const int[2]));5104  static_assert(__is_same(remove_extent_t<volatile int[]>, volatile int));5105  static_assert(__is_same(remove_extent_t<volatile int[1]>, volatile int));5106  static_assert(__is_same(remove_extent_t<volatile int[1][2]>, volatile int[2]));5107  static_assert(__is_same(remove_extent_t<volatile int[][2]>, volatile int[2]));5108  static_assert(__is_same(remove_extent_t<const volatile int[]>, const volatile int));5109  static_assert(__is_same(remove_extent_t<const volatile int[1]>, const volatile int));5110  static_assert(__is_same(remove_extent_t<const volatile int[1][2]>, const volatile int[2]));5111  static_assert(__is_same(remove_extent_t<const volatile int[][2]>, const volatile int[2]));5112  static_assert(__is_same(remove_extent_t<int *>, int *));5113  static_assert(__is_same(remove_extent_t<int &>, int &));5114  static_assert(__is_same(remove_extent_t<int &&>, int &&));5115  static_assert(__is_same(remove_extent_t<int()>, int()));5116  static_assert(__is_same(remove_extent_t<int (*)()>, int (*)()));5117  static_assert(__is_same(remove_extent_t<int (&)()>, int (&)()));5118 5119  static_assert(__is_same(remove_extent_t<S>, S));5120  static_assert(__is_same(remove_extent_t<int S::*>, int S::*));5121  static_assert(__is_same(remove_extent_t<int (S::*)()>, int(S::*)()));5122 5123  using SomeArray = int[1][2];5124  static_assert(__is_same(remove_extent_t<const SomeArray>, const int[2]));5125}5126 5127template <class T> using remove_all_extents_t = __remove_all_extents(T);5128 5129void remove_all_extents() {5130  static_assert(__is_same(remove_all_extents_t<void>, void));5131  static_assert(__is_same(remove_all_extents_t<int>, int));5132  static_assert(__is_same(remove_all_extents_t<const int>, const int));5133  static_assert(__is_same(remove_all_extents_t<volatile int>, volatile int));5134  static_assert(__is_same(remove_all_extents_t<const volatile int>, const volatile int));5135  static_assert(__is_same(remove_all_extents_t<int[]>, int));5136  static_assert(__is_same(remove_all_extents_t<int[1]>, int));5137  static_assert(__is_same(remove_all_extents_t<int[1][2]>, int));5138  static_assert(__is_same(remove_all_extents_t<int[][2]>, int));5139  static_assert(__is_same(remove_all_extents_t<const int[]>, const int));5140  static_assert(__is_same(remove_all_extents_t<const int[1]>, const int));5141  static_assert(__is_same(remove_all_extents_t<const int[1][2]>, const int));5142  static_assert(__is_same(remove_all_extents_t<const int[][2]>, const int));5143  static_assert(__is_same(remove_all_extents_t<volatile int[]>, volatile int));5144  static_assert(__is_same(remove_all_extents_t<volatile int[1]>, volatile int));5145  static_assert(__is_same(remove_all_extents_t<volatile int[1][2]>, volatile int));5146  static_assert(__is_same(remove_all_extents_t<volatile int[][2]>, volatile int));5147  static_assert(__is_same(remove_all_extents_t<const volatile int[]>, const volatile int));5148  static_assert(__is_same(remove_all_extents_t<const volatile int[1]>, const volatile int));5149  static_assert(__is_same(remove_all_extents_t<const volatile int[1][2]>, const volatile int));5150  static_assert(__is_same(remove_all_extents_t<const volatile int[][2]>, const volatile int));5151  static_assert(__is_same(remove_all_extents_t<int *>, int *));5152  static_assert(__is_same(remove_all_extents_t<int &>, int &));5153  static_assert(__is_same(remove_all_extents_t<int &&>, int &&));5154  static_assert(__is_same(remove_all_extents_t<int()>, int()));5155  static_assert(__is_same(remove_all_extents_t<int (*)()>, int (*)()));5156  static_assert(__is_same(remove_all_extents_t<int (&)()>, int (&)()));5157 5158  static_assert(__is_same(remove_all_extents_t<S>, S));5159  static_assert(__is_same(remove_all_extents_t<int S::*>, int S::*));5160  static_assert(__is_same(remove_all_extents_t<int (S::*)()>, int(S::*)()));5161 5162  using SomeArray = int[1][2];5163  static_assert(__is_same(remove_all_extents_t<const SomeArray>, const int));5164}5165 5166namespace GH121278 {5167// https://cplusplus.github.io/LWG/lwg-active.html#39295168#if __cplusplus >= 202002L5169template <typename B, typename D>5170concept C = __is_base_of(B, D);5171// expected-error@-1 {{incomplete type 'S' used in type trait expression}}5172// expected-note@-2 {{while substituting template arguments into constraint expression here}}5173 5174struct T;5175struct S;5176bool b = C<T, S>;5177// expected-note@-1 {{while checking the satisfaction of concept 'C<T, S>' requested here}}5178#endif5179}5180