test/SemaCXX/type-traits.cpp

// 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  %s
// 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  %s
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++17 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted  %s
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++20 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted  %s


struct NonPOD { NonPOD(int); };
typedef NonPOD NonPODAr[10];
typedef NonPOD NonPODArNB[];
typedef NonPOD NonPODArMB[10][2];

// PODs
enum Enum { EV };
enum SignedEnum : signed int { };
enum UnsignedEnum : unsigned int { };
enum class EnumClass { EV };
enum class SignedEnumClass : signed int {};
enum class UnsignedEnumClass : unsigned int {};
struct POD { Enum e; int i; float f; NonPOD* p; };
struct Empty {};
struct IncompleteStruct;
typedef Empty EmptyAr[10];
typedef Empty EmptyArNB[];
typedef Empty EmptyArMB[1][2];
typedef int Int;
typedef Int IntAr[10];
typedef Int IntArNB[];
class Statics { static int priv; static NonPOD np; };
union EmptyUnion {};
union IncompleteUnion; // expected-note {{forward declaration of 'IncompleteUnion'}}
union Union { int i; float f; };
struct HasFunc { void f (); };
struct HasOp { void operator *(); };
struct HasConv { operator int(); };
struct HasAssign { void operator =(int); };

struct HasAnonymousUnion {
  union {
    int i;
    float f;
  };
};

typedef int Vector __attribute__((vector_size(16)));
typedef int VectorExt __attribute__((ext_vector_type(4)));

using ComplexFloat = _Complex float;
using ComplexInt = _Complex int;

// Not PODs
typedef const void cvoid;
struct Derives : POD {};
typedef Derives DerivesAr[10];
typedef Derives DerivesArNB[];
struct DerivesEmpty : Empty {};
struct HasCons { HasCons(int); };
struct HasDefaultCons { HasDefaultCons() = default; };
struct HasExplicitDefaultCons { explicit HasExplicitDefaultCons() = default; };
struct HasInheritedCons : HasDefaultCons { using HasDefaultCons::HasDefaultCons; };
struct HasNoInheritedCons : HasCons {};
struct HasCopyAssign { HasCopyAssign operator =(const HasCopyAssign&); };
struct HasMoveAssign { HasMoveAssign operator =(const HasMoveAssign&&); };
struct HasNoThrowMoveAssign {
  HasNoThrowMoveAssign& operator=(
    const HasNoThrowMoveAssign&&) throw(); };
struct HasNoExceptNoThrowMoveAssign {
  HasNoExceptNoThrowMoveAssign& operator=(
    const HasNoExceptNoThrowMoveAssign&&) noexcept;
};
struct HasThrowMoveAssign {
  HasThrowMoveAssign& operator=(const HasThrowMoveAssign&&)
#if __cplusplus <= 201402L
  throw(POD);
#else
  noexcept(false);
#endif
};


struct HasNoExceptFalseMoveAssign {
  HasNoExceptFalseMoveAssign& operator=(
    const HasNoExceptFalseMoveAssign&&) noexcept(false); };
struct HasMoveCtor { HasMoveCtor(const HasMoveCtor&&); };
struct HasMemberMoveCtor { HasMoveCtor member; };
struct HasMemberMoveAssign { HasMoveAssign member; };
struct HasStaticMemberMoveCtor { static HasMoveCtor member; };
struct HasStaticMemberMoveAssign { static HasMoveAssign member; };
struct HasMemberThrowMoveAssign { HasThrowMoveAssign member; };
struct HasMemberNoExceptFalseMoveAssign {
  HasNoExceptFalseMoveAssign member; };
struct HasMemberNoThrowMoveAssign { HasNoThrowMoveAssign member; };
struct HasMemberNoExceptNoThrowMoveAssign {
  HasNoExceptNoThrowMoveAssign member; };

struct HasDefaultTrivialCopyAssign {
  HasDefaultTrivialCopyAssign &operator=(
    const HasDefaultTrivialCopyAssign&) = default;
};
struct TrivialMoveButNotCopy {
  TrivialMoveButNotCopy &operator=(TrivialMoveButNotCopy&&) = default;
  TrivialMoveButNotCopy &operator=(const TrivialMoveButNotCopy&);
};
struct NonTrivialDefault {
  NonTrivialDefault();
};

struct HasDest { ~HasDest(); };
class  HasPriv { int priv; };
class  HasProt { protected: int prot; };
struct HasRef { int i; int& ref; HasRef() : i(0), ref(i) {} };
struct HasRefAggregate { int i; int& ref; };
struct HasNonPOD { NonPOD np; };
struct HasVirt { virtual void Virt() {}; };
typedef NonPOD NonPODAr[10];
typedef HasVirt VirtAr[10];
typedef NonPOD NonPODArNB[];
union NonPODUnion { int i; Derives n; };
struct DerivesHasCons : HasCons {};
struct DerivesHasCopyAssign : HasCopyAssign {};
struct DerivesHasMoveAssign : HasMoveAssign {};
struct DerivesHasDest : HasDest {};
struct DerivesHasPriv : HasPriv {};
struct DerivesHasProt : HasProt {};
struct DerivesHasRef : HasRef {};
struct DerivesHasVirt : HasVirt {};
struct DerivesHasMoveCtor : HasMoveCtor {};

struct HasNoThrowCopyAssign {
  void operator =(const HasNoThrowCopyAssign&) throw();
};
struct HasMultipleCopyAssign {
  void operator =(const HasMultipleCopyAssign&) throw();
  void operator =(volatile HasMultipleCopyAssign&);
};
struct HasMultipleNoThrowCopyAssign {
  void operator =(const HasMultipleNoThrowCopyAssign&) throw();
  void operator =(volatile HasMultipleNoThrowCopyAssign&) throw();
};

struct HasNoThrowConstructor { HasNoThrowConstructor() throw(); };
struct HasNoThrowConstructorWithArgs {
  HasNoThrowConstructorWithArgs(HasCons i = HasCons(0)) throw();
};
struct HasMultipleDefaultConstructor1 {
  HasMultipleDefaultConstructor1() throw();
  HasMultipleDefaultConstructor1(int i = 0);
};
struct HasMultipleDefaultConstructor2 {
  HasMultipleDefaultConstructor2(int i = 0);
  HasMultipleDefaultConstructor2() throw();
};

struct HasNoThrowCopy { HasNoThrowCopy(const HasNoThrowCopy&) throw(); };
struct HasMultipleCopy {
  HasMultipleCopy(const HasMultipleCopy&) throw();
  HasMultipleCopy(volatile HasMultipleCopy&);
};
struct HasMultipleNoThrowCopy {
  HasMultipleNoThrowCopy(const HasMultipleNoThrowCopy&) throw();
  HasMultipleNoThrowCopy(volatile HasMultipleNoThrowCopy&) throw();
};

struct HasVirtDest { virtual ~HasVirtDest(); };
struct DerivedVirtDest : HasVirtDest {};
typedef HasVirtDest VirtDestAr[1];

class AllPrivate {
  AllPrivate() throw();
  AllPrivate(const AllPrivate&) throw();
  AllPrivate &operator=(const AllPrivate &) throw();
  ~AllPrivate() throw();
};

struct ThreeArgCtor {
  ThreeArgCtor(int*, char*, int);
};

struct VariadicCtor {
  template<typename...T> VariadicCtor(T...);
};

struct ThrowingDtor {
  ~ThrowingDtor()
#if __cplusplus <= 201402L
  throw(int);
#else
  noexcept(false);
#endif
};

struct NoExceptDtor {
  ~NoExceptDtor() noexcept(true);
};

struct NoThrowDtor {
  ~NoThrowDtor() throw();
};

struct ACompleteType {};
struct AnIncompleteType; // expected-note 1+ {{forward declaration of 'AnIncompleteType'}}
typedef AnIncompleteType AnIncompleteTypeAr[42];
typedef AnIncompleteType AnIncompleteTypeArNB[];
typedef AnIncompleteType AnIncompleteTypeArMB[1][10];

struct HasInClassInit {
  int x = 42;
};

struct HasPrivateBase : private ACompleteType {};
struct HasProtectedBase : protected ACompleteType {};
struct HasVirtBase : virtual ACompleteType {};

void is_pod()
{
  static_assert(__is_pod(int));
  static_assert(__is_pod(Enum));
  static_assert(__is_pod(POD));
  static_assert(__is_pod(Int));
  static_assert(__is_pod(IntAr));
  static_assert(__is_pod(Statics));
  static_assert(__is_pod(Empty));
  static_assert(__is_pod(EmptyUnion));
  static_assert(__is_pod(Union));
  static_assert(__is_pod(HasFunc));
  static_assert(__is_pod(HasOp));
  static_assert(__is_pod(HasConv));
  static_assert(__is_pod(HasAssign));
  static_assert(__is_pod(IntArNB));
  static_assert(__is_pod(HasAnonymousUnion));
  static_assert(__is_pod(Vector));
  static_assert(__is_pod(VectorExt));
  static_assert(__is_pod(Derives));
  static_assert(__is_pod(DerivesAr));
  static_assert(__is_pod(DerivesArNB));
  static_assert(__is_pod(DerivesEmpty));
  static_assert(__is_pod(HasPriv));
  static_assert(__is_pod(HasProt));
  static_assert(__is_pod(DerivesHasPriv));
  static_assert(__is_pod(DerivesHasProt));

  static_assert(!__is_pod(HasCons));
  static_assert(!__is_pod(HasCopyAssign));
  static_assert(!__is_pod(HasMoveAssign));
  static_assert(!__is_pod(HasDest));
  static_assert(!__is_pod(HasRef));
  static_assert(!__is_pod(HasVirt));
  static_assert(!__is_pod(DerivesHasCons));
  static_assert(!__is_pod(DerivesHasCopyAssign));
  static_assert(!__is_pod(DerivesHasMoveAssign));
  static_assert(!__is_pod(DerivesHasDest));
  static_assert(!__is_pod(DerivesHasRef));
  static_assert(!__is_pod(DerivesHasVirt));
  static_assert(!__is_pod(NonPOD));
  static_assert(!__is_pod(HasNonPOD));
  static_assert(!__is_pod(NonPODAr));
  static_assert(!__is_pod(NonPODArNB));
  static_assert(!__is_pod(void));
  static_assert(!__is_pod(cvoid));
// static_assert(!__is_pod(NonPODUnion));

  static_assert(__is_pod(ACompleteType));
  static_assert(!__is_pod(AnIncompleteType)); // expected-error {{incomplete type}}
  static_assert(!__is_pod(AnIncompleteType[])); // expected-error {{incomplete type}}
  static_assert(!__is_pod(AnIncompleteType[1])); // expected-error {{incomplete type}}
}

typedef Empty EmptyAr[10];
struct Bit0 { int : 0; };
struct Bit0Cons { int : 0; Bit0Cons(); };
struct AnonBitOnly { int : 3; };
struct BitOnly { int x : 3; };
struct DerivesVirt : virtual POD {};

void is_empty()
{
  static_assert(__is_empty(Empty));
  static_assert(__is_empty(DerivesEmpty));
  static_assert(__is_empty(HasCons));
  static_assert(__is_empty(HasCopyAssign));
  static_assert(__is_empty(HasMoveAssign));
  static_assert(__is_empty(HasDest));
  static_assert(__is_empty(HasFunc));
  static_assert(__is_empty(HasOp));
  static_assert(__is_empty(HasConv));
  static_assert(__is_empty(HasAssign));
  static_assert(__is_empty(Bit0));
  static_assert(__is_empty(Bit0Cons));

  static_assert(!__is_empty(Int));
  static_assert(!__is_empty(POD));
  static_assert(!__is_empty(EmptyUnion));
  static_assert(!__is_empty(IncompleteUnion));
  static_assert(!__is_empty(EmptyAr));
  static_assert(!__is_empty(HasRef));
  static_assert(!__is_empty(HasVirt));
  static_assert(!__is_empty(AnonBitOnly));
  static_assert(!__is_empty(BitOnly));
  static_assert(!__is_empty(void));
  static_assert(!__is_empty(IntArNB));
  static_assert(!__is_empty(HasAnonymousUnion));
//  static_assert(!__is_empty(DerivesVirt));

  static_assert(__is_empty(ACompleteType));
  static_assert(!__is_empty(AnIncompleteType)); // expected-error {{incomplete type}}
  static_assert(!__is_empty(AnIncompleteType[]));
  static_assert(!__is_empty(AnIncompleteType[1]));
}

typedef Derives ClassType;

void is_class()
{
  static_assert(__is_class(Derives));
  static_assert(__is_class(HasPriv));
  static_assert(__is_class(ClassType));
  static_assert(__is_class(HasAnonymousUnion));

  static_assert(!__is_class(int));
  static_assert(!__is_class(Enum));
  static_assert(!__is_class(Int));
  static_assert(!__is_class(IntAr));
  static_assert(!__is_class(DerivesAr));
  static_assert(!__is_class(Union));
  static_assert(!__is_class(cvoid));
  static_assert(!__is_class(IntArNB));
}

typedef Union UnionAr[10];
typedef Union UnionType;

void is_union()
{
  static_assert(__is_union(Union));
  static_assert(__is_union(UnionType));

  static_assert(!__is_union(int));
  static_assert(!__is_union(Enum));
  static_assert(!__is_union(Int));
  static_assert(!__is_union(IntAr));
  static_assert(!__is_union(UnionAr));
  static_assert(!__is_union(cvoid));
  static_assert(!__is_union(IntArNB));
  static_assert(!__is_union(HasAnonymousUnion));
}

typedef Enum EnumType;
typedef EnumClass EnumClassType;

void is_enum()
{
  static_assert(__is_enum(Enum));
  static_assert(__is_enum(EnumType));
  static_assert(__is_enum(SignedEnum));
  static_assert(__is_enum(UnsignedEnum));

  static_assert(__is_enum(EnumClass));
  static_assert(__is_enum(EnumClassType));
  static_assert(__is_enum(SignedEnumClass));
  static_assert(__is_enum(UnsignedEnumClass));

  static_assert(!__is_enum(int));
  static_assert(!__is_enum(Union));
  static_assert(!__is_enum(Int));
  static_assert(!__is_enum(IntAr));
  static_assert(!__is_enum(UnionAr));
  static_assert(!__is_enum(Derives));
  static_assert(!__is_enum(ClassType));
  static_assert(!__is_enum(cvoid));
  static_assert(!__is_enum(IntArNB));
  static_assert(!__is_enum(HasAnonymousUnion));
  static_assert(!__is_enum(AnIncompleteType));
  static_assert(!__is_enum(AnIncompleteTypeAr));
  static_assert(!__is_enum(AnIncompleteTypeArMB));
  static_assert(!__is_enum(AnIncompleteTypeArNB));
}

void is_scoped_enum() {
  static_assert(!__is_scoped_enum(Enum));
  static_assert(!__is_scoped_enum(EnumType));
  static_assert(!__is_scoped_enum(SignedEnum));
  static_assert(!__is_scoped_enum(UnsignedEnum));

  static_assert(__is_scoped_enum(EnumClass));
  static_assert(__is_scoped_enum(EnumClassType));
  static_assert(__is_scoped_enum(SignedEnumClass));
  static_assert(__is_scoped_enum(UnsignedEnumClass));

  static_assert(!__is_scoped_enum(int));
  static_assert(!__is_scoped_enum(Union));
  static_assert(!__is_scoped_enum(Int));
  static_assert(!__is_scoped_enum(IntAr));
  static_assert(!__is_scoped_enum(UnionAr));
  static_assert(!__is_scoped_enum(Derives));
  static_assert(!__is_scoped_enum(ClassType));
  static_assert(!__is_scoped_enum(cvoid));
  static_assert(!__is_scoped_enum(IntArNB));
  static_assert(!__is_scoped_enum(HasAnonymousUnion));
  static_assert(!__is_scoped_enum(AnIncompleteType));
  static_assert(!__is_scoped_enum(AnIncompleteTypeAr));
  static_assert(!__is_scoped_enum(AnIncompleteTypeArMB));
  static_assert(!__is_scoped_enum(AnIncompleteTypeArNB));
}

struct FinalClass final {
};

template<typename T>
struct PotentiallyFinal { };

template<typename T>
struct PotentiallyFinal<T*> final { };

template<>
struct PotentiallyFinal<int> final { };





void is_final()
{
	static_assert(__is_final(FinalClass));
	static_assert(__is_final(PotentiallyFinal<float*>));
	static_assert(__is_final(PotentiallyFinal<int>));

	static_assert(!__is_final(int));
	static_assert(!__is_final(Union));
	static_assert(!__is_final(Int));
	static_assert(!__is_final(IntAr));
	static_assert(!__is_final(UnionAr));
	static_assert(!__is_final(Derives));
	static_assert(!__is_final(ClassType));
	static_assert(!__is_final(cvoid));
	static_assert(!__is_final(IntArNB));
	static_assert(!__is_final(HasAnonymousUnion));
}


typedef HasVirt Polymorph;
struct InheritPolymorph : Polymorph {};

void is_polymorphic()
{
  static_assert(__is_polymorphic(Polymorph));
  static_assert(__is_polymorphic(InheritPolymorph));

  static_assert(!__is_polymorphic(int));
  static_assert(!__is_polymorphic(Union));
  static_assert(!__is_polymorphic(IncompleteUnion));
  static_assert(!__is_polymorphic(Int));
  static_assert(!__is_polymorphic(IntAr));
  static_assert(!__is_polymorphic(UnionAr));
  static_assert(!__is_polymorphic(Derives));
  static_assert(!__is_polymorphic(ClassType));
  static_assert(!__is_polymorphic(Enum));
  static_assert(!__is_polymorphic(cvoid));
  static_assert(!__is_polymorphic(IntArNB));
}

void is_integral()
{
  static_assert(__is_integral(bool));
  static_assert(__is_integral(char));
  static_assert(__is_integral(signed char));
  static_assert(__is_integral(unsigned char));
  //static_assert(__is_integral(char16_t));
  //static_assert(__is_integral(char32_t));
  static_assert(__is_integral(wchar_t));
  static_assert(__is_integral(short));
  static_assert(__is_integral(unsigned short));
  static_assert(__is_integral(int));
  static_assert(__is_integral(unsigned int));
  static_assert(__is_integral(long));
  static_assert(__is_integral(unsigned long));

  static_assert(!__is_integral(float));
  static_assert(!__is_integral(double));
  static_assert(!__is_integral(long double));
  static_assert(!__is_integral(Union));
  static_assert(!__is_integral(UnionAr));
  static_assert(!__is_integral(Derives));
  static_assert(!__is_integral(ClassType));
  static_assert(!__is_integral(Enum));
  static_assert(!__is_integral(void));
  static_assert(!__is_integral(cvoid));
  static_assert(!__is_integral(IntArNB));
}

void is_floating_point()
{
  static_assert(__is_floating_point(float));
  static_assert(__is_floating_point(double));
  static_assert(__is_floating_point(long double));

  static_assert(!__is_floating_point(bool));
  static_assert(!__is_floating_point(char));
  static_assert(!__is_floating_point(signed char));
  static_assert(!__is_floating_point(unsigned char));
  //static_assert(!__is_floating_point(char16_t));
  //static_assert(!__is_floating_point(char32_t));
  static_assert(!__is_floating_point(wchar_t));
  static_assert(!__is_floating_point(short));
  static_assert(!__is_floating_point(unsigned short));
  static_assert(!__is_floating_point(int));
  static_assert(!__is_floating_point(unsigned int));
  static_assert(!__is_floating_point(long));
  static_assert(!__is_floating_point(unsigned long));
  static_assert(!__is_floating_point(Union));
  static_assert(!__is_floating_point(UnionAr));
  static_assert(!__is_floating_point(Derives));
  static_assert(!__is_floating_point(ClassType));
  static_assert(!__is_floating_point(Enum));
  static_assert(!__is_floating_point(void));
  static_assert(!__is_floating_point(cvoid));
  static_assert(!__is_floating_point(IntArNB));
}

template <class T>
struct AggregateTemplate {
  T value;
};

template <class T>
struct NonAggregateTemplate {
  T value;
  NonAggregateTemplate();
};

void is_aggregate()
{
  constexpr bool TrueAfterCpp11 = __cplusplus > 201103L;
  constexpr bool TrueAfterCpp14 = __cplusplus > 201402L;

  __is_aggregate(AnIncompleteType); // expected-error {{incomplete type}}
  __is_aggregate(IncompleteUnion); // expected-error {{incomplete type}}

  // Valid since LWG3823
  static_assert(__is_aggregate(AnIncompleteType[]));
  static_assert(__is_aggregate(AnIncompleteType[1]));
  static_assert(__is_aggregate(AnIncompleteTypeAr));
  static_assert(__is_aggregate(AnIncompleteTypeArNB));
  static_assert(__is_aggregate(AnIncompleteTypeArMB));

  static_assert(!__is_aggregate(NonPOD));
  static_assert(__is_aggregate(NonPODAr));
  static_assert(__is_aggregate(NonPODArNB));
  static_assert(__is_aggregate(NonPODArMB));

  static_assert(!__is_aggregate(Enum));
  static_assert(__is_aggregate(POD));
  static_assert(__is_aggregate(Empty));
  static_assert(__is_aggregate(EmptyAr));
  static_assert(__is_aggregate(EmptyArNB));
  static_assert(__is_aggregate(EmptyArMB));
  static_assert(!__is_aggregate(void));
  static_assert(!__is_aggregate(const volatile void));
  static_assert(!__is_aggregate(int));
  static_assert(__is_aggregate(IntAr));
  static_assert(__is_aggregate(IntArNB));
  static_assert(__is_aggregate(EmptyUnion));
  static_assert(__is_aggregate(Union));
  static_assert(__is_aggregate(Statics));
  static_assert(__is_aggregate(HasFunc));
  static_assert(__is_aggregate(HasOp));
  static_assert(__is_aggregate(HasAssign));
  static_assert(__is_aggregate(HasAnonymousUnion));

  static_assert(__is_aggregate(Derives) == TrueAfterCpp14);
  static_assert(__is_aggregate(DerivesAr));
  static_assert(__is_aggregate(DerivesArNB));
  static_assert(!__is_aggregate(HasCons));
#if __cplusplus >= 202002L
  static_assert(!__is_aggregate(HasDefaultCons));
#else
  static_assert(__is_aggregate(HasDefaultCons));
#endif
  static_assert(!__is_aggregate(HasExplicitDefaultCons));
  static_assert(!__is_aggregate(HasInheritedCons));
  static_assert(__is_aggregate(HasNoInheritedCons) == TrueAfterCpp14);
  static_assert(__is_aggregate(HasCopyAssign));
  static_assert(!__is_aggregate(NonTrivialDefault));
  static_assert(__is_aggregate(HasDest));
  static_assert(!__is_aggregate(HasPriv));
  static_assert(!__is_aggregate(HasProt));
  static_assert(__is_aggregate(HasRefAggregate));
  static_assert(__is_aggregate(HasNonPOD));
  static_assert(!__is_aggregate(HasVirt));
  static_assert(__is_aggregate(VirtAr));
  static_assert(__is_aggregate(HasInClassInit) == TrueAfterCpp11);
  static_assert(!__is_aggregate(HasPrivateBase));
  static_assert(!__is_aggregate(HasProtectedBase));
  static_assert(!__is_aggregate(HasVirtBase));

  static_assert(__is_aggregate(AggregateTemplate<int>));
  static_assert(!__is_aggregate(NonAggregateTemplate<int>));

  static_assert(__is_aggregate(Vector)); // Extension supported by GCC and Clang
  static_assert(__is_aggregate(VectorExt));
  static_assert(__is_aggregate(ComplexInt));
  static_assert(__is_aggregate(ComplexFloat));
}

void is_arithmetic()
{
  static_assert(__is_arithmetic(float));
  static_assert(__is_arithmetic(double));
  static_assert(__is_arithmetic(long double));
  static_assert(__is_arithmetic(bool));
  static_assert(__is_arithmetic(char));
  static_assert(__is_arithmetic(signed char));
  static_assert(__is_arithmetic(unsigned char));
  //static_assert(__is_arithmetic(char16_t));
  //static_assert(__is_arithmetic(char32_t));
  static_assert(__is_arithmetic(wchar_t));
  static_assert(__is_arithmetic(short));
  static_assert(__is_arithmetic(unsigned short));
  static_assert(__is_arithmetic(int));
  static_assert(__is_arithmetic(unsigned int));
  static_assert(__is_arithmetic(long));
  static_assert(__is_arithmetic(unsigned long));

  static_assert(!__is_arithmetic(Union));
  static_assert(!__is_arithmetic(UnionAr));
  static_assert(!__is_arithmetic(Derives));
  static_assert(!__is_arithmetic(ClassType));
  static_assert(!__is_arithmetic(Enum));
  static_assert(!__is_arithmetic(void));
  static_assert(!__is_arithmetic(cvoid));
  static_assert(!__is_arithmetic(IntArNB));
}

void is_complete_type()
{
  static_assert(__is_complete_type(float));
  static_assert(__is_complete_type(double));
  static_assert(__is_complete_type(long double));
  static_assert(__is_complete_type(bool));
  static_assert(__is_complete_type(char));
  static_assert(__is_complete_type(signed char));
  static_assert(__is_complete_type(unsigned char));
  //static_assert(__is_complete_type(char16_t));
  //static_assert(__is_complete_type(char32_t));
  static_assert(__is_complete_type(wchar_t));
  static_assert(__is_complete_type(short));
  static_assert(__is_complete_type(unsigned short));
  static_assert(__is_complete_type(int));
  static_assert(__is_complete_type(unsigned int));
  static_assert(__is_complete_type(long));
  static_assert(__is_complete_type(unsigned long));
  static_assert(__is_complete_type(ACompleteType));

  static_assert(!__is_complete_type(AnIncompleteType));
}

void is_void()
{
  static_assert(__is_void(void));
  static_assert(__is_void(cvoid));

  static_assert(!__is_void(float));
  static_assert(!__is_void(double));
  static_assert(!__is_void(long double));
  static_assert(!__is_void(bool));
  static_assert(!__is_void(char));
  static_assert(!__is_void(signed char));
  static_assert(!__is_void(unsigned char));
  static_assert(!__is_void(wchar_t));
  static_assert(!__is_void(short));
  static_assert(!__is_void(unsigned short));
  static_assert(!__is_void(int));
  static_assert(!__is_void(unsigned int));
  static_assert(!__is_void(long));
  static_assert(!__is_void(unsigned long));
  static_assert(!__is_void(Union));
  static_assert(!__is_void(UnionAr));
  static_assert(!__is_void(Derives));
  static_assert(!__is_void(ClassType));
  static_assert(!__is_void(Enum));
  static_assert(!__is_void(IntArNB));
  static_assert(!__is_void(void*));
  static_assert(!__is_void(cvoid*));
}

void is_array()
{
  static_assert(__is_array(IntAr));
  static_assert(__is_array(IntArNB));
  static_assert(__is_array(UnionAr));

  static_assert(!__is_array(void));
  static_assert(!__is_array(cvoid));
  static_assert(!__is_array(float));
  static_assert(!__is_array(double));
  static_assert(!__is_array(long double));
  static_assert(!__is_array(bool));
  static_assert(!__is_array(char));
  static_assert(!__is_array(signed char));
  static_assert(!__is_array(unsigned char));
  static_assert(!__is_array(wchar_t));
  static_assert(!__is_array(short));
  static_assert(!__is_array(unsigned short));
  static_assert(!__is_array(int));
  static_assert(!__is_array(unsigned int));
  static_assert(!__is_array(long));
  static_assert(!__is_array(unsigned long));
  static_assert(!__is_array(Union));
  static_assert(!__is_array(Derives));
  static_assert(!__is_array(ClassType));
  static_assert(!__is_array(Enum));
  static_assert(!__is_array(void*));
  static_assert(!__is_array(cvoid*));
}

void is_bounded_array(int n) {
  static_assert(__is_bounded_array(IntAr));
  static_assert(!__is_bounded_array(IntArNB));
  static_assert(__is_bounded_array(UnionAr));

  static_assert(!__is_bounded_array(void));
  static_assert(!__is_bounded_array(cvoid));
  static_assert(!__is_bounded_array(float));
  static_assert(!__is_bounded_array(double));
  static_assert(!__is_bounded_array(long double));
  static_assert(!__is_bounded_array(bool));
  static_assert(!__is_bounded_array(char));
  static_assert(!__is_bounded_array(signed char));
  static_assert(!__is_bounded_array(unsigned char));
  static_assert(!__is_bounded_array(wchar_t));
  static_assert(!__is_bounded_array(short));
  static_assert(!__is_bounded_array(unsigned short));
  static_assert(!__is_bounded_array(int));
  static_assert(!__is_bounded_array(unsigned int));
  static_assert(!__is_bounded_array(long));
  static_assert(!__is_bounded_array(unsigned long));
  static_assert(!__is_bounded_array(Union));
  static_assert(!__is_bounded_array(Derives));
  static_assert(!__is_bounded_array(ClassType));
  static_assert(!__is_bounded_array(Enum));
  static_assert(!__is_bounded_array(void *));
  static_assert(!__is_bounded_array(cvoid *));

  int t32[n];
  (void)__is_bounded_array(decltype(t32)); // expected-error{{variable length arrays are not supported in '__is_bounded_array'}}
}

void is_unbounded_array(int n) {
  static_assert(!__is_unbounded_array(IntAr));
  static_assert(__is_unbounded_array(IntArNB));
  static_assert(!__is_unbounded_array(UnionAr));

  static_assert(!__is_unbounded_array(void));
  static_assert(!__is_unbounded_array(cvoid));
  static_assert(!__is_unbounded_array(float));
  static_assert(!__is_unbounded_array(double));
  static_assert(!__is_unbounded_array(long double));
  static_assert(!__is_unbounded_array(bool));
  static_assert(!__is_unbounded_array(char));
  static_assert(!__is_unbounded_array(signed char));
  static_assert(!__is_unbounded_array(unsigned char));
  static_assert(!__is_unbounded_array(wchar_t));
  static_assert(!__is_unbounded_array(short));
  static_assert(!__is_unbounded_array(unsigned short));
  static_assert(!__is_unbounded_array(int));
  static_assert(!__is_unbounded_array(unsigned int));
  static_assert(!__is_unbounded_array(long));
  static_assert(!__is_unbounded_array(unsigned long));
  static_assert(!__is_unbounded_array(Union));
  static_assert(!__is_unbounded_array(Derives));
  static_assert(!__is_unbounded_array(ClassType));
  static_assert(!__is_unbounded_array(Enum));
  static_assert(!__is_unbounded_array(void *));
  static_assert(!__is_unbounded_array(cvoid *));

  int t32[n];
  (void)__is_unbounded_array(decltype(t32)); // expected-error{{variable length arrays are not supported in '__is_unbounded_array'}}
}

void is_referenceable() {
  static_assert(__is_referenceable(int));
  static_assert(__is_referenceable(const int));
  static_assert(__is_referenceable(volatile int));
  static_assert(__is_referenceable(const volatile int));
  static_assert(__is_referenceable(int *));
  static_assert(__is_referenceable(int &));
  static_assert(__is_referenceable(int &&));
  static_assert(__is_referenceable(int (*)()));
  static_assert(__is_referenceable(int (&)()));
  static_assert(__is_referenceable(int(&&)()));
  static_assert(__is_referenceable(IntAr));
  static_assert(__is_referenceable(IntArNB));
  static_assert(__is_referenceable(decltype(nullptr)));
  static_assert(__is_referenceable(Empty));
  static_assert(__is_referenceable(Union));
  static_assert(__is_referenceable(Derives));
  static_assert(__is_referenceable(Enum));
  static_assert(__is_referenceable(EnumClass));
  static_assert(__is_referenceable(int Empty::*));
  static_assert(__is_referenceable(int(Empty::*)()));
  static_assert(__is_referenceable(AnIncompleteType));
  static_assert(__is_referenceable(struct AnIncompleteType));

  using function_type = void(int);
  static_assert(__is_referenceable(function_type));

  static_assert(!__is_referenceable(void));
}

template <typename T> void tmpl_func(T&) {}

template <typename T> struct type_wrapper {
  typedef T type;
  typedef T* ptrtype;
  typedef T& reftype;
};

void is_function()
{
  static_assert(__is_function(type_wrapper<void(void)>::type));
  static_assert(__is_function(typeof(tmpl_func<int>)));

  typedef void (*ptr_to_func_type)(void);

  static_assert(!__is_function(void));
  static_assert(!__is_function(cvoid));
  static_assert(!__is_function(float));
  static_assert(!__is_function(double));
  static_assert(!__is_function(long double));
  static_assert(!__is_function(bool));
  static_assert(!__is_function(char));
  static_assert(!__is_function(signed char));
  static_assert(!__is_function(unsigned char));
  static_assert(!__is_function(wchar_t));
  static_assert(!__is_function(short));
  static_assert(!__is_function(unsigned short));
  static_assert(!__is_function(int));
  static_assert(!__is_function(unsigned int));
  static_assert(!__is_function(long));
  static_assert(!__is_function(unsigned long));
  static_assert(!__is_function(Union));
  static_assert(!__is_function(Derives));
  static_assert(!__is_function(ClassType));
  static_assert(!__is_function(Enum));
  static_assert(!__is_function(void*));
  static_assert(!__is_function(cvoid*));
  static_assert(!__is_function(void(*)()));
  static_assert(!__is_function(ptr_to_func_type));
  static_assert(!__is_function(type_wrapper<void(void)>::ptrtype));
  static_assert(!__is_function(type_wrapper<void(void)>::reftype));
}

void is_reference()
{
  static_assert(__is_reference(int&));
  static_assert(__is_reference(const int&));
  static_assert(__is_reference(void *&));

  static_assert(!__is_reference(int));
  static_assert(!__is_reference(const int));
  static_assert(!__is_reference(void *));
}

void is_lvalue_reference()
{
  static_assert(__is_lvalue_reference(int&));
  static_assert(__is_lvalue_reference(void *&));
  static_assert(__is_lvalue_reference(const int&));
  static_assert(__is_lvalue_reference(void * const &));

  static_assert(!__is_lvalue_reference(int));
  static_assert(!__is_lvalue_reference(const int));
  static_assert(!__is_lvalue_reference(void *));
}

#if __has_feature(cxx_rvalue_references)

void is_rvalue_reference()
{
  static_assert(__is_rvalue_reference(const int&&));
  static_assert(__is_rvalue_reference(void * const &&));

  static_assert(!__is_rvalue_reference(int&));
  static_assert(!__is_rvalue_reference(void *&));
  static_assert(!__is_rvalue_reference(const int&));
  static_assert(!__is_rvalue_reference(void * const &));
  static_assert(!__is_rvalue_reference(int));
  static_assert(!__is_rvalue_reference(const int));
  static_assert(!__is_rvalue_reference(void *));
}

#endif

void is_fundamental()
{
  static_assert(__is_fundamental(float));
  static_assert(__is_fundamental(double));
  static_assert(__is_fundamental(long double));
  static_assert(__is_fundamental(bool));
  static_assert(__is_fundamental(char));
  static_assert(__is_fundamental(signed char));
  static_assert(__is_fundamental(unsigned char));
  //static_assert(__is_fundamental(char16_t));
  //static_assert(__is_fundamental(char32_t));
  static_assert(__is_fundamental(wchar_t));
  static_assert(__is_fundamental(short));
  static_assert(__is_fundamental(unsigned short));
  static_assert(__is_fundamental(int));
  static_assert(__is_fundamental(unsigned int));
  static_assert(__is_fundamental(long));
  static_assert(__is_fundamental(unsigned long));
  static_assert(__is_fundamental(void));
  static_assert(__is_fundamental(cvoid));
  static_assert(__is_fundamental(decltype(nullptr)));

  static_assert(!__is_fundamental(Union));
  static_assert(!__is_fundamental(UnionAr));
  static_assert(!__is_fundamental(Derives));
  static_assert(!__is_fundamental(ClassType));
  static_assert(!__is_fundamental(Enum));
  static_assert(!__is_fundamental(IntArNB));
}

void is_object()
{
  static_assert(__is_object(int));
  static_assert(__is_object(int *));
  static_assert(__is_object(void *));
  static_assert(__is_object(Union));
  static_assert(__is_object(UnionAr));
  static_assert(__is_object(ClassType));
  static_assert(__is_object(Enum));

  static_assert(!__is_object(type_wrapper<void(void)>::type));
  static_assert(!__is_object(int&));
  static_assert(!__is_object(void));
}

void is_scalar()
{
  static_assert(__is_scalar(float));
  static_assert(__is_scalar(double));
  static_assert(__is_scalar(long double));
  static_assert(__is_scalar(bool));
  static_assert(__is_scalar(char));
  static_assert(__is_scalar(signed char));
  static_assert(__is_scalar(unsigned char));
  static_assert(__is_scalar(wchar_t));
  static_assert(__is_scalar(short));
  static_assert(__is_scalar(unsigned short));
  static_assert(__is_scalar(int));
  static_assert(__is_scalar(unsigned int));
  static_assert(__is_scalar(long));
  static_assert(__is_scalar(unsigned long));
  static_assert(__is_scalar(Enum));
  static_assert(__is_scalar(void*));
  static_assert(__is_scalar(cvoid*));

  static_assert(!__is_scalar(void));
  static_assert(!__is_scalar(cvoid));
  static_assert(!__is_scalar(Union));
  static_assert(!__is_scalar(UnionAr));
  static_assert(!__is_scalar(Derives));
  static_assert(!__is_scalar(ClassType));
  static_assert(!__is_scalar(IntArNB));
}

struct StructWithMembers {
  int member;
  void method() {}
};

void is_compound()
{
  static_assert(__is_compound(void*));
  static_assert(__is_compound(cvoid*));
  static_assert(__is_compound(void (*)()));
  static_assert(__is_compound(int StructWithMembers::*));
  static_assert(__is_compound(void (StructWithMembers::*)()));
  static_assert(__is_compound(int&));
  static_assert(__is_compound(Union));
  static_assert(__is_compound(UnionAr));
  static_assert(__is_compound(Derives));
  static_assert(__is_compound(ClassType));
  static_assert(__is_compound(IntArNB));
  static_assert(__is_compound(Enum));

  static_assert(!__is_compound(float));
  static_assert(!__is_compound(double));
  static_assert(!__is_compound(long double));
  static_assert(!__is_compound(bool));
  static_assert(!__is_compound(char));
  static_assert(!__is_compound(signed char));
  static_assert(!__is_compound(unsigned char));
  static_assert(!__is_compound(wchar_t));
  static_assert(!__is_compound(short));
  static_assert(!__is_compound(unsigned short));
  static_assert(!__is_compound(int));
  static_assert(!__is_compound(unsigned int));
  static_assert(!__is_compound(long));
  static_assert(!__is_compound(unsigned long));
  static_assert(!__is_compound(void));
  static_assert(!__is_compound(cvoid));
}

void is_pointer()
{
  StructWithMembers x;

  static_assert(__is_pointer(void*));
  static_assert(__is_pointer(cvoid*));
  static_assert(__is_pointer(cvoid*));
  static_assert(__is_pointer(char*));
  static_assert(__is_pointer(int*));
  static_assert(__is_pointer(int**));
  static_assert(__is_pointer(ClassType*));
  static_assert(__is_pointer(Derives*));
  static_assert(__is_pointer(Enum*));
  static_assert(__is_pointer(IntArNB*));
  static_assert(__is_pointer(Union*));
  static_assert(__is_pointer(UnionAr*));
  static_assert(__is_pointer(StructWithMembers*));
  static_assert(__is_pointer(void (*)()));

  static_assert(!__is_pointer(void));
  static_assert(!__is_pointer(cvoid));
  static_assert(!__is_pointer(cvoid));
  static_assert(!__is_pointer(char));
  static_assert(!__is_pointer(int));
  static_assert(!__is_pointer(int));
  static_assert(!__is_pointer(ClassType));
  static_assert(!__is_pointer(Derives));
  static_assert(!__is_pointer(Enum));
  static_assert(!__is_pointer(IntArNB));
  static_assert(!__is_pointer(Union));
  static_assert(!__is_pointer(UnionAr));
  static_assert(!__is_pointer(StructWithMembers));
  static_assert(!__is_pointer(int StructWithMembers::*));
  static_assert(!__is_pointer(void (StructWithMembers::*) ()));
}

void is_null_pointer() {
  StructWithMembers x;

  static_assert(__is_nullptr(decltype(nullptr)));
  static_assert(!__is_nullptr(void *));
  static_assert(!__is_nullptr(cvoid *));
  static_assert(!__is_nullptr(cvoid *));
  static_assert(!__is_nullptr(char *));
  static_assert(!__is_nullptr(int *));
  static_assert(!__is_nullptr(int **));
  static_assert(!__is_nullptr(ClassType *));
  static_assert(!__is_nullptr(Derives *));
  static_assert(!__is_nullptr(Enum *));
  static_assert(!__is_nullptr(IntArNB *));
  static_assert(!__is_nullptr(Union *));
  static_assert(!__is_nullptr(UnionAr *));
  static_assert(!__is_nullptr(StructWithMembers *));
  static_assert(!__is_nullptr(void (*)()));

  static_assert(!__is_nullptr(void));
  static_assert(!__is_nullptr(cvoid));
  static_assert(!__is_nullptr(cvoid));
  static_assert(!__is_nullptr(char));
  static_assert(!__is_nullptr(int));
  static_assert(!__is_nullptr(int));
  static_assert(!__is_nullptr(ClassType));
  static_assert(!__is_nullptr(Derives));
  static_assert(!__is_nullptr(Enum));
  static_assert(!__is_nullptr(IntArNB));
  static_assert(!__is_nullptr(Union));
  static_assert(!__is_nullptr(UnionAr));
  static_assert(!__is_nullptr(StructWithMembers));
  static_assert(!__is_nullptr(int StructWithMembers::*));
  static_assert(!__is_nullptr(void(StructWithMembers::*)()));
}

void is_member_object_pointer()
{
  StructWithMembers x;

  static_assert(__is_member_object_pointer(int StructWithMembers::*));

  static_assert(!__is_member_object_pointer(void (StructWithMembers::*) ()));
  static_assert(!__is_member_object_pointer(void*));
  static_assert(!__is_member_object_pointer(cvoid*));
  static_assert(!__is_member_object_pointer(cvoid*));
  static_assert(!__is_member_object_pointer(char*));
  static_assert(!__is_member_object_pointer(int*));
  static_assert(!__is_member_object_pointer(int**));
  static_assert(!__is_member_object_pointer(ClassType*));
  static_assert(!__is_member_object_pointer(Derives*));
  static_assert(!__is_member_object_pointer(Enum*));
  static_assert(!__is_member_object_pointer(IntArNB*));
  static_assert(!__is_member_object_pointer(Union*));
  static_assert(!__is_member_object_pointer(UnionAr*));
  static_assert(!__is_member_object_pointer(StructWithMembers*));
  static_assert(!__is_member_object_pointer(void));
  static_assert(!__is_member_object_pointer(cvoid));
  static_assert(!__is_member_object_pointer(cvoid));
  static_assert(!__is_member_object_pointer(char));
  static_assert(!__is_member_object_pointer(int));
  static_assert(!__is_member_object_pointer(int));
  static_assert(!__is_member_object_pointer(ClassType));
  static_assert(!__is_member_object_pointer(Derives));
  static_assert(!__is_member_object_pointer(Enum));
  static_assert(!__is_member_object_pointer(IntArNB));
  static_assert(!__is_member_object_pointer(Union));
  static_assert(!__is_member_object_pointer(UnionAr));
  static_assert(!__is_member_object_pointer(StructWithMembers));
  static_assert(!__is_member_object_pointer(void (*)()));
}

void is_member_function_pointer()
{
  StructWithMembers x;

  static_assert(__is_member_function_pointer(void (StructWithMembers::*) ()));

  static_assert(!__is_member_function_pointer(int StructWithMembers::*));
  static_assert(!__is_member_function_pointer(void*));
  static_assert(!__is_member_function_pointer(cvoid*));
  static_assert(!__is_member_function_pointer(cvoid*));
  static_assert(!__is_member_function_pointer(char*));
  static_assert(!__is_member_function_pointer(int*));
  static_assert(!__is_member_function_pointer(int**));
  static_assert(!__is_member_function_pointer(ClassType*));
  static_assert(!__is_member_function_pointer(Derives*));
  static_assert(!__is_member_function_pointer(Enum*));
  static_assert(!__is_member_function_pointer(IntArNB*));
  static_assert(!__is_member_function_pointer(Union*));
  static_assert(!__is_member_function_pointer(UnionAr*));
  static_assert(!__is_member_function_pointer(StructWithMembers*));
  static_assert(!__is_member_function_pointer(void));
  static_assert(!__is_member_function_pointer(cvoid));
  static_assert(!__is_member_function_pointer(cvoid));
  static_assert(!__is_member_function_pointer(char));
  static_assert(!__is_member_function_pointer(int));
  static_assert(!__is_member_function_pointer(int));
  static_assert(!__is_member_function_pointer(ClassType));
  static_assert(!__is_member_function_pointer(Derives));
  static_assert(!__is_member_function_pointer(Enum));
  static_assert(!__is_member_function_pointer(IntArNB));
  static_assert(!__is_member_function_pointer(Union));
  static_assert(!__is_member_function_pointer(UnionAr));
  static_assert(!__is_member_function_pointer(StructWithMembers));
  static_assert(!__is_member_function_pointer(void (*)()));
}

void is_member_pointer()
{
  StructWithMembers x;

  static_assert(__is_member_pointer(int StructWithMembers::*));
  static_assert(__is_member_pointer(void (StructWithMembers::*) ()));

  static_assert(!__is_member_pointer(void*));
  static_assert(!__is_member_pointer(cvoid*));
  static_assert(!__is_member_pointer(cvoid*));
  static_assert(!__is_member_pointer(char*));
  static_assert(!__is_member_pointer(int*));
  static_assert(!__is_member_pointer(int**));
  static_assert(!__is_member_pointer(ClassType*));
  static_assert(!__is_member_pointer(Derives*));
  static_assert(!__is_member_pointer(Enum*));
  static_assert(!__is_member_pointer(IntArNB*));
  static_assert(!__is_member_pointer(Union*));
  static_assert(!__is_member_pointer(UnionAr*));
  static_assert(!__is_member_pointer(StructWithMembers*));
  static_assert(!__is_member_pointer(void));
  static_assert(!__is_member_pointer(cvoid));
  static_assert(!__is_member_pointer(cvoid));
  static_assert(!__is_member_pointer(char));
  static_assert(!__is_member_pointer(int));
  static_assert(!__is_member_pointer(int));
  static_assert(!__is_member_pointer(ClassType));
  static_assert(!__is_member_pointer(Derives));
  static_assert(!__is_member_pointer(Enum));
  static_assert(!__is_member_pointer(IntArNB));
  static_assert(!__is_member_pointer(Union));
  static_assert(!__is_member_pointer(UnionAr));
  static_assert(!__is_member_pointer(StructWithMembers));
  static_assert(!__is_member_pointer(void (*)()));
}

void is_const()
{
  static_assert(__is_const(cvoid));
  static_assert(__is_const(const char));
  static_assert(__is_const(const int));
  static_assert(__is_const(const long));
  static_assert(__is_const(const short));
  static_assert(__is_const(const signed char));
  static_assert(__is_const(const wchar_t));
  static_assert(__is_const(const bool));
  static_assert(__is_const(const float));
  static_assert(__is_const(const double));
  static_assert(__is_const(const long double));
  static_assert(__is_const(const unsigned char));
  static_assert(__is_const(const unsigned int));
  static_assert(__is_const(const unsigned long long));
  static_assert(__is_const(const unsigned long));
  static_assert(__is_const(const unsigned short));
  static_assert(__is_const(const void));
  static_assert(__is_const(const ClassType));
  static_assert(__is_const(const Derives));
  static_assert(__is_const(const Enum));
  static_assert(__is_const(const IntArNB));
  static_assert(__is_const(const Union));
  static_assert(__is_const(const UnionAr));

  static_assert(!__is_const(char));
  static_assert(!__is_const(int));
  static_assert(!__is_const(long));
  static_assert(!__is_const(short));
  static_assert(!__is_const(signed char));
  static_assert(!__is_const(wchar_t));
  static_assert(!__is_const(bool));
  static_assert(!__is_const(float));
  static_assert(!__is_const(double));
  static_assert(!__is_const(long double));
  static_assert(!__is_const(unsigned char));
  static_assert(!__is_const(unsigned int));
  static_assert(!__is_const(unsigned long long));
  static_assert(!__is_const(unsigned long));
  static_assert(!__is_const(unsigned short));
  static_assert(!__is_const(void));
  static_assert(!__is_const(ClassType));
  static_assert(!__is_const(Derives));
  static_assert(!__is_const(Enum));
  static_assert(!__is_const(IntArNB));
  static_assert(!__is_const(Union));
  static_assert(!__is_const(UnionAr));
}

void is_volatile()
{
  static_assert(__is_volatile(volatile char));
  static_assert(__is_volatile(volatile int));
  static_assert(__is_volatile(volatile long));
  static_assert(__is_volatile(volatile short));
  static_assert(__is_volatile(volatile signed char));
  static_assert(__is_volatile(volatile wchar_t));
  static_assert(__is_volatile(volatile bool));
  static_assert(__is_volatile(volatile float));
  static_assert(__is_volatile(volatile double));
  static_assert(__is_volatile(volatile long double));
  static_assert(__is_volatile(volatile unsigned char));
  static_assert(__is_volatile(volatile unsigned int));
  static_assert(__is_volatile(volatile unsigned long long));
  static_assert(__is_volatile(volatile unsigned long));
  static_assert(__is_volatile(volatile unsigned short));
  static_assert(__is_volatile(volatile void));
  static_assert(__is_volatile(volatile ClassType));
  static_assert(__is_volatile(volatile Derives));
  static_assert(__is_volatile(volatile Enum));
  static_assert(__is_volatile(volatile IntArNB));
  static_assert(__is_volatile(volatile Union));
  static_assert(__is_volatile(volatile UnionAr));

  static_assert(!__is_volatile(char));
  static_assert(!__is_volatile(int));
  static_assert(!__is_volatile(long));
  static_assert(!__is_volatile(short));
  static_assert(!__is_volatile(signed char));
  static_assert(!__is_volatile(wchar_t));
  static_assert(!__is_volatile(bool));
  static_assert(!__is_volatile(float));
  static_assert(!__is_volatile(double));
  static_assert(!__is_volatile(long double));
  static_assert(!__is_volatile(unsigned char));
  static_assert(!__is_volatile(unsigned int));
  static_assert(!__is_volatile(unsigned long long));
  static_assert(!__is_volatile(unsigned long));
  static_assert(!__is_volatile(unsigned short));
  static_assert(!__is_volatile(void));
  static_assert(!__is_volatile(ClassType));
  static_assert(!__is_volatile(Derives));
  static_assert(!__is_volatile(Enum));
  static_assert(!__is_volatile(IntArNB));
  static_assert(!__is_volatile(Union));
  static_assert(!__is_volatile(UnionAr));
}

struct TrivialStruct {
  int member;
};

struct NonTrivialStruct {
  int member;
  NonTrivialStruct() {
    member = 0;
  }
};

struct SuperNonTrivialStruct {
  SuperNonTrivialStruct() { }
  ~SuperNonTrivialStruct() { }
};

struct NonTCStruct {
  NonTCStruct(const NonTCStruct&) {}
};

struct AllDefaulted {
  AllDefaulted() = default;
  AllDefaulted(const AllDefaulted &) = default;
  AllDefaulted(AllDefaulted &&) = default;
  AllDefaulted &operator=(const AllDefaulted &) = default;
  AllDefaulted &operator=(AllDefaulted &&) = default;
  ~AllDefaulted() = default;
};

struct NoDefaultMoveAssignDueToUDCopyCtor {
  NoDefaultMoveAssignDueToUDCopyCtor(const NoDefaultMoveAssignDueToUDCopyCtor&);
};

struct NoDefaultMoveAssignDueToUDCopyAssign {
  NoDefaultMoveAssignDueToUDCopyAssign& operator=(
    const NoDefaultMoveAssignDueToUDCopyAssign&);
};

struct NoDefaultMoveAssignDueToDtor {
  ~NoDefaultMoveAssignDueToDtor();
};

struct AllDeleted {
  AllDeleted() = delete;
  AllDeleted(const AllDeleted &) = delete;
  AllDeleted(AllDeleted &&) = delete;
  AllDeleted &operator=(const AllDeleted &) = delete;
  AllDeleted &operator=(AllDeleted &&) = delete;
  ~AllDeleted() = delete;
};

struct ExtDefaulted {
  ExtDefaulted();
  ExtDefaulted(const ExtDefaulted &);
  ExtDefaulted(ExtDefaulted &&);
  ExtDefaulted &operator=(const ExtDefaulted &);
  ExtDefaulted &operator=(ExtDefaulted &&);
  ~ExtDefaulted();
};

// Despite being defaulted, these functions are not trivial.
ExtDefaulted::ExtDefaulted() = default;
ExtDefaulted::ExtDefaulted(const ExtDefaulted &) = default;
ExtDefaulted::ExtDefaulted(ExtDefaulted &&) = default;
ExtDefaulted &ExtDefaulted::operator=(const ExtDefaulted &) = default;
ExtDefaulted &ExtDefaulted::operator=(ExtDefaulted &&) = default;
ExtDefaulted::~ExtDefaulted() = default;

void is_trivial2()
{
  static_assert(__is_trivial(char));
  static_assert(__is_trivial(int));
  static_assert(__is_trivial(long));
  static_assert(__is_trivial(short));
  static_assert(__is_trivial(signed char));
  static_assert(__is_trivial(wchar_t));
  static_assert(__is_trivial(bool));
  static_assert(__is_trivial(float));
  static_assert(__is_trivial(double));
  static_assert(__is_trivial(long double));
  static_assert(__is_trivial(unsigned char));
  static_assert(__is_trivial(unsigned int));
  static_assert(__is_trivial(unsigned long long));
  static_assert(__is_trivial(unsigned long));
  static_assert(__is_trivial(unsigned short));
  static_assert(__is_trivial(ClassType));
  static_assert(__is_trivial(Derives));
  static_assert(__is_trivial(Enum));
  static_assert(__is_trivial(IntAr));
  static_assert(__is_trivial(Union));
  static_assert(__is_trivial(UnionAr));
  static_assert(__is_trivial(TrivialStruct));
  static_assert(__is_trivial(AllDefaulted));
  static_assert(__is_trivial(AllDeleted));

  static_assert(!__is_trivial(void));
  static_assert(!__is_trivial(NonTrivialStruct));
  static_assert(!__is_trivial(SuperNonTrivialStruct));
  static_assert(!__is_trivial(NonTCStruct));
  static_assert(!__is_trivial(ExtDefaulted));

  static_assert(__is_trivial(ACompleteType));
  static_assert(!__is_trivial(AnIncompleteType)); // expected-error {{incomplete type}}
  static_assert(!__is_trivial(AnIncompleteType[])); // expected-error {{incomplete type}}
  static_assert(!__is_trivial(AnIncompleteType[1])); // expected-error {{incomplete type}}
  static_assert(!__is_trivial(void));
  static_assert(!__is_trivial(const volatile void));
}

void is_trivially_copyable2()
{
  static_assert(__is_trivially_copyable(char));
  static_assert(__is_trivially_copyable(int));
  static_assert(__is_trivially_copyable(long));
  static_assert(__is_trivially_copyable(short));
  static_assert(__is_trivially_copyable(signed char));
  static_assert(__is_trivially_copyable(wchar_t));
  static_assert(__is_trivially_copyable(bool));
  static_assert(__is_trivially_copyable(float));
  static_assert(__is_trivially_copyable(double));
  static_assert(__is_trivially_copyable(long double));
  static_assert(__is_trivially_copyable(unsigned char));
  static_assert(__is_trivially_copyable(unsigned int));
  static_assert(__is_trivially_copyable(unsigned long long));
  static_assert(__is_trivially_copyable(unsigned long));
  static_assert(__is_trivially_copyable(unsigned short));
  static_assert(__is_trivially_copyable(ClassType));
  static_assert(__is_trivially_copyable(Derives));
  static_assert(__is_trivially_copyable(Enum));
  static_assert(__is_trivially_copyable(IntAr));
  static_assert(__is_trivially_copyable(Union));
  static_assert(__is_trivially_copyable(UnionAr));
  static_assert(__is_trivially_copyable(TrivialStruct));
  static_assert(__is_trivially_copyable(NonTrivialStruct));
  static_assert(__is_trivially_copyable(AllDefaulted));
  static_assert(__is_trivially_copyable(AllDeleted));

  static_assert(!__is_trivially_copyable(void));
  static_assert(!__is_trivially_copyable(SuperNonTrivialStruct));
  static_assert(!__is_trivially_copyable(NonTCStruct));
  static_assert(!__is_trivially_copyable(ExtDefaulted));

  static_assert(__is_trivially_copyable(const int));
  static_assert(__is_trivially_copyable(volatile int));

  static_assert(__is_trivially_copyable(ACompleteType));
  static_assert(!__is_trivially_copyable(AnIncompleteType)); // expected-error {{incomplete type}}
  static_assert(!__is_trivially_copyable(AnIncompleteType[])); // expected-error {{incomplete type}}
  static_assert(!__is_trivially_copyable(AnIncompleteType[1])); // expected-error {{incomplete type}}
  static_assert(!__is_trivially_copyable(void));
  static_assert(!__is_trivially_copyable(const volatile void));
}

struct CStruct {
  int one;
  int two;
};

struct CEmptyStruct {};

struct CppEmptyStruct : CStruct {};
struct CppStructStandard : CEmptyStruct {
  int three;
  int four;
};
struct CppStructNonStandardByBase : CStruct {
  int three;
  int four;
};
struct CppStructNonStandardByVirt : CStruct {
  virtual void method() {}
};
struct CppStructNonStandardByMemb : CStruct {
  CppStructNonStandardByVirt member;
};
struct CppStructNonStandardByProt : CStruct {
  int five;
protected:
  int six;
};
struct CppStructNonStandardByVirtBase : virtual CStruct {
};
struct CppStructNonStandardBySameBase : CEmptyStruct {
  CEmptyStruct member;
};
struct CppStructNonStandardBy2ndVirtBase : CEmptyStruct {
  CEmptyStruct member;
};

void is_standard_layout()
{
  typedef const int ConstInt;
  typedef ConstInt ConstIntAr[4];
  typedef CppStructStandard CppStructStandardAr[4];

  static_assert(__is_standard_layout(int));
  static_assert(__is_standard_layout(ConstInt));
  static_assert(__is_standard_layout(ConstIntAr));
  static_assert(__is_standard_layout(CStruct));
  static_assert(__is_standard_layout(CppStructStandard));
  static_assert(__is_standard_layout(CppStructStandardAr));
  static_assert(__is_standard_layout(Vector));
  static_assert(__is_standard_layout(VectorExt));

  typedef CppStructNonStandardByBase CppStructNonStandardByBaseAr[4];

  static_assert(!__is_standard_layout(CppStructNonStandardByVirt));
  static_assert(!__is_standard_layout(CppStructNonStandardByMemb));
  static_assert(!__is_standard_layout(CppStructNonStandardByProt));
  static_assert(!__is_standard_layout(CppStructNonStandardByVirtBase));
  static_assert(!__is_standard_layout(CppStructNonStandardByBase));
  static_assert(!__is_standard_layout(CppStructNonStandardByBaseAr));
  static_assert(!__is_standard_layout(CppStructNonStandardBySameBase));
  static_assert(!__is_standard_layout(CppStructNonStandardBy2ndVirtBase));

  static_assert(__is_standard_layout(ACompleteType));
  static_assert(!__is_standard_layout(AnIncompleteType)); // expected-error {{incomplete type}}
  static_assert(!__is_standard_layout(AnIncompleteType[])); // expected-error {{incomplete type}}
  static_assert(!__is_standard_layout(AnIncompleteType[1])); // expected-error {{incomplete type}}
  static_assert(!__is_standard_layout(void));
  static_assert(!__is_standard_layout(const volatile void));

  struct HasAnonEmptyBitfield { int : 0; };
  struct HasAnonBitfield { int : 4; };
  struct DerivesFromBitfield : HasAnonBitfield {};
  struct DerivesFromBitfieldWithBitfield : HasAnonBitfield { int : 5; };
  struct DerivesFromBitfieldTwice : DerivesFromBitfield, HasAnonEmptyBitfield {};

  static_assert(__is_standard_layout(HasAnonEmptyBitfield));
  static_assert(__is_standard_layout(HasAnonBitfield));
  static_assert(__is_standard_layout(DerivesFromBitfield));
  static_assert(!__is_standard_layout(DerivesFromBitfieldWithBitfield));
  static_assert(!__is_standard_layout(DerivesFromBitfieldTwice));

  struct Empty {};
  struct HasEmptyBase : Empty {};
  struct HoldsEmptyBase { Empty e; };
  struct HasRepeatedEmptyBase : Empty, HasEmptyBase {}; // expected-warning {{inaccessible}}
  struct HasEmptyBaseAsMember : Empty { Empty e; };
  struct HasEmptyBaseAsSubobjectOfMember1 : Empty { HoldsEmptyBase e; };
  struct HasEmptyBaseAsSubobjectOfMember2 : Empty { HasEmptyBase e; };
  struct HasEmptyBaseAsSubobjectOfMember3 : Empty { HoldsEmptyBase e[2]; };
  struct HasEmptyIndirectBaseAsMember : HasEmptyBase { Empty e; };
  struct HasEmptyIndirectBaseAsSecondMember : HasEmptyBase { int n; Empty e; };
  struct HasEmptyIndirectBaseAfterBitfield : HasEmptyBase { int : 4; Empty e; };

  static_assert(__is_standard_layout(Empty));
  static_assert(__is_standard_layout(HasEmptyBase));
  static_assert(!__is_standard_layout(HasRepeatedEmptyBase));
  static_assert(!__is_standard_layout(HasEmptyBaseAsMember));
  static_assert(!__is_standard_layout(HasEmptyBaseAsSubobjectOfMember1));
  static_assert(__is_standard_layout(HasEmptyBaseAsSubobjectOfMember2)); // FIXME: standard bug?
  static_assert(!__is_standard_layout(HasEmptyBaseAsSubobjectOfMember3));
  static_assert(!__is_standard_layout(HasEmptyIndirectBaseAsMember));
  static_assert(__is_standard_layout(HasEmptyIndirectBaseAsSecondMember));
  static_assert(!__is_standard_layout(HasEmptyIndirectBaseAfterBitfield)); // FIXME: standard bug?

  struct StructWithEmptyFields {
    int n;
    HoldsEmptyBase e[3];
  };
  union UnionWithEmptyFields {
    int n;
    HoldsEmptyBase e[3];
  };
  struct HasEmptyIndirectBaseAsSecondStructMember : HasEmptyBase {
    StructWithEmptyFields u;
  };
  struct HasEmptyIndirectBaseAsSecondUnionMember : HasEmptyBase {
    UnionWithEmptyFields u;
  };

  static_assert(__is_standard_layout(HasEmptyIndirectBaseAsSecondStructMember));
  static_assert(!__is_standard_layout(HasEmptyIndirectBaseAsSecondUnionMember));
}

struct CStruct2 {
  int one;
  int two;
};

struct CEmptyStruct2 {};

struct CppEmptyStruct2 : CStruct2 {};
struct CppStructStandard2 : CEmptyStruct2 {
  int three;
  int four;
};
struct CppStructNonStandardByBase2 : CStruct2 {
  int three;
  int four;
};
struct CppStructNonStandardByVirt2 : CStruct2 {
  virtual void method() {}
};
struct CppStructNonStandardByMemb2 : CStruct2 {
  CppStructNonStandardByVirt member;
};
struct CppStructNonStandardByProt2 : CStruct2 {
  int five;
protected:
  int six;
};
struct CppStructNonStandardByVirtBase2 : virtual CStruct2 {
};
struct CppStructNonStandardBySameBase2 : CEmptyStruct2 {
  CEmptyStruct member;
};
struct CppStructNonStandardBy2ndVirtBase2 : CEmptyStruct2 {
  CEmptyStruct member;
};

struct CStructWithQualifiers {
  const int one;
  volatile int two;
};

struct CStructNoUniqueAddress {
  int one;
  [[no_unique_address]] int two;
};

struct CStructNoUniqueAddress2 {
  int one;
  [[no_unique_address]] int two;
};

struct alignas(64) CStructAlignment {
  int one;
  int two;
};

struct CStructAlignedMembers {
  int one;
  alignas(16) int two;
};

enum EnumLayout : int {};
enum class EnumClassLayout {};
enum EnumForward : int;
enum class EnumClassForward;

struct CStructIncomplete; // #CStructIncomplete

struct CStructNested {
  int a;
  CStruct s;
  int b;
};

struct CStructNested2 {
  int a2;
  CStruct s2;
  int b2;
};

struct CStructWithBitfelds {
  int a : 5;
  int : 0;
};

struct CStructWithBitfelds2 {
  int a : 5;
  int : 0;
};

struct CStructWithBitfelds3 {
  int : 0;
  int b : 5;
};

struct CStructWithBitfelds4 {
  EnumLayout a : 5;
  int : 0;
};

union UnionLayout {
  int a;
  double b;
  CStruct c;
  [[no_unique_address]] CEmptyStruct d;
  [[no_unique_address]] CEmptyStruct2 e;
};

union UnionLayout2 {
  CStruct c;
  int a;
  CEmptyStruct2 e;
  double b;
  [[no_unique_address]] CEmptyStruct d;
};

union UnionLayout3 {
  CStruct c;
  int a;
  double b;
  [[no_unique_address]] CEmptyStruct d;
};

union UnionNoOveralignedMembers {
  int a;
  double b;
};

union UnionWithOveralignedMembers {
  int a;
  alignas(16) double b;
};

struct StructWithAnonUnion {
  union {
    int a;
    double b;
    CStruct c;
    [[no_unique_address]] CEmptyStruct d;
    [[no_unique_address]] CEmptyStruct2 e;
  };
};

struct StructWithAnonUnion2 {
  union {
    CStruct c;
    int a;
    CEmptyStruct2 e;
    double b;
    [[no_unique_address]] CEmptyStruct d;
  };
};

struct StructWithAnonUnion3 {
  union {
    CStruct c;
    int a;
    CEmptyStruct2 e;
    double b;
    [[no_unique_address]] CEmptyStruct d;
  } u;
};

struct CStructWithArrayAtTheEnd {
  int a;
  int b[4];
};

struct CStructWithFMA {
  int c;
  int d[];
};

struct CStructWithFMA2 {
  int e;
  int f[];
};

void is_layout_compatible(int n)
{
  static_assert(__is_layout_compatible(void, void));
  static_assert(!__is_layout_compatible(void, int));
  static_assert(__is_layout_compatible(void, const void));
  static_assert(__is_layout_compatible(void, volatile void));
  static_assert(__is_layout_compatible(const void, volatile void));
  static_assert(__is_layout_compatible(int, int));
  static_assert(__is_layout_compatible(int, const int));
  static_assert(__is_layout_compatible(int, volatile int));
  static_assert(__is_layout_compatible(const int, volatile int));
  static_assert(__is_layout_compatible(int *, int * __restrict));
  // Note: atomic qualification matters for layout compatibility.
  static_assert(!__is_layout_compatible(int, _Atomic int));
  static_assert(__is_layout_compatible(_Atomic(int), _Atomic int));
  static_assert(!__is_layout_compatible(int, unsigned int));
  static_assert(!__is_layout_compatible(char, unsigned char));
  static_assert(!__is_layout_compatible(char, signed char));
  static_assert(!__is_layout_compatible(unsigned char, signed char));
  static_assert(__is_layout_compatible(int[], int[]));
  static_assert(__is_layout_compatible(int[2], int[2]));
  static_assert(!__is_layout_compatible(int[n], int[2]));
  // expected-error@-1 {{variable length arrays are not supported in '__is_layout_compatible'}}
  static_assert(!__is_layout_compatible(int[n], int[n]));
  // expected-error@-1 {{variable length arrays are not supported in '__is_layout_compatible'}}
  // expected-error@-2 {{variable length arrays are not supported in '__is_layout_compatible'}}
  static_assert(__is_layout_compatible(int&, int&));
  static_assert(!__is_layout_compatible(int&, char&));
  static_assert(__is_layout_compatible(void(int), void(int)));
  static_assert(!__is_layout_compatible(void(int), void(char)));
  static_assert(__is_layout_compatible(void(&)(int), void(&)(int)));
  static_assert(!__is_layout_compatible(void(&)(int), void(&)(char)));
  static_assert(__is_layout_compatible(void(*)(int), void(*)(int)));
  static_assert(!__is_layout_compatible(void(*)(int), void(*)(char)));
  using function_type = void();
  using function_type2 = void(char);
  static_assert(__is_layout_compatible(const function_type, const function_type));
  // expected-warning@-1 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}}
  // expected-warning@-2 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}}
  static_assert(__is_layout_compatible(function_type, const function_type));
  // expected-warning@-1 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}}
  static_assert(!__is_layout_compatible(const function_type, const function_type2));
  // expected-warning@-1 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}}
  // expected-warning@-2 {{'const' qualifier on function type 'function_type2' (aka 'void (char)') has no effect}}
  static_assert(__is_layout_compatible(CStruct, CStruct2));
  static_assert(__is_layout_compatible(CStruct, const CStruct2));
  static_assert(__is_layout_compatible(CStruct, volatile CStruct2));
  static_assert(__is_layout_compatible(const CStruct, volatile CStruct2));
  static_assert(__is_layout_compatible(CEmptyStruct, CEmptyStruct2));
  static_assert(__is_layout_compatible(CppEmptyStruct, CppEmptyStruct2));
  static_assert(__is_layout_compatible(CppStructStandard, CppStructStandard2));
  static_assert(!__is_layout_compatible(CppStructNonStandardByBase, CppStructNonStandardByBase2));
  static_assert(!__is_layout_compatible(CppStructNonStandardByVirt, CppStructNonStandardByVirt2));
  static_assert(!__is_layout_compatible(CppStructNonStandardByMemb, CppStructNonStandardByMemb2));
  static_assert(!__is_layout_compatible(CppStructNonStandardByProt, CppStructNonStandardByProt2));
  static_assert(!__is_layout_compatible(CppStructNonStandardByVirtBase, CppStructNonStandardByVirtBase2));
  static_assert(!__is_layout_compatible(CppStructNonStandardBySameBase, CppStructNonStandardBySameBase2));
  static_assert(!__is_layout_compatible(CppStructNonStandardBy2ndVirtBase, CppStructNonStandardBy2ndVirtBase2));
  static_assert(__is_layout_compatible(CStruct, CStructWithQualifiers));
  static_assert(__is_layout_compatible(CStruct, CStructNoUniqueAddress) != bool(__has_cpp_attribute(no_unique_address)));
  static_assert(__is_layout_compatible(CStructNoUniqueAddress, CStructNoUniqueAddress2) != bool(__has_cpp_attribute(no_unique_address)));
  static_assert(__is_layout_compatible(CStruct, CStructAlignment));
  static_assert(!__is_layout_compatible(CStruct, CStructAlignedMembers));
  static_assert(__is_layout_compatible(UnionNoOveralignedMembers, UnionWithOveralignedMembers));
  static_assert(__is_layout_compatible(CStructWithBitfelds, CStructWithBitfelds));
  static_assert(__is_layout_compatible(CStructWithBitfelds, CStructWithBitfelds2));
  static_assert(!__is_layout_compatible(CStructWithBitfelds, CStructWithBitfelds3));
  static_assert(!__is_layout_compatible(CStructWithBitfelds, CStructWithBitfelds4));
  static_assert(__is_layout_compatible(int CStruct2::*, int CStruct2::*));
  static_assert(!__is_layout_compatible(int CStruct2::*, char CStruct2::*));
  static_assert(__is_layout_compatible(void(CStruct2::*)(int), void(CStruct2::*)(int)));
  static_assert(!__is_layout_compatible(void(CStruct2::*)(int), void(CStruct2::*)(char)));
  static_assert(__is_layout_compatible(CStructNested, CStructNested2));
  static_assert(__is_layout_compatible(UnionLayout, UnionLayout));
  static_assert(!__is_layout_compatible(UnionLayout, UnionLayout2));
  static_assert(!__is_layout_compatible(UnionLayout, UnionLayout3));
  static_assert(!__is_layout_compatible(StructWithAnonUnion, StructWithAnonUnion2));
  static_assert(!__is_layout_compatible(StructWithAnonUnion, StructWithAnonUnion3));
  static_assert(__is_layout_compatible(EnumLayout, EnumClassLayout));
  static_assert(__is_layout_compatible(EnumForward, EnumForward));
  static_assert(__is_layout_compatible(EnumForward, EnumClassForward));
  static_assert(__is_layout_compatible(CStructIncomplete, CStructIncomplete));
  // expected-error@-1 {{incomplete type 'CStructIncomplete' where a complete type is required}}
  //   expected-note@#CStructIncomplete {{forward declaration of 'CStructIncomplete'}}
  // expected-error@-3 {{incomplete type 'CStructIncomplete' where a complete type is required}}
  //   expected-note@#CStructIncomplete {{forward declaration of 'CStructIncomplete'}}
  static_assert(!__is_layout_compatible(CStruct, CStructIncomplete));
  // expected-error@-1 {{incomplete type 'CStructIncomplete' where a complete type is required}}
  //   expected-note@#CStructIncomplete {{forward declaration of 'CStructIncomplete'}}
  static_assert(__is_layout_compatible(CStructIncomplete[2], CStructIncomplete[2]));
  // expected-error@-1 {{incomplete type 'CStructIncomplete[2]' where a complete type is required}}
  //   expected-note@#CStructIncomplete {{forward declaration of 'CStructIncomplete'}}
  // expected-error@-3 {{incomplete type 'CStructIncomplete[2]' where a complete type is required}}
  //   expected-note@#CStructIncomplete {{forward declaration of 'CStructIncomplete'}}
  static_assert(__is_layout_compatible(CStructIncomplete[], CStructIncomplete[]));
  static_assert(!__is_layout_compatible(CStructWithArrayAtTheEnd, CStructWithFMA));
  static_assert(__is_layout_compatible(CStructWithFMA, CStructWithFMA));
  static_assert(__is_layout_compatible(CStructWithFMA, CStructWithFMA2));
  // Layout compatibility rules for enums might be relaxed in the future. See https://github.com/cplusplus/CWG/issues/39#issuecomment-1184791364
  static_assert(!__is_layout_compatible(EnumLayout, int));
  static_assert(!__is_layout_compatible(EnumClassLayout, int));
  static_assert(!__is_layout_compatible(EnumForward, int));
  static_assert(!__is_layout_compatible(EnumClassForward, int));
}

namespace IPIBO {
struct Base {};
struct Base2 {};
struct Base3 : Base {};
struct Base3Virtual : virtual Base {};
struct Derived : Base {};
struct DerivedIndirect : Base3 {};
struct DerivedMultiple : Base, Base2 {};
struct DerivedAmbiguous : Base, Base3 {};
/* expected-warning@-1 {{direct base 'Base' is inaccessible due to ambiguity:
    struct IPIBO::DerivedAmbiguous -> Base
    struct IPIBO::DerivedAmbiguous -> Base3 -> Base}} */
struct DerivedPrivate : private Base {};
struct DerivedVirtual : virtual Base {};

union Union {};
union UnionIncomplete;
struct StructIncomplete; // #StructIncomplete

void is_pointer_interconvertible_base_of(int n)
{
  static_assert(__is_pointer_interconvertible_base_of(Base, Derived));
  static_assert(!__is_pointer_interconvertible_base_of(Base2, Derived));
  static_assert(__is_pointer_interconvertible_base_of(Base, DerivedIndirect));
  static_assert(__is_pointer_interconvertible_base_of(Base, DerivedMultiple));
  static_assert(__is_pointer_interconvertible_base_of(Base2, DerivedMultiple));
  static_assert(!__is_pointer_interconvertible_base_of(Base3, DerivedMultiple));
  static_assert(!__is_pointer_interconvertible_base_of(Base, DerivedAmbiguous));
  static_assert(__is_pointer_interconvertible_base_of(Base, DerivedPrivate));
  static_assert(!__is_pointer_interconvertible_base_of(Base, DerivedVirtual));
  static_assert(!__is_pointer_interconvertible_base_of(Union, Union));
  static_assert(!__is_pointer_interconvertible_base_of(UnionIncomplete, UnionIncomplete));
  static_assert(__is_pointer_interconvertible_base_of(StructIncomplete, StructIncomplete));
  static_assert(__is_pointer_interconvertible_base_of(StructIncomplete, const StructIncomplete));
  static_assert(__is_pointer_interconvertible_base_of(StructIncomplete, volatile StructIncomplete));
  static_assert(__is_pointer_interconvertible_base_of(const StructIncomplete, volatile StructIncomplete));
  static_assert(!__is_pointer_interconvertible_base_of(StructIncomplete, Derived));
  static_assert(!__is_pointer_interconvertible_base_of(Base, StructIncomplete));
  // expected-error@-1 {{incomplete type 'StructIncomplete' where a complete type is required}}
  //   expected-note@#StructIncomplete {{forward declaration of 'IPIBO::StructIncomplete'}}
  static_assert(!__is_pointer_interconvertible_base_of(CStruct2, CppStructNonStandardByBase2));
  static_assert(!__is_pointer_interconvertible_base_of(void, void));
  static_assert(!__is_pointer_interconvertible_base_of(void, int));
  static_assert(!__is_pointer_interconvertible_base_of(void, const void));
  static_assert(!__is_pointer_interconvertible_base_of(void, volatile void));
  static_assert(!__is_pointer_interconvertible_base_of(const void, volatile void));
  static_assert(!__is_pointer_interconvertible_base_of(int, int));
  static_assert(!__is_pointer_interconvertible_base_of(int, const int));
  static_assert(!__is_pointer_interconvertible_base_of(int, volatile int));
  static_assert(!__is_pointer_interconvertible_base_of(const int, volatile int));
  static_assert(!__is_pointer_interconvertible_base_of(int *, int * __restrict));
  static_assert(!__is_pointer_interconvertible_base_of(int, _Atomic int));
  static_assert(!__is_pointer_interconvertible_base_of(_Atomic(int), _Atomic int));
  static_assert(!__is_pointer_interconvertible_base_of(int, unsigned int));
  static_assert(!__is_pointer_interconvertible_base_of(char, unsigned char));
  static_assert(!__is_pointer_interconvertible_base_of(char, signed char));
  static_assert(!__is_pointer_interconvertible_base_of(unsigned char, signed char));
  using function_type = void();
  using function_type2 = void(char);
  static_assert(!__is_pointer_interconvertible_base_of(const function_type, const function_type));
  // expected-warning@-1 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}}
  // expected-warning@-2 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}}
  static_assert(!__is_pointer_interconvertible_base_of(function_type, const function_type));
  // expected-warning@-1 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}}
  static_assert(!__is_pointer_interconvertible_base_of(const function_type, const function_type2));
  // expected-warning@-1 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}}
  // expected-warning@-2 {{'const' qualifier on function type 'function_type2' (aka 'void (char)') has no effect}}
  static_assert(!__is_pointer_interconvertible_base_of(int CStruct2::*, int CStruct2::*));
  static_assert(!__is_pointer_interconvertible_base_of(int CStruct2::*, char CStruct2::*));
  static_assert(!__is_pointer_interconvertible_base_of(void(CStruct2::*)(int), void(CStruct2::*)(int)));
  static_assert(!__is_pointer_interconvertible_base_of(void(CStruct2::*)(int), void(CStruct2::*)(char)));
  static_assert(!__is_pointer_interconvertible_base_of(int[], int[]));
  static_assert(!__is_pointer_interconvertible_base_of(int[], double[]));
  static_assert(!__is_pointer_interconvertible_base_of(int[2], int[2]));
  static_assert(!__is_pointer_interconvertible_base_of(int[n], int[2]));
  // expected-error@-1 {{variable length arrays are not supported in '__is_pointer_interconvertible_base_of'}}
  static_assert(!__is_pointer_interconvertible_base_of(int[n], int[n]));
  // expected-error@-1 {{variable length arrays are not supported in '__is_pointer_interconvertible_base_of'}}
  // expected-error@-2 {{variable length arrays are not supported in '__is_pointer_interconvertible_base_of'}}
  static_assert(!__is_pointer_interconvertible_base_of(int&, int&));
  static_assert(!__is_pointer_interconvertible_base_of(int&, char&));
  static_assert(!__is_pointer_interconvertible_base_of(void(int), void(int)));
  static_assert(!__is_pointer_interconvertible_base_of(void(int), void(char)));
  static_assert(!__is_pointer_interconvertible_base_of(void(&)(int), void(&)(int)));
  static_assert(!__is_pointer_interconvertible_base_of(void(&)(int), void(&)(char)));
  static_assert(!__is_pointer_interconvertible_base_of(void(*)(int), void(*)(int)));
  static_assert(!__is_pointer_interconvertible_base_of(void(*)(int), void(*)(char)));
}
}

void is_signed()
{
  //static_assert(__is_signed(char));
  static_assert(__is_signed(int));
  static_assert(__is_signed(long));
  static_assert(__is_signed(short));
  static_assert(__is_signed(signed char));
  static_assert(__is_signed(wchar_t));
  static_assert(__is_signed(float));
  static_assert(__is_signed(double));
  static_assert(__is_signed(long double));

  static_assert(!__is_signed(bool));
  static_assert(!__is_signed(cvoid));
  static_assert(!__is_signed(unsigned char));
  static_assert(!__is_signed(unsigned int));
  static_assert(!__is_signed(unsigned long long));
  static_assert(!__is_signed(unsigned long));
  static_assert(!__is_signed(unsigned short));
  static_assert(!__is_signed(void));
  static_assert(!__is_signed(ClassType));
  static_assert(!__is_signed(Derives));
  static_assert(!__is_signed(Enum));
  static_assert(!__is_signed(SignedEnum));
  static_assert(!__is_signed(IntArNB));
  static_assert(!__is_signed(Union));
  static_assert(!__is_signed(UnionAr));
  static_assert(!__is_signed(UnsignedEnum));
}

void is_unsigned()
{
  static_assert(__is_unsigned(bool));
  static_assert(__is_unsigned(unsigned char));
  static_assert(__is_unsigned(unsigned short));
  static_assert(__is_unsigned(unsigned int));
  static_assert(__is_unsigned(unsigned long));
  static_assert(__is_unsigned(unsigned long long));

  static_assert(!__is_unsigned(void));
  static_assert(!__is_unsigned(cvoid));
  static_assert(!__is_unsigned(float));
  static_assert(!__is_unsigned(double));
  static_assert(!__is_unsigned(long double));
  static_assert(!__is_unsigned(char));
  static_assert(!__is_unsigned(signed char));
  static_assert(!__is_unsigned(wchar_t));
  static_assert(!__is_unsigned(short));
  static_assert(!__is_unsigned(int));
  static_assert(!__is_unsigned(long));
  static_assert(!__is_unsigned(Union));
  static_assert(!__is_unsigned(UnionAr));
  static_assert(!__is_unsigned(Derives));
  static_assert(!__is_unsigned(ClassType));
  static_assert(!__is_unsigned(IntArNB));
  static_assert(!__is_unsigned(Enum));
  static_assert(!__is_unsigned(UnsignedEnum));
  static_assert(!__is_unsigned(SignedEnum));
}

typedef Int& IntRef;
typedef const IntAr ConstIntAr;
typedef ConstIntAr ConstIntArAr[4];

struct HasCopy {
  HasCopy(HasCopy& cp);
};

struct HasMove {
  HasMove(HasMove&& cp);
};

struct HasTemplateCons {
  HasVirt Annoying;

  template <typename T>
  HasTemplateCons(const T&);
};

void has_trivial_default_constructor() {
  static_assert(__has_trivial_constructor(Int));
  static_assert(__has_trivial_constructor(IntAr));
  static_assert(__has_trivial_constructor(Union));
  static_assert(__has_trivial_constructor(UnionAr));
  static_assert(__has_trivial_constructor(POD));
  static_assert(__has_trivial_constructor(Derives));
  static_assert(__has_trivial_constructor(DerivesAr));
  static_assert(__has_trivial_constructor(ConstIntAr));
  static_assert(__has_trivial_constructor(ConstIntArAr));
  static_assert(__has_trivial_constructor(HasDest));
  static_assert(__has_trivial_constructor(HasPriv));
  static_assert(__has_trivial_constructor(HasCopyAssign));
  static_assert(__has_trivial_constructor(HasMoveAssign));
  static_assert(__has_trivial_constructor(const Int));
  static_assert(__has_trivial_constructor(AllDefaulted));
  static_assert(__has_trivial_constructor(AllDeleted));
  static_assert(__has_trivial_constructor(ACompleteType[]));

  static_assert(!__has_trivial_constructor(AnIncompleteType[])); // expected-error {{incomplete type}}
  static_assert(!__has_trivial_constructor(HasCons));
  static_assert(!__has_trivial_constructor(HasRef));
  static_assert(!__has_trivial_constructor(HasCopy));
  static_assert(!__has_trivial_constructor(IntRef));
  static_assert(!__has_trivial_constructor(VirtAr));
  static_assert(!__has_trivial_constructor(void));
  static_assert(!__has_trivial_constructor(cvoid));
  static_assert(!__has_trivial_constructor(HasTemplateCons));
  static_assert(!__has_trivial_constructor(AllPrivate));
  static_assert(!__has_trivial_constructor(ExtDefaulted));
}

void has_trivial_move_constructor() {
  // n3376 12.8 [class.copy]/12
  // A copy/move constructor for class X is trivial if it is not
  // user-provided, its declared parameter type is the same as
  // if it had been implicitly declared, and if
  //   - class X has no virtual functions (10.3) and no virtual
  //     base classes (10.1), and
  //   - the constructor selected to copy/move each direct base
  //     class subobject is trivial, and
  //   - for each non-static data member of X that is of class
  //     type (or array thereof), the constructor selected
  //     to copy/move that member is trivial;
  // otherwise the copy/move constructor is non-trivial.
  static_assert(__has_trivial_move_constructor(POD));
  static_assert(__has_trivial_move_constructor(Union));
  static_assert(__has_trivial_move_constructor(HasCons));
  static_assert(__has_trivial_move_constructor(HasStaticMemberMoveCtor));
  static_assert(__has_trivial_move_constructor(AllDeleted));
  static_assert(__has_trivial_move_constructor(ACompleteType[]));

  static_assert(!__has_trivial_move_constructor(AnIncompleteType[])); // expected-error {{incomplete type}}
  static_assert(!__has_trivial_move_constructor(HasVirt));
  static_assert(!__has_trivial_move_constructor(DerivesVirt));
  static_assert(!__has_trivial_move_constructor(HasMoveCtor));
  static_assert(!__has_trivial_move_constructor(DerivesHasMoveCtor));
  static_assert(!__has_trivial_move_constructor(HasMemberMoveCtor));
}

void has_trivial_copy_constructor() {
  static_assert(__has_trivial_copy(Int));
  static_assert(__has_trivial_copy(IntAr));
  static_assert(__has_trivial_copy(Union));
  static_assert(__has_trivial_copy(UnionAr));
  static_assert(__has_trivial_copy(POD));
  static_assert(__has_trivial_copy(Derives));
  static_assert(__has_trivial_copy(ConstIntAr));
  static_assert(__has_trivial_copy(ConstIntArAr));
  static_assert(__has_trivial_copy(HasDest));
  static_assert(__has_trivial_copy(HasPriv));
  static_assert(__has_trivial_copy(HasCons));
  static_assert(__has_trivial_copy(HasRef));
  static_assert(__has_trivial_copy(HasMove));
  static_assert(__has_trivial_copy(IntRef));
  static_assert(__has_trivial_copy(HasCopyAssign));
  static_assert(__has_trivial_copy(HasMoveAssign));
  static_assert(__has_trivial_copy(const Int));
  static_assert(__has_trivial_copy(AllDefaulted));
  static_assert(__has_trivial_copy(AllDeleted));
  static_assert(__has_trivial_copy(DerivesAr));
  static_assert(__has_trivial_copy(DerivesHasRef));
  static_assert(__has_trivial_copy(ACompleteType[]));

  static_assert(!__has_trivial_copy(AnIncompleteType[])); // expected-error {{incomplete type}}
  static_assert(!__has_trivial_copy(HasCopy));
  static_assert(!__has_trivial_copy(HasTemplateCons));
  static_assert(!__has_trivial_copy(VirtAr));
  static_assert(!__has_trivial_copy(void));
  static_assert(!__has_trivial_copy(cvoid));
  static_assert(!__has_trivial_copy(AllPrivate));
  static_assert(!__has_trivial_copy(ExtDefaulted));
}

void has_trivial_copy_assignment() {
  static_assert(__has_trivial_assign(Int));
  static_assert(__has_trivial_assign(IntAr));
  static_assert(__has_trivial_assign(Union));
  static_assert(__has_trivial_assign(UnionAr));
  static_assert(__has_trivial_assign(POD));
  static_assert(__has_trivial_assign(Derives));
  static_assert(__has_trivial_assign(HasDest));
  static_assert(__has_trivial_assign(HasPriv));
  static_assert(__has_trivial_assign(HasCons));
  static_assert(__has_trivial_assign(HasRef));
  static_assert(__has_trivial_assign(HasCopy));
  static_assert(__has_trivial_assign(HasMove));
  static_assert(__has_trivial_assign(HasMoveAssign));
  static_assert(__has_trivial_assign(AllDefaulted));
  static_assert(__has_trivial_assign(AllDeleted));
  static_assert(__has_trivial_assign(DerivesAr));
  static_assert(__has_trivial_assign(DerivesHasRef));
  static_assert(__has_trivial_assign(ACompleteType[]));

  static_assert(!__has_trivial_assign(AnIncompleteType[])); // expected-error {{incomplete type}}
  static_assert(!__has_trivial_assign(IntRef));
  static_assert(!__has_trivial_assign(HasCopyAssign));
  static_assert(!__has_trivial_assign(const Int));
  static_assert(!__has_trivial_assign(ConstIntAr));
  static_assert(!__has_trivial_assign(ConstIntArAr));
  static_assert(!__has_trivial_assign(VirtAr));
  static_assert(!__has_trivial_assign(void));
  static_assert(!__has_trivial_assign(cvoid));
  static_assert(!__has_trivial_assign(AllPrivate));
  static_assert(!__has_trivial_assign(ExtDefaulted));
}

void has_trivial_destructor() {
  static_assert(__has_trivial_destructor(Int));
  static_assert(__has_trivial_destructor(IntAr));
  static_assert(__has_trivial_destructor(Union));
  static_assert(__has_trivial_destructor(UnionAr));
  static_assert(__has_trivial_destructor(POD));
  static_assert(__has_trivial_destructor(Derives));
  static_assert(__has_trivial_destructor(ConstIntAr));
  static_assert(__has_trivial_destructor(ConstIntArAr));
  static_assert(__has_trivial_destructor(HasPriv));
  static_assert(__has_trivial_destructor(HasCons));
  static_assert(__has_trivial_destructor(HasRef));
  static_assert(__has_trivial_destructor(HasCopy));
  static_assert(__has_trivial_destructor(HasMove));
  static_assert(__has_trivial_destructor(IntRef));
  static_assert(__has_trivial_destructor(HasCopyAssign));
  static_assert(__has_trivial_destructor(HasMoveAssign));
  static_assert(__has_trivial_destructor(const Int));
  static_assert(__has_trivial_destructor(DerivesAr));
  static_assert(__has_trivial_destructor(VirtAr));
  static_assert(__has_trivial_destructor(AllDefaulted));
  static_assert(__has_trivial_destructor(AllDeleted));
  static_assert(__has_trivial_destructor(DerivesHasRef));
  static_assert(__has_trivial_destructor(ACompleteType[]));

  static_assert(!__has_trivial_destructor(HasDest));
  static_assert(!__has_trivial_destructor(AnIncompleteType[])); // expected-error {{incomplete type}}
  static_assert(!__has_trivial_destructor(void));
  static_assert(!__has_trivial_destructor(cvoid));
  static_assert(!__has_trivial_destructor(AllPrivate));
  static_assert(!__has_trivial_destructor(ExtDefaulted));
}

struct A { ~A() {} };
template<typename> struct B : A { };

void f() {
  static_assert(!__has_trivial_destructor(A));
  static_assert(!__has_trivial_destructor(B<int>));
}

class PR11110 {
  template <int> int operator=( int );
  int operator=(PR11110);
};

class UsingAssign;

class UsingAssignBase {
protected:
  UsingAssign &operator=(const UsingAssign&) throw();
};

class UsingAssign : public UsingAssignBase {
public:
  using UsingAssignBase::operator=;
};

void has_nothrow_assign() {
  static_assert(__has_nothrow_assign(Int));
  static_assert(__has_nothrow_assign(IntAr));
  static_assert(__has_nothrow_assign(Union));
  static_assert(__has_nothrow_assign(UnionAr));
  static_assert(__has_nothrow_assign(POD));
  static_assert(__has_nothrow_assign(Derives));
  static_assert(__has_nothrow_assign(HasDest));
  static_assert(__has_nothrow_assign(HasPriv));
  static_assert(__has_nothrow_assign(HasCons));
  static_assert(__has_nothrow_assign(HasRef));
  static_assert(__has_nothrow_assign(HasCopy));
  static_assert(__has_nothrow_assign(HasMove));
  static_assert(__has_nothrow_assign(HasMoveAssign));
  static_assert(__has_nothrow_assign(HasNoThrowCopyAssign));
  static_assert(__has_nothrow_assign(HasMultipleNoThrowCopyAssign));
  static_assert(__has_nothrow_assign(HasVirtDest));
  static_assert(__has_nothrow_assign(AllPrivate));
  static_assert(__has_nothrow_assign(UsingAssign));
  static_assert(__has_nothrow_assign(DerivesAr));
  static_assert(__has_nothrow_assign(ACompleteType[]));

  static_assert(!__has_nothrow_assign(AnIncompleteType[])); // expected-error {{incomplete type}}
  static_assert(!__has_nothrow_assign(IntRef));
  static_assert(!__has_nothrow_assign(HasCopyAssign));
  static_assert(!__has_nothrow_assign(HasMultipleCopyAssign));
  static_assert(!__has_nothrow_assign(const Int));
  static_assert(!__has_nothrow_assign(ConstIntAr));
  static_assert(!__has_nothrow_assign(ConstIntArAr));
  static_assert(!__has_nothrow_assign(VirtAr));
  static_assert(!__has_nothrow_assign(void));
  static_assert(!__has_nothrow_assign(cvoid));
  static_assert(!__has_nothrow_assign(PR11110));
}

void has_nothrow_move_assign() {
  static_assert(__has_nothrow_move_assign(Int));
  static_assert(__has_nothrow_move_assign(Enum));
  static_assert(__has_nothrow_move_assign(Int*));
  static_assert(__has_nothrow_move_assign(Enum POD::*));
  static_assert(__has_nothrow_move_assign(POD));
  static_assert(__has_nothrow_move_assign(HasPriv));
  static_assert(__has_nothrow_move_assign(HasNoThrowMoveAssign));
  static_assert(__has_nothrow_move_assign(HasNoExceptNoThrowMoveAssign));
  static_assert(__has_nothrow_move_assign(HasMemberNoThrowMoveAssign));
  static_assert(__has_nothrow_move_assign(HasMemberNoExceptNoThrowMoveAssign));
  static_assert(__has_nothrow_move_assign(AllDeleted));
  static_assert(__has_nothrow_move_assign(ACompleteType[]));

  static_assert(!__has_nothrow_move_assign(AnIncompleteType[])); // expected-error {{incomplete type}}
  static_assert(!__has_nothrow_move_assign(HasThrowMoveAssign));
  static_assert(!__has_nothrow_move_assign(HasNoExceptFalseMoveAssign));
  static_assert(!__has_nothrow_move_assign(HasMemberThrowMoveAssign));
  static_assert(!__has_nothrow_move_assign(HasMemberNoExceptFalseMoveAssign));
  static_assert(!__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyCtor));
  static_assert(!__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyAssign));
  static_assert(!__has_nothrow_move_assign(NoDefaultMoveAssignDueToDtor));


  static_assert(__is_nothrow_assignable(HasNoThrowMoveAssign, HasNoThrowMoveAssign));
  static_assert(!__is_nothrow_assignable(HasThrowMoveAssign, HasThrowMoveAssign));

  static_assert(__is_assignable(HasNoThrowMoveAssign, HasNoThrowMoveAssign));
  static_assert(__is_assignable(HasThrowMoveAssign, HasThrowMoveAssign));
}

void has_trivial_move_assign() {
  // n3376 12.8 [class.copy]/25
  // A copy/move assignment operator for class X is trivial if it
  // is not user-provided, its declared parameter type is the same
  // as if it had been implicitly declared, and if:
  //  - class X has no virtual functions (10.3) and no virtual base
  //    classes (10.1), and
  //  - the assignment operator selected to copy/move each direct
  //    base class subobject is trivial, and
  //  - for each non-static data member of X that is of class type
  //    (or array thereof), the assignment operator
  //    selected to copy/move that member is trivial;
  static_assert(__has_trivial_move_assign(Int));
  static_assert(__has_trivial_move_assign(HasStaticMemberMoveAssign));
  static_assert(__has_trivial_move_assign(AllDeleted));
  static_assert(__has_trivial_move_assign(ACompleteType[]));

  static_assert(!__has_trivial_move_assign(AnIncompleteType[])); // expected-error {{incomplete type}}
  static_assert(!__has_trivial_move_assign(HasVirt));
  static_assert(!__has_trivial_move_assign(DerivesVirt));
  static_assert(!__has_trivial_move_assign(HasMoveAssign));
  static_assert(!__has_trivial_move_assign(DerivesHasMoveAssign));
  static_assert(!__has_trivial_move_assign(HasMemberMoveAssign));
  static_assert(!__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyCtor));
  static_assert(!__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyAssign));
}

void has_nothrow_copy() {
  static_assert(__has_nothrow_copy(Int));
  static_assert(__has_nothrow_copy(IntAr));
  static_assert(__has_nothrow_copy(Union));
  static_assert(__has_nothrow_copy(UnionAr));
  static_assert(__has_nothrow_copy(POD));
  static_assert(__has_nothrow_copy(const Int));
  static_assert(__has_nothrow_copy(ConstIntAr));
  static_assert(__has_nothrow_copy(ConstIntArAr));
  static_assert(__has_nothrow_copy(Derives));
  static_assert(__has_nothrow_copy(IntRef));
  static_assert(__has_nothrow_copy(HasDest));
  static_assert(__has_nothrow_copy(HasPriv));
  static_assert(__has_nothrow_copy(HasCons));
  static_assert(__has_nothrow_copy(HasRef));
  static_assert(__has_nothrow_copy(HasMove));
  static_assert(__has_nothrow_copy(HasCopyAssign));
  static_assert(__has_nothrow_copy(HasMoveAssign));
  static_assert(__has_nothrow_copy(HasNoThrowCopy));
  static_assert(__has_nothrow_copy(HasMultipleNoThrowCopy));
  static_assert(__has_nothrow_copy(HasVirtDest));
  static_assert(__has_nothrow_copy(HasTemplateCons));
  static_assert(__has_nothrow_copy(AllPrivate));
  static_assert(__has_nothrow_copy(DerivesAr));
  static_assert(__has_nothrow_copy(ACompleteType[]));

  static_assert(!__has_nothrow_copy(AnIncompleteType[])); // expected-error {{incomplete type}}
  static_assert(!__has_nothrow_copy(HasCopy));
  static_assert(!__has_nothrow_copy(HasMultipleCopy));
  static_assert(!__has_nothrow_copy(VirtAr));
  static_assert(!__has_nothrow_copy(void));
  static_assert(!__has_nothrow_copy(cvoid));
}

void has_nothrow_constructor() {
  static_assert(__has_nothrow_constructor(Int));
  static_assert(__has_nothrow_constructor(IntAr));
  static_assert(__has_nothrow_constructor(Union));
  static_assert(__has_nothrow_constructor(UnionAr));
  static_assert(__has_nothrow_constructor(POD));
  static_assert(__has_nothrow_constructor(Derives));
  static_assert(__has_nothrow_constructor(DerivesAr));
  static_assert(__has_nothrow_constructor(ConstIntAr));
  static_assert(__has_nothrow_constructor(ConstIntArAr));
  static_assert(__has_nothrow_constructor(HasDest));
  static_assert(__has_nothrow_constructor(HasPriv));
  static_assert(__has_nothrow_constructor(HasCopyAssign));
  static_assert(__has_nothrow_constructor(const Int));
  static_assert(__has_nothrow_constructor(HasNoThrowConstructor));
  static_assert(__has_nothrow_constructor(HasVirtDest));
  // static_assert(__has_nothrow_constructor(VirtAr)); // not implemented
  static_assert(__has_nothrow_constructor(AllPrivate));
  static_assert(__has_nothrow_constructor(ACompleteType[]));

  static_assert(!__has_nothrow_constructor(AnIncompleteType[])); // expected-error {{incomplete type}}
  static_assert(!__has_nothrow_constructor(HasCons));
  static_assert(!__has_nothrow_constructor(HasRef));
  static_assert(!__has_nothrow_constructor(HasCopy));
  static_assert(!__has_nothrow_constructor(HasMove));
  static_assert(!__has_nothrow_constructor(HasNoThrowConstructorWithArgs));
  static_assert(!__has_nothrow_constructor(IntRef));
  static_assert(!__has_nothrow_constructor(void));
  static_assert(!__has_nothrow_constructor(cvoid));
  static_assert(!__has_nothrow_constructor(HasTemplateCons));

  static_assert(!__has_nothrow_constructor(HasMultipleDefaultConstructor1));
  static_assert(!__has_nothrow_constructor(HasMultipleDefaultConstructor2));
}

void has_virtual_destructor() {
  static_assert(!__has_virtual_destructor(Int));
  static_assert(!__has_virtual_destructor(IntAr));
  static_assert(!__has_virtual_destructor(Union));
  static_assert(!__has_virtual_destructor(UnionAr));
  static_assert(!__has_virtual_destructor(POD));
  static_assert(!__has_virtual_destructor(Derives));
  static_assert(!__has_virtual_destructor(DerivesAr));
  static_assert(!__has_virtual_destructor(const Int));
  static_assert(!__has_virtual_destructor(ConstIntAr));
  static_assert(!__has_virtual_destructor(ConstIntArAr));
  static_assert(!__has_virtual_destructor(HasDest));
  static_assert(!__has_virtual_destructor(HasPriv));
  static_assert(!__has_virtual_destructor(HasCons));
  static_assert(!__has_virtual_destructor(HasRef));
  static_assert(!__has_virtual_destructor(HasCopy));
  static_assert(!__has_virtual_destructor(HasMove));
  static_assert(!__has_virtual_destructor(HasCopyAssign));
  static_assert(!__has_virtual_destructor(HasMoveAssign));
  static_assert(!__has_virtual_destructor(IntRef));
  static_assert(!__has_virtual_destructor(VirtAr));
  static_assert(!__has_virtual_destructor(ACompleteType[]));

  static_assert(!__has_virtual_destructor(AnIncompleteType[])); // expected-error {{incomplete type}}
  static_assert(__has_virtual_destructor(HasVirtDest));
  static_assert(__has_virtual_destructor(DerivedVirtDest));
  static_assert(!__has_virtual_destructor(VirtDestAr));
  static_assert(!__has_virtual_destructor(void));
  static_assert(!__has_virtual_destructor(cvoid));
  static_assert(!__has_virtual_destructor(AllPrivate));
}


class Base {};
class Derived : Base {};
class Derived2a : Derived {};
class Derived2b : Derived {};
class Derived3 : virtual Derived2a, virtual Derived2b {};
template<typename T> struct BaseA { T a;  };
template<typename T> struct DerivedB : BaseA<T> { };
template<typename T> struct CrazyDerived : T { };


class class_forward; // expected-note 2 {{forward declaration of 'class_forward'}}

template <class T> class DerivedTemp : Base {};
template <class T> class NonderivedTemp {};
template <class T> class UndefinedTemp; // expected-note {{declared here}}

void is_base_of() {
  static_assert(__is_base_of(Base, Derived));
  static_assert(__is_base_of(const Base, Derived));
  static_assert(!__is_base_of(Derived, Base));
  static_assert(!__is_base_of(Derived, int));
  static_assert(__is_base_of(Base, Base));
  static_assert(__is_base_of(Base, Derived3));
  static_assert(__is_base_of(Derived, Derived3));
  static_assert(__is_base_of(Derived2b, Derived3));
  static_assert(__is_base_of(Derived2a, Derived3));
  static_assert(__is_base_of(BaseA<int>, DerivedB<int>));
  static_assert(!__is_base_of(DerivedB<int>, BaseA<int>));
  static_assert(__is_base_of(Base, CrazyDerived<Base>));
  static_assert(!__is_base_of(Union, Union));
  static_assert(__is_base_of(Empty, Empty));
  static_assert(__is_base_of(class_forward, class_forward));
  static_assert(!__is_base_of(Empty, class_forward)); // expected-error {{incomplete type 'class_forward' used in type trait expression}}
  static_assert(!__is_base_of(Base&, Derived&));
  static_assert(!__is_base_of(Base[10], Derived[10]));
  static_assert(!__is_base_of(int, int));
  static_assert(!__is_base_of(long, int));
  static_assert(__is_base_of(Base, DerivedTemp<int>));
  static_assert(!__is_base_of(Base, NonderivedTemp<int>));
  static_assert(!__is_base_of(Base, UndefinedTemp<int>)); // expected-error {{implicit instantiation of undefined template 'UndefinedTemp<int>'}}

  static_assert(!__is_base_of(IncompleteUnion, IncompleteUnion));
  static_assert(!__is_base_of(Union, IncompleteUnion));
  static_assert(!__is_base_of(IncompleteUnion, Union));
  static_assert(!__is_base_of(IncompleteStruct, IncompleteUnion));
  static_assert(!__is_base_of(IncompleteUnion, IncompleteStruct));
  static_assert(!__is_base_of(Empty, IncompleteUnion));
  static_assert(!__is_base_of(IncompleteUnion, Empty));
  static_assert(!__is_base_of(int, IncompleteUnion));
  static_assert(!__is_base_of(IncompleteUnion, int));
  static_assert(!__is_base_of(Empty, Union));
  static_assert(!__is_base_of(Union, Empty));
  static_assert(!__is_base_of(int, Empty));
  static_assert(!__is_base_of(Union, int));

  static_assert(__is_base_of(Base, Derived));
  static_assert(!__is_base_of(Derived, Base));

  static_assert(__is_base_of(Base, CrazyDerived<Base>));
  static_assert(!__is_base_of(CrazyDerived<Base>, Base));

  static_assert(__is_base_of(BaseA<int>, DerivedB<int>));
  static_assert(!__is_base_of(DerivedB<int>, BaseA<int>));
}

template<class T, class U>
class TemplateClass {};

template<class T>
using TemplateAlias = TemplateClass<T, int>;

typedef class Base BaseTypedef;

void is_same()
{
  static_assert(__is_same(Base, Base));
  static_assert(__is_same(Base, BaseTypedef));
  static_assert(__is_same(TemplateClass<int, int>, TemplateAlias<int>));

  static_assert(!__is_same(Base, const Base));
  static_assert(!__is_same(Base, Base&));
  static_assert(!__is_same(Base, Derived));

  // __is_same_as is a GCC compatibility synonym for __is_same.
  static_assert(__is_same_as(int, int));
  static_assert(!__is_same_as(int, float));
}

struct IntWrapper
{
  int value;
  IntWrapper(int _value) : value(_value) {}
  operator int() const noexcept {
    return value;
  }
};

struct FloatWrapper
{
  float value;
  FloatWrapper(float _value) noexcept : value(_value) {}
  FloatWrapper(const IntWrapper& obj)
    : value(static_cast<float>(obj.value)) {}
  operator float() const {
    return value;
  }
  operator IntWrapper() const {
    return IntWrapper(static_cast<int>(value));
  }
};

void is_convertible()
{
  static_assert(__is_convertible(IntWrapper, IntWrapper));
  static_assert(__is_convertible(IntWrapper, const IntWrapper));
  static_assert(__is_convertible(IntWrapper, int));
  static_assert(__is_convertible(int, IntWrapper));
  static_assert(__is_convertible(IntWrapper, FloatWrapper));
  static_assert(__is_convertible(FloatWrapper, IntWrapper));
  static_assert(__is_convertible(FloatWrapper, float));
  static_assert(__is_convertible(float, FloatWrapper));
  static_assert(__is_convertible(IntWrapper, IntWrapper&&));
  static_assert(__is_convertible(IntWrapper, const IntWrapper&));
  static_assert(__is_convertible(IntWrapper, int&&));
  static_assert(__is_convertible(IntWrapper, const int&));
  static_assert(__is_convertible(int, IntWrapper&&));
  static_assert(__is_convertible(int, const IntWrapper&));
  static_assert(__is_convertible(IntWrapper, FloatWrapper&&));
  static_assert(__is_convertible(IntWrapper, const FloatWrapper&));
  static_assert(__is_convertible(FloatWrapper, IntWrapper&&));
  static_assert(__is_convertible(FloatWrapper, const IntWrapper&&));
  static_assert(__is_convertible(FloatWrapper, float&&));
  static_assert(__is_convertible(FloatWrapper, const float&));
  static_assert(__is_convertible(float, FloatWrapper&&));
  static_assert(__is_convertible(float, const FloatWrapper&));
}

void is_nothrow_convertible()
{
  static_assert(__is_nothrow_convertible(IntWrapper, IntWrapper));
  static_assert(__is_nothrow_convertible(IntWrapper, const IntWrapper));
  static_assert(__is_nothrow_convertible(IntWrapper, int));
  static_assert(!__is_nothrow_convertible(int, IntWrapper));
  static_assert(!__is_nothrow_convertible(IntWrapper, FloatWrapper));
  static_assert(!__is_nothrow_convertible(FloatWrapper, IntWrapper));
  static_assert(!__is_nothrow_convertible(FloatWrapper, float));
  static_assert(__is_nothrow_convertible(float, FloatWrapper));
  static_assert(__is_nothrow_convertible(IntWrapper, IntWrapper&&));
  static_assert(__is_nothrow_convertible(IntWrapper, const IntWrapper&));
  static_assert(__is_nothrow_convertible(IntWrapper, int&&));
  static_assert(__is_nothrow_convertible(IntWrapper, const int&));
  static_assert(!__is_nothrow_convertible(int, IntWrapper&&));
  static_assert(!__is_nothrow_convertible(int, const IntWrapper&));
  static_assert(!__is_nothrow_convertible(IntWrapper, FloatWrapper&&));
  static_assert(!__is_nothrow_convertible(IntWrapper, const FloatWrapper&));
  static_assert(!__is_nothrow_convertible(FloatWrapper, IntWrapper&&));
  static_assert(!__is_nothrow_convertible(FloatWrapper, const IntWrapper&));
  static_assert(!__is_nothrow_convertible(FloatWrapper, float&&));
  static_assert(!__is_nothrow_convertible(FloatWrapper, const float&));
  static_assert(__is_nothrow_convertible(float, FloatWrapper&&));
  static_assert(__is_nothrow_convertible(float, const FloatWrapper&));
}

struct FromInt { FromInt(int); };
struct ToInt { operator int(); };
typedef void Function();

void is_convertible_to();
class PrivateCopy {
  PrivateCopy(const PrivateCopy&);
  friend void is_convertible_to();
};

template<typename T>
struct X0 {
  template<typename U> X0(const X0<U>&);
};

struct Abstract { virtual void f() = 0; };

void is_convertible_to() {
  static_assert(__is_convertible_to(Int, Int));
  static_assert(!__is_convertible_to(Int, IntAr));
  static_assert(!__is_convertible_to(IntAr, IntAr));
  static_assert(__is_convertible_to(void, void));
  static_assert(__is_convertible_to(cvoid, void));
  static_assert(__is_convertible_to(void, cvoid));
  static_assert(__is_convertible_to(cvoid, cvoid));
  static_assert(__is_convertible_to(int, FromInt));
  static_assert(__is_convertible_to(long, FromInt));
  static_assert(__is_convertible_to(double, FromInt));
  static_assert(__is_convertible_to(const int, FromInt));
  static_assert(__is_convertible_to(const int&, FromInt));
  static_assert(__is_convertible_to(ToInt, int));
  static_assert(__is_convertible_to(ToInt, const int&));
  static_assert(__is_convertible_to(ToInt, long));
  static_assert(!__is_convertible_to(ToInt, int&));
  static_assert(!__is_convertible_to(ToInt, FromInt));
  static_assert(__is_convertible_to(IntAr&, IntAr&));
  static_assert(__is_convertible_to(IntAr&, const IntAr&));
  static_assert(!__is_convertible_to(const IntAr&, IntAr&));
  static_assert(!__is_convertible_to(Function, Function));
  static_assert(!__is_convertible_to(PrivateCopy, PrivateCopy));
  static_assert(__is_convertible_to(X0<int>, X0<float>));
  static_assert(!__is_convertible_to(Abstract, Abstract));
}

namespace is_convertible_to_instantiate {
  // Make sure we don't try to instantiate the constructor.
  template<int x> class A { A(int) { int a[x]; } };
  int x = __is_convertible_to(int, A<-1>);
}

void is_trivial()
{
  static_assert(__is_trivial(int));
  static_assert(__is_trivial(Enum));
  static_assert(__is_trivial(POD));
  static_assert(__is_trivial(Int));
  static_assert(__is_trivial(IntAr));
  static_assert(__is_trivial(IntArNB));
  static_assert(__is_trivial(Statics));
  static_assert(__is_trivial(Empty));
  static_assert(__is_trivial(EmptyUnion));
  static_assert(__is_trivial(Union));
  static_assert(__is_trivial(Derives));
  static_assert(__is_trivial(DerivesAr));
  static_assert(__is_trivial(DerivesArNB));
  static_assert(__is_trivial(DerivesEmpty));
  static_assert(__is_trivial(HasFunc));
  static_assert(__is_trivial(HasOp));
  static_assert(__is_trivial(HasConv));
  static_assert(__is_trivial(HasAssign));
  static_assert(__is_trivial(HasAnonymousUnion));
  static_assert(__is_trivial(HasPriv));
  static_assert(__is_trivial(HasProt));
  static_assert(__is_trivial(DerivesHasPriv));
  static_assert(__is_trivial(DerivesHasProt));
  static_assert(__is_trivial(Vector));
  static_assert(__is_trivial(VectorExt));

  static_assert(!__is_trivial(HasCons));
  static_assert(!__is_trivial(HasCopyAssign));
  static_assert(!__is_trivial(HasMoveAssign));
  static_assert(!__is_trivial(HasDest));
  static_assert(!__is_trivial(HasRef));
  static_assert(!__is_trivial(HasNonPOD));
  static_assert(!__is_trivial(HasVirt));
  static_assert(!__is_trivial(DerivesHasCons));
  static_assert(!__is_trivial(DerivesHasCopyAssign));
  static_assert(!__is_trivial(DerivesHasMoveAssign));
  static_assert(!__is_trivial(DerivesHasDest));
  static_assert(!__is_trivial(DerivesHasRef));
  static_assert(!__is_trivial(DerivesHasVirt));
  static_assert(!__is_trivial(void));
  static_assert(!__is_trivial(cvoid));
}

template<typename T> struct TriviallyConstructibleTemplate {};

void trivial_checks()
{
  static_assert(__is_trivially_copyable(int));
  static_assert(__is_trivially_copyable(Enum));
  static_assert(__is_trivially_copyable(POD));
  static_assert(__is_trivially_copyable(Int));
  static_assert(__is_trivially_copyable(IntAr));
  static_assert(__is_trivially_copyable(IntArNB));
  static_assert(__is_trivially_copyable(Statics));
  static_assert(__is_trivially_copyable(Empty));
  static_assert(__is_trivially_copyable(EmptyUnion));
  static_assert(__is_trivially_copyable(Union));
  static_assert(__is_trivially_copyable(Derives));
  static_assert(__is_trivially_copyable(DerivesAr));
  static_assert(__is_trivially_copyable(DerivesArNB));
  static_assert(__is_trivially_copyable(DerivesEmpty));
  static_assert(__is_trivially_copyable(HasFunc));
  static_assert(__is_trivially_copyable(HasOp));
  static_assert(__is_trivially_copyable(HasConv));
  static_assert(__is_trivially_copyable(HasAssign));
  static_assert(__is_trivially_copyable(HasAnonymousUnion));
  static_assert(__is_trivially_copyable(HasPriv));
  static_assert(__is_trivially_copyable(HasProt));
  static_assert(__is_trivially_copyable(DerivesHasPriv));
  static_assert(__is_trivially_copyable(DerivesHasProt));
  static_assert(__is_trivially_copyable(Vector));
  static_assert(__is_trivially_copyable(VectorExt));
  static_assert(__is_trivially_copyable(HasCons));
  static_assert(__is_trivially_copyable(HasRef));
  static_assert(__is_trivially_copyable(HasNonPOD));
  static_assert(__is_trivially_copyable(DerivesHasCons));
  static_assert(__is_trivially_copyable(DerivesHasRef));
  static_assert(__is_trivially_copyable(NonTrivialDefault));
  static_assert(__is_trivially_copyable(NonTrivialDefault[]));
  static_assert(__is_trivially_copyable(NonTrivialDefault[3]));

  static_assert(!__is_trivially_copyable(HasCopyAssign));
  static_assert(!__is_trivially_copyable(HasMoveAssign));
  static_assert(!__is_trivially_copyable(HasDest));
  static_assert(!__is_trivially_copyable(HasVirt));
  static_assert(!__is_trivially_copyable(DerivesHasCopyAssign));
  static_assert(!__is_trivially_copyable(DerivesHasMoveAssign));
  static_assert(!__is_trivially_copyable(DerivesHasDest));
  static_assert(!__is_trivially_copyable(DerivesHasVirt));
  static_assert(!__is_trivially_copyable(void));
  static_assert(!__is_trivially_copyable(cvoid));

  static_assert((__is_trivially_constructible(int)));
  static_assert((__is_trivially_constructible(int, int)));
  static_assert((__is_trivially_constructible(int, float)));
  static_assert((__is_trivially_constructible(int, int&)));
  static_assert((__is_trivially_constructible(int, const int&)));
  static_assert((__is_trivially_constructible(int, int)));
  static_assert((__is_trivially_constructible(HasCopyAssign, HasCopyAssign)));
  static_assert((__is_trivially_constructible(HasCopyAssign, const HasCopyAssign&)));
  static_assert((__is_trivially_constructible(HasCopyAssign, HasCopyAssign&&)));
  static_assert((__is_trivially_constructible(HasCopyAssign)));
  static_assert((__is_trivially_constructible(NonTrivialDefault,
                                            const NonTrivialDefault&)));
  static_assert((__is_trivially_constructible(NonTrivialDefault,
                                            NonTrivialDefault&&)));
  static_assert((__is_trivially_constructible(AllDefaulted)));
  static_assert((__is_trivially_constructible(AllDefaulted,
                                            const AllDefaulted &)));
  static_assert((__is_trivially_constructible(AllDefaulted,
                                            AllDefaulted &&)));

  static_assert(!(__is_trivially_constructible(int, int*)));
  static_assert(!(__is_trivially_constructible(NonTrivialDefault)));
  static_assert(!(__is_trivially_constructible(ThreeArgCtor, int*, char*, int&)));
  static_assert(!(__is_trivially_constructible(AllDeleted)));
  static_assert(!(__is_trivially_constructible(AllDeleted,
                                            const AllDeleted &)));
  static_assert(!(__is_trivially_constructible(AllDeleted,
                                            AllDeleted &&)));
  static_assert(!(__is_trivially_constructible(ExtDefaulted)));
  static_assert(!(__is_trivially_constructible(ExtDefaulted,
                                            const ExtDefaulted &)));
  static_assert(!(__is_trivially_constructible(ExtDefaulted,
                                            ExtDefaulted &&)));

  static_assert((__is_trivially_constructible(TriviallyConstructibleTemplate<int>)));
  static_assert(!(__is_trivially_constructible(class_forward))); // expected-error {{incomplete type 'class_forward' used in type trait expression}}
  static_assert(!(__is_trivially_constructible(class_forward[])));
  static_assert(!(__is_trivially_constructible(void)));

  static_assert((__is_trivially_assignable(int&, int)));
  static_assert((__is_trivially_assignable(int&, int&)));
  static_assert((__is_trivially_assignable(int&, int&&)));
  static_assert((__is_trivially_assignable(int&, const int&)));
  static_assert((__is_trivially_assignable(POD&, POD)));
  static_assert((__is_trivially_assignable(POD&, POD&)));
  static_assert((__is_trivially_assignable(POD&, POD&&)));
  static_assert((__is_trivially_assignable(POD&, const POD&)));
  static_assert((__is_trivially_assignable(int*&, int*)));
  static_assert((__is_trivially_assignable(AllDefaulted,
                                         const AllDefaulted &)));
  static_assert((__is_trivially_assignable(AllDefaulted,
                                         AllDefaulted &&)));

  static_assert(!(__is_trivially_assignable(int*&, float*)));
  static_assert(!(__is_trivially_assignable(HasCopyAssign&, HasCopyAssign)));
  static_assert(!(__is_trivially_assignable(HasCopyAssign&, HasCopyAssign&)));
  static_assert(!(__is_trivially_assignable(HasCopyAssign&, const HasCopyAssign&)));
  static_assert(!(__is_trivially_assignable(HasCopyAssign&, HasCopyAssign&&)));
  static_assert(!(__is_trivially_assignable(TrivialMoveButNotCopy&,
                                        TrivialMoveButNotCopy&)));
  static_assert(!(__is_trivially_assignable(TrivialMoveButNotCopy&,
                                        const TrivialMoveButNotCopy&)));
  static_assert(!(__is_trivially_assignable(AllDeleted,
                                         const AllDeleted &)));
  static_assert(!(__is_trivially_assignable(AllDeleted,
                                         AllDeleted &&)));
  static_assert(!(__is_trivially_assignable(ExtDefaulted,
                                         const ExtDefaulted &)));
  static_assert(!(__is_trivially_assignable(ExtDefaulted,
                                         ExtDefaulted &&)));

  static_assert((__is_trivially_assignable(HasDefaultTrivialCopyAssign&,
                                         HasDefaultTrivialCopyAssign&)));
  static_assert((__is_trivially_assignable(HasDefaultTrivialCopyAssign&,
                                       const HasDefaultTrivialCopyAssign&)));
  static_assert((__is_trivially_assignable(TrivialMoveButNotCopy&,
                                         TrivialMoveButNotCopy)));
  static_assert((__is_trivially_assignable(TrivialMoveButNotCopy&,
                                         TrivialMoveButNotCopy&&)));
  static_assert((__is_trivially_assignable(int&, int)));
  static_assert((__is_trivially_assignable(int&, int&)));
  static_assert((__is_trivially_assignable(int&, int&&)));
  static_assert((__is_trivially_assignable(int&, const int&)));
  static_assert((__is_trivially_assignable(POD&, POD)));
  static_assert((__is_trivially_assignable(POD&, POD&)));
  static_assert((__is_trivially_assignable(POD&, POD&&)));
  static_assert((__is_trivially_assignable(POD&, const POD&)));
  static_assert((__is_trivially_assignable(int*&, int*)));
  static_assert((__is_trivially_assignable(AllDefaulted,
                                         const AllDefaulted &)));
  static_assert((__is_trivially_assignable(AllDefaulted,
                                         AllDefaulted &&)));

  static_assert(!(__is_assignable(int *&, float *)));
  static_assert((__is_assignable(HasCopyAssign &, HasCopyAssign)));
  static_assert((__is_assignable(HasCopyAssign &, HasCopyAssign &)));
  static_assert((__is_assignable(HasCopyAssign &, const HasCopyAssign &)));
  static_assert((__is_assignable(HasCopyAssign &, HasCopyAssign &&)));
  static_assert((__is_assignable(TrivialMoveButNotCopy &,
                               TrivialMoveButNotCopy &)));
  static_assert((__is_assignable(TrivialMoveButNotCopy &,
                               const TrivialMoveButNotCopy &)));
  static_assert(!(__is_assignable(AllDeleted,
                               const AllDeleted &)));
  static_assert(!(__is_assignable(AllDeleted,
                               AllDeleted &&)));
  static_assert((__is_assignable(ExtDefaulted,
                               const ExtDefaulted &)));
  static_assert((__is_assignable(ExtDefaulted,
                               ExtDefaulted &&)));

  static_assert((__is_assignable(HasDefaultTrivialCopyAssign &,
                               HasDefaultTrivialCopyAssign &)));
  static_assert((__is_assignable(HasDefaultTrivialCopyAssign &,
                               const HasDefaultTrivialCopyAssign &)));
  static_assert((__is_assignable(TrivialMoveButNotCopy &,
                               TrivialMoveButNotCopy)));
  static_assert((__is_assignable(TrivialMoveButNotCopy &,
                               TrivialMoveButNotCopy &&)));

  static_assert(__is_assignable(ACompleteType, ACompleteType));
  static_assert(!__is_assignable(AnIncompleteType, AnIncompleteType)); // expected-error {{incomplete type}}
  static_assert(!__is_assignable(AnIncompleteType[], AnIncompleteType[]));
  static_assert(!__is_assignable(AnIncompleteType[1], AnIncompleteType[1])); // expected-error {{incomplete type}}
  static_assert(!__is_assignable(void, void));
  static_assert(!__is_assignable(const volatile void, const volatile void));
}

void constructible_checks() {
  static_assert(__is_constructible(HasNoThrowConstructorWithArgs));
  static_assert(!__is_nothrow_constructible(HasNoThrowConstructorWithArgs)); // MSVC doesn't look into default args and gets this wrong.

  static_assert(__is_constructible(HasNoThrowConstructorWithArgs, HasCons));
  static_assert(__is_nothrow_constructible(HasNoThrowConstructorWithArgs, HasCons));

  static_assert(__is_constructible(NonTrivialDefault));
  static_assert(!__is_nothrow_constructible(NonTrivialDefault));

  static_assert(__is_constructible(int));
  static_assert(__is_nothrow_constructible(int));

  static_assert(!__is_constructible(NonPOD));
  static_assert(!__is_nothrow_constructible(NonPOD));

  static_assert(__is_constructible(NonPOD, int));
  static_assert(!__is_nothrow_constructible(NonPOD, int));

  // PR19178
  static_assert(!__is_constructible(Abstract));
  static_assert(!__is_nothrow_constructible(Abstract));

  // PR20228
  static_assert(__is_constructible(VariadicCtor,
                                 int, int, int, int, int, int, int, int, int));

  // PR25513
  static_assert(!__is_constructible(int(int)));
  static_assert(__is_constructible(int const &, long));

  static_assert(__is_constructible(ACompleteType));
  static_assert(__is_nothrow_constructible(ACompleteType));
  static_assert(!__is_constructible(AnIncompleteType)); // expected-error {{incomplete type}}
  static_assert(!__is_nothrow_constructible(AnIncompleteType)); // expected-error {{incomplete type}}
  static_assert(!__is_constructible(AnIncompleteType[]));
  static_assert(!__is_nothrow_constructible(AnIncompleteType[]));
  static_assert(!__is_constructible(AnIncompleteType[1])); // expected-error {{incomplete type}}
  static_assert(!__is_nothrow_constructible(AnIncompleteType[1])); // expected-error {{incomplete type}}
  static_assert(!__is_constructible(void));
  static_assert(!__is_nothrow_constructible(void));
  static_assert(!__is_constructible(const volatile void));
  static_assert(!__is_nothrow_constructible(const volatile void));
}

// Instantiation of __is_trivially_constructible
template<typename T, typename ...Args>
struct is_trivially_constructible {
  static const bool value = __is_trivially_constructible(T, Args...);
};

void is_trivially_constructible_test() {
  static_assert((is_trivially_constructible<int>::value));
  static_assert((is_trivially_constructible<int, int>::value));
  static_assert((is_trivially_constructible<int, float>::value));
  static_assert((is_trivially_constructible<int, int&>::value));
  static_assert((is_trivially_constructible<int, const int&>::value));
  static_assert((is_trivially_constructible<int, int>::value));
  static_assert((is_trivially_constructible<HasCopyAssign, HasCopyAssign>::value));
  static_assert((is_trivially_constructible<HasCopyAssign, const HasCopyAssign&>::value));
  static_assert((is_trivially_constructible<HasCopyAssign, HasCopyAssign&&>::value));
  static_assert((is_trivially_constructible<HasCopyAssign>::value));
  static_assert((is_trivially_constructible<NonTrivialDefault,
                                            const NonTrivialDefault&>::value));
  static_assert((is_trivially_constructible<NonTrivialDefault,
                                            NonTrivialDefault&&>::value));

  static_assert(!(is_trivially_constructible<int, int*>::value));
  static_assert(!(is_trivially_constructible<NonTrivialDefault>::value));
  static_assert(!(is_trivially_constructible<ThreeArgCtor, int*, char*, int&>::value));
  static_assert(!(is_trivially_constructible<Abstract>::value)); // PR19178

  static_assert(__is_trivially_constructible(ACompleteType));
  static_assert(!__is_trivially_constructible(AnIncompleteType)); // expected-error {{incomplete type}}
  static_assert(!__is_trivially_constructible(AnIncompleteType[]));
  static_assert(!__is_trivially_constructible(AnIncompleteType[1])); // expected-error {{incomplete type}}
  static_assert(!__is_trivially_constructible(void));
  static_assert(!__is_trivially_constructible(const volatile void));
}

template <class T, class RefType = T &>
struct ConvertsToRef {
  operator RefType() const { return static_cast<RefType>(obj); }
  mutable T obj = 42;
};

void reference_binds_to_temporary_checks() {
  static_assert(!(__reference_binds_to_temporary(int &, int &)));
  static_assert(!(__reference_binds_to_temporary(int &, int &&)));

  static_assert(!(__reference_binds_to_temporary(int const &, int &)));
  static_assert(!(__reference_binds_to_temporary(int const &, int const &)));
  static_assert(!(__reference_binds_to_temporary(int const &, int &&)));

  static_assert(!(__reference_binds_to_temporary(int &, long &))); // doesn't construct
  static_assert((__reference_binds_to_temporary(int const &, long &)));
  static_assert((__reference_binds_to_temporary(int const &, long &&)));
  static_assert((__reference_binds_to_temporary(int &&, long &)));

  using LRef = ConvertsToRef<int, int &>;
  using RRef = ConvertsToRef<int, int &&>;
  using CLRef = ConvertsToRef<int, const int &>;
  using LongRef = ConvertsToRef<long, long &>;
  static_assert((__is_constructible(int &, LRef)));
  static_assert(!(__reference_binds_to_temporary(int &, LRef)));

  static_assert((__is_constructible(int &&, RRef)));
  static_assert(!(__reference_binds_to_temporary(int &&, RRef)));

  static_assert((__is_constructible(int const &, CLRef)));
  static_assert(!(__reference_binds_to_temporary(int &&, CLRef)));

  static_assert((__is_constructible(int const &, LongRef)));
  static_assert((__reference_binds_to_temporary(int const &, LongRef)));

  // Test that it doesn't accept non-reference types as input.
  static_assert(!(__reference_binds_to_temporary(int, long)));

  static_assert((__reference_binds_to_temporary(const int &, long)));
}

void reference_constructs_from_temporary_checks() {
  static_assert(!__reference_constructs_from_temporary(int &, int &));
  static_assert(!__reference_constructs_from_temporary(int &, int &&));

  static_assert(!__reference_constructs_from_temporary(int const &, int &));
  static_assert(!__reference_constructs_from_temporary(int const &, int const &));
  static_assert(!__reference_constructs_from_temporary(int const &, int &&));

  static_assert(!__reference_constructs_from_temporary(int &, long &)); // doesn't construct

  static_assert(__reference_constructs_from_temporary(int const &, long &));
  static_assert(__reference_constructs_from_temporary(int const &, long &&));
  static_assert(__reference_constructs_from_temporary(int &&, long &));

  using LRef = ConvertsToRef<int, int &>;
  using RRef = ConvertsToRef<int, int &&>;
  using CLRef = ConvertsToRef<int, const int &>;
  using LongRef = ConvertsToRef<long, long &>;
  static_assert(__is_constructible(int &, LRef));
  static_assert(!__reference_constructs_from_temporary(int &, LRef));

  static_assert(__is_constructible(int &&, RRef));
  static_assert(!__reference_constructs_from_temporary(int &&, RRef));

  static_assert(__is_constructible(int const &, CLRef));
  static_assert(!__reference_constructs_from_temporary(int &&, CLRef));

  static_assert(__is_constructible(int const &, LongRef));
  static_assert(__reference_constructs_from_temporary(int const &, LongRef));

  // Test that it doesn't accept non-reference types as input.
  static_assert(!__reference_constructs_from_temporary(int, long));

  static_assert(__reference_constructs_from_temporary(const int &, long));

  // Additional checks
  static_assert(__reference_constructs_from_temporary(POD const&, Derives));
  static_assert(__reference_constructs_from_temporary(int&&, int));
  static_assert(__reference_constructs_from_temporary(const int&, int));
  static_assert(!__reference_constructs_from_temporary(int&&, int&&));
  static_assert(!__reference_constructs_from_temporary(const int&, int&&));
  static_assert(__reference_constructs_from_temporary(int&&, long&&));
  static_assert(__reference_constructs_from_temporary(int&&, long));
}

void array_rank() {
  static_assert(__array_rank(IntAr) == 1);
  static_assert(__array_rank(ConstIntArAr) == 2);
}

void array_extent() {
  static_assert(__array_extent(IntAr, 0) == 10);
  static_assert(__array_extent(ConstIntArAr, 0) == 4);
  static_assert(__array_extent(ConstIntArAr, 1) == 10);
}

void is_destructible_test() {
  static_assert(__is_destructible(int));
  static_assert(__is_destructible(int[2]));
  static_assert(!__is_destructible(int[]));
  static_assert(!__is_destructible(void));
  static_assert(__is_destructible(int &));
  static_assert(__is_destructible(HasDest));
  static_assert(!__is_destructible(AllPrivate));
  static_assert(__is_destructible(SuperNonTrivialStruct));
  static_assert(__is_destructible(AllDefaulted));
  static_assert(!__is_destructible(AllDeleted));
  static_assert(__is_destructible(ThrowingDtor));
  static_assert(__is_destructible(NoThrowDtor));

  static_assert(__is_destructible(ACompleteType));
  static_assert(!__is_destructible(AnIncompleteType)); // expected-error {{incomplete type}}
  static_assert(!__is_destructible(AnIncompleteType[]));
  static_assert(!__is_destructible(AnIncompleteType[1])); // expected-error {{incomplete type}}
  static_assert(!__is_destructible(void));
  static_assert(!__is_destructible(const volatile void));
}

void is_nothrow_destructible_test() {
  static_assert(__is_nothrow_destructible(int));
  static_assert(__is_nothrow_destructible(int[2]));
  static_assert(!__is_nothrow_destructible(int[]));
  static_assert(!__is_nothrow_destructible(void));
  static_assert(__is_nothrow_destructible(int &));
  static_assert(__is_nothrow_destructible(HasDest));
  static_assert(!__is_nothrow_destructible(AllPrivate));
  static_assert(__is_nothrow_destructible(SuperNonTrivialStruct));
  static_assert(__is_nothrow_destructible(AllDefaulted));
  static_assert(!__is_nothrow_destructible(AllDeleted));
  static_assert(!__is_nothrow_destructible(ThrowingDtor));
  static_assert(__is_nothrow_destructible(NoExceptDtor));
  static_assert(__is_nothrow_destructible(NoThrowDtor));

  static_assert(__is_nothrow_destructible(ACompleteType));
  static_assert(!__is_nothrow_destructible(AnIncompleteType)); // expected-error {{incomplete type}}
  static_assert(!__is_nothrow_destructible(AnIncompleteType[]));
  static_assert(!__is_nothrow_destructible(AnIncompleteType[1])); // expected-error {{incomplete type}}
  static_assert(!__is_nothrow_destructible(void));
  static_assert(!__is_nothrow_destructible(const volatile void));
}

void is_trivially_destructible_test() {
  static_assert(__is_trivially_destructible(int));
  static_assert(__is_trivially_destructible(int[2]));
  static_assert(!__is_trivially_destructible(int[]));
  static_assert(!__is_trivially_destructible(void));
  static_assert(__is_trivially_destructible(int &));
  static_assert(!__is_trivially_destructible(HasDest));
  static_assert(!__is_trivially_destructible(AllPrivate));
  static_assert(!__is_trivially_destructible(SuperNonTrivialStruct));
  static_assert(__is_trivially_destructible(AllDefaulted));
  static_assert(!__is_trivially_destructible(AllDeleted));
  static_assert(!__is_trivially_destructible(ThrowingDtor));
  static_assert(!__is_trivially_destructible(NoThrowDtor));

  static_assert(__is_trivially_destructible(ACompleteType));
  static_assert(!__is_trivially_destructible(AnIncompleteType)); // expected-error {{incomplete type}}
  static_assert(!__is_trivially_destructible(AnIncompleteType[]));
  static_assert(!__is_trivially_destructible(AnIncompleteType[1])); // expected-error {{incomplete type}}
  static_assert(!__is_trivially_destructible(void));
  static_assert(!__is_trivially_destructible(const volatile void));
}

static_assert(!__has_unique_object_representations(void), "void is never unique");
static_assert(!__has_unique_object_representations(const void), "void is never unique");
static_assert(!__has_unique_object_representations(volatile void), "void is never unique");
static_assert(!__has_unique_object_representations(const volatile void), "void is never unique");

static_assert(__has_unique_object_representations(int), "integrals are");
static_assert(__has_unique_object_representations(const int), "integrals are");
static_assert(__has_unique_object_representations(volatile int), "integrals are");
static_assert(__has_unique_object_representations(const volatile int), "integrals are");

static_assert(__has_unique_object_representations(void *), "as are pointers");
static_assert(__has_unique_object_representations(const void *), "as are pointers");
static_assert(__has_unique_object_representations(volatile void *), "are pointers");
static_assert(__has_unique_object_representations(const volatile void *), "as are pointers");

static_assert(__has_unique_object_representations(int *), "as are pointers");
static_assert(__has_unique_object_representations(const int *), "as are pointers");
static_assert(__has_unique_object_representations(volatile int *), "as are pointers");
static_assert(__has_unique_object_representations(const volatile int *), "as are pointers");

class C {};
using FP = int (*)(int);
using PMF = int (C::*)(int);
using PMD = int C::*;

static_assert(__has_unique_object_representations(FP), "even function pointers");
static_assert(__has_unique_object_representations(const FP), "even function pointers");
static_assert(__has_unique_object_representations(volatile FP), "even function pointers");
static_assert(__has_unique_object_representations(const volatile FP), "even function pointers");

static_assert(__has_unique_object_representations(PMF), "and pointer to members");
static_assert(__has_unique_object_representations(const PMF), "and pointer to members");
static_assert(__has_unique_object_representations(volatile PMF), "and pointer to members");
static_assert(__has_unique_object_representations(const volatile PMF), "and pointer to members");

static_assert(__has_unique_object_representations(PMD), "and pointer to members");
static_assert(__has_unique_object_representations(const PMD), "and pointer to members");
static_assert(__has_unique_object_representations(volatile PMD), "and pointer to members");
static_assert(__has_unique_object_representations(const volatile PMD), "and pointer to members");

static_assert(__has_unique_object_representations(bool), "yes, all integral types");
static_assert(__has_unique_object_representations(char), "yes, all integral types");
static_assert(__has_unique_object_representations(signed char), "yes, all integral types");
static_assert(__has_unique_object_representations(unsigned char), "yes, all integral types");
static_assert(__has_unique_object_representations(short), "yes, all integral types");
static_assert(__has_unique_object_representations(unsigned short), "yes, all integral types");
static_assert(__has_unique_object_representations(int), "yes, all integral types");
static_assert(__has_unique_object_representations(unsigned int), "yes, all integral types");
static_assert(__has_unique_object_representations(long), "yes, all integral types");
static_assert(__has_unique_object_representations(unsigned long), "yes, all integral types");
static_assert(__has_unique_object_representations(long long), "yes, all integral types");
static_assert(__has_unique_object_representations(unsigned long long), "yes, all integral types");
static_assert(__has_unique_object_representations(wchar_t), "yes, all integral types");
static_assert(__has_unique_object_representations(char16_t), "yes, all integral types");
static_assert(__has_unique_object_representations(char32_t), "yes, all integral types");

static_assert(!__has_unique_object_representations(void), "but not void!");
static_assert(!__has_unique_object_representations(decltype(nullptr)), "or nullptr_t");
static_assert(!__has_unique_object_representations(float), "definitely not Floating Point");
static_assert(!__has_unique_object_representations(double), "definitely not Floating Point");
static_assert(!__has_unique_object_representations(long double), "definitely not Floating Point");

struct NoPadding {
  int a;
  int b;
};

static_assert(__has_unique_object_representations(NoPadding), "types without padding are");

struct InheritsFromNoPadding : NoPadding {
  int c;
  int d;
};

static_assert(__has_unique_object_representations(InheritsFromNoPadding), "types without padding are");

struct VirtuallyInheritsFromNoPadding : virtual NoPadding {
  int c;
  int d;
};

static_assert(!__has_unique_object_representations(VirtuallyInheritsFromNoPadding), "No virtual inheritance");

struct Padding {
  char a;
  int b;
};

//static_assert(!__has_unique_object_representations(Padding), "but not with padding");

struct InheritsFromPadding : Padding {
  int c;
  int d;
};

static_assert(!__has_unique_object_representations(InheritsFromPadding), "or its subclasses");

struct TailPadding {
  int a;
  char b;
};

static_assert(!__has_unique_object_representations(TailPadding), "even at the end");

struct TinyStruct {
  char a;
};

static_assert(__has_unique_object_representations(TinyStruct), "Should be no padding");

struct InheritsFromTinyStruct : TinyStruct {
  int b;
};

static_assert(!__has_unique_object_representations(InheritsFromTinyStruct), "Inherit causes padding");

union NoPaddingUnion {
  int a;
  unsigned int b;
};

static_assert(__has_unique_object_representations(NoPaddingUnion), "unions follow the same rules as structs");

union PaddingUnion {
  int a;
  long long b;
};

static_assert(!__has_unique_object_representations(PaddingUnion), "unions follow the same rules as structs");

struct NotTriviallyCopyable {
  int x;
  NotTriviallyCopyable(const NotTriviallyCopyable &) {}
};

static_assert(!__has_unique_object_representations(NotTriviallyCopyable), "must be trivially copyable");

struct HasNonUniqueMember {
  float x;
};

static_assert(!__has_unique_object_representations(HasNonUniqueMember), "all members must be unique");

enum ExampleEnum { xExample,
                   yExample };
enum LLEnum : long long { xLongExample,
                          yLongExample };

static_assert(__has_unique_object_representations(ExampleEnum), "Enums are integrals, so unique!");
static_assert(__has_unique_object_representations(LLEnum), "Enums are integrals, so unique!");

enum class ExampleEnumClass { xExample,
                              yExample };
enum class LLEnumClass : long long { xLongExample,
                                     yLongExample };

static_assert(__has_unique_object_representations(ExampleEnumClass), "Enums are integrals, so unique!");
static_assert(__has_unique_object_representations(LLEnumClass), "Enums are integrals, so unique!");

// because references aren't trivially copyable.
static_assert(!__has_unique_object_representations(int &), "No references!");
static_assert(!__has_unique_object_representations(const int &), "No references!");
static_assert(!__has_unique_object_representations(volatile int &), "No references!");
static_assert(!__has_unique_object_representations(const volatile int &), "No references!");
static_assert(!__has_unique_object_representations(Empty), "No empty types!");
static_assert(!__has_unique_object_representations(EmptyUnion), "No empty types!");

class Compressed : Empty {
  int x;
};

static_assert(__has_unique_object_representations(Compressed), "But inheriting from one is ok");

class EmptyInheritor : Compressed {};

static_assert(__has_unique_object_representations(EmptyInheritor), "As long as the base has items, empty is ok");

class Dynamic {
  virtual void A();
  int i;
};

static_assert(!__has_unique_object_representations(Dynamic), "Dynamic types are not valid");

class InheritsDynamic : Dynamic {
  int j;
};

static_assert(!__has_unique_object_representations(InheritsDynamic), "Dynamic types are not valid");

static_assert(__has_unique_object_representations(int[42]), "Arrays are fine, as long as their value type is");
static_assert(__has_unique_object_representations(int[]), "Arrays are fine, as long as their value type is");
static_assert(__has_unique_object_representations(int[][42]), "Arrays are fine, as long as their value type is");
static_assert(!__has_unique_object_representations(double[42]), "So no array of doubles!");
static_assert(!__has_unique_object_representations(double[]), "So no array of doubles!");
static_assert(!__has_unique_object_representations(double[][42]), "So no array of doubles!");

struct __attribute__((aligned(16))) WeirdAlignment {
  int i;
};
union __attribute__((aligned(16))) WeirdAlignmentUnion {
  int i;
};
static_assert(!__has_unique_object_representations(WeirdAlignment), "Alignment causes padding");
static_assert(!__has_unique_object_representations(WeirdAlignmentUnion), "Alignment causes padding");
static_assert(!__has_unique_object_representations(WeirdAlignment[42]), "Also no arrays that have padding");

struct __attribute__((packed)) PackedNoPadding1 {
  short i;
  int j;
};
struct __attribute__((packed)) PackedNoPadding2 {
  int j;
  short i;
};
static_assert(__has_unique_object_representations(PackedNoPadding1), "Packed structs have no padding");
static_assert(__has_unique_object_representations(PackedNoPadding2), "Packed structs have no padding");

static_assert(!__has_unique_object_representations(int(int)), "Functions are not unique");
static_assert(!__has_unique_object_representations(int(int) const), "Functions are not unique");
static_assert(!__has_unique_object_representations(int(int) volatile), "Functions are not unique");
static_assert(!__has_unique_object_representations(int(int) const volatile), "Functions are not unique");
static_assert(!__has_unique_object_representations(int(int) &), "Functions are not unique");
static_assert(!__has_unique_object_representations(int(int) const &), "Functions are not unique");
static_assert(!__has_unique_object_representations(int(int) volatile &), "Functions are not unique");
static_assert(!__has_unique_object_representations(int(int) const volatile &), "Functions are not unique");
static_assert(!__has_unique_object_representations(int(int) &&), "Functions are not unique");
static_assert(!__has_unique_object_representations(int(int) const &&), "Functions are not unique");
static_assert(!__has_unique_object_representations(int(int) volatile &&), "Functions are not unique");
static_assert(!__has_unique_object_representations(int(int) const volatile &&), "Functions are not unique");

static_assert(!__has_unique_object_representations(int(int, ...)), "Functions are not unique");
static_assert(!__has_unique_object_representations(int(int, ...) const), "Functions are not unique");
static_assert(!__has_unique_object_representations(int(int, ...) volatile), "Functions are not unique");
static_assert(!__has_unique_object_representations(int(int, ...) const volatile), "Functions are not unique");
static_assert(!__has_unique_object_representations(int(int, ...) &), "Functions are not unique");
static_assert(!__has_unique_object_representations(int(int, ...) const &), "Functions are not unique");
static_assert(!__has_unique_object_representations(int(int, ...) volatile &), "Functions are not unique");
static_assert(!__has_unique_object_representations(int(int, ...) const volatile &), "Functions are not unique");
static_assert(!__has_unique_object_representations(int(int, ...) &&), "Functions are not unique");
static_assert(!__has_unique_object_representations(int(int, ...) const &&), "Functions are not unique");
static_assert(!__has_unique_object_representations(int(int, ...) volatile &&), "Functions are not unique");
static_assert(!__has_unique_object_representations(int(int, ...) const volatile &&), "Functions are not unique");

void foo(){
  static auto lambda = []() {};
  static_assert(!__has_unique_object_representations(decltype(lambda)), "Lambdas follow struct rules");
  int i;
  static auto lambda2 = [i]() {};
  static_assert(__has_unique_object_representations(decltype(lambda2)), "Lambdas follow struct rules");
}

struct PaddedBitfield {
  char c : 6;
  char d : 1;
};

struct UnPaddedBitfield {
  char c : 6;
  char d : 2;
};

struct AlignedPaddedBitfield {
  char c : 6;
  __attribute__((aligned(1)))
  char d : 2;
};

struct UnnamedBitfield {
  int named : 8;
  int : 24;
};

struct __attribute__((packed)) UnnamedBitfieldPacked {
  int named : 8;
  int : 24;
};

struct UnnamedEmptyBitfield {
  int named;
  int : 0;
};

struct UnnamedEmptyBitfieldSplit {
  short named;
  int : 0;
  short also_named;
};

static_assert(!__has_unique_object_representations(PaddedBitfield), "Bitfield padding");
static_assert(__has_unique_object_representations(UnPaddedBitfield), "Bitfield padding");
static_assert(!__has_unique_object_representations(AlignedPaddedBitfield), "Bitfield padding");
static_assert(!__has_unique_object_representations(UnnamedBitfield), "Bitfield padding");
static_assert(!__has_unique_object_representations(UnnamedBitfieldPacked), "Bitfield padding");
static_assert(__has_unique_object_representations(UnnamedEmptyBitfield), "Bitfield padding");
static_assert(sizeof(UnnamedEmptyBitfieldSplit) != (sizeof(short) * 2), "Wrong size");
static_assert(!__has_unique_object_representations(UnnamedEmptyBitfieldSplit), "Bitfield padding");

struct BoolBitfield {
  bool b : 8;
};

static_assert(__has_unique_object_representations(BoolBitfield), "Bitfield bool");

struct BoolBitfield2 {
  bool b : 16;
};

static_assert(!__has_unique_object_representations(BoolBitfield2), "Bitfield bool");

struct GreaterSizeBitfield {
  //expected-warning@+1 {{width of bit-field 'n'}}
  int n : 1024;
};

static_assert(sizeof(GreaterSizeBitfield) == 128, "Bitfield Size");
static_assert(!__has_unique_object_representations(GreaterSizeBitfield), "Bitfield padding");

struct StructWithRef {
  int &I;
};

static_assert(__has_unique_object_representations(StructWithRef), "References are still unique");

struct NotUniqueBecauseTailPadding {
  int &r;
  char a;
};
struct CanBeUniqueIfNoPadding : NotUniqueBecauseTailPadding {
  char b[7];
};

static_assert(!__has_unique_object_representations(NotUniqueBecauseTailPadding),
              "non trivial");
// Can be unique on Itanium, since the is child class' data is 'folded' into the
// parent's tail padding.
static_assert(sizeof(CanBeUniqueIfNoPadding) != 16 ||
              __has_unique_object_representations(CanBeUniqueIfNoPadding),
              "inherit from std layout");

namespace ErrorType {
  struct S; //expected-note{{forward declaration of 'ErrorType::S'}}

  struct T {
        S t; //expected-error{{field has incomplete type 'S'}}
  };
  bool b = __has_unique_object_representations(T);
};

static_assert(!__has_unique_object_representations(_BitInt(7)), "BitInt:");
static_assert(__has_unique_object_representations(_BitInt(8)), "BitInt:");
static_assert(!__has_unique_object_representations(_BitInt(127)), "BitInt:");
static_assert(__has_unique_object_representations(_BitInt(128)), "BitInt:");


namespace PR46209 {
  // Foo has both a trivial assignment operator and a non-trivial one.
  struct Foo {
    Foo &operator=(const Foo &) & { return *this; }
    Foo &operator=(const Foo &) && = default;
  };

  // Bar's copy assignment calls Foo's non-trivial assignment.
  struct Bar {
    Foo foo;
  };

  static_assert(!__is_trivially_assignable(Foo &, const Foo &));
  static_assert(!__is_trivially_assignable(Bar &, const Bar &));

  // Foo2 has both a trivial assignment operator and a non-trivial one.
  struct Foo2 {
    Foo2 &operator=(const Foo2 &) & = default;
    Foo2 &operator=(const Foo2 &) && { return *this; }
  };

  // Bar2's copy assignment calls Foo2's trivial assignment.
  struct Bar2 {
    Foo2 foo;
  };

  static_assert(__is_trivially_assignable(Foo2 &, const Foo2 &));
  static_assert(__is_trivially_assignable(Bar2 &, const Bar2 &));
}

namespace ConstClass {
  struct A {
    A &operator=(const A&) = default;
  };
  struct B {
    const A a;
  };
  static_assert(!__is_trivially_assignable(B&, const B&));
}

namespace type_trait_expr_numargs_overflow {
// Make sure that TypeTraitExpr can store 16 bits worth of arguments.
#define T4(X) X,X,X,X
#define T16(X) T4(X),T4(X),T4(X),T4(X)
#define T64(X) T16(X),T16(X),T16(X),T16(X)
#define T256(X) T64(X),T64(X),T64(X),T64(X)
#define T1024(X) T256(X),T256(X),T256(X),T256(X)
#define T4096(X) T1024(X),T1024(X),T1024(X),T1024(X)
#define T16384(X) T4096(X),T4096(X),T4096(X),T4096(X)
#define T32768(X) T16384(X),T16384(X)
void test() { (void) __is_constructible(int, T32768(int)); }
#undef T4
#undef T16
#undef T64
#undef T256
#undef T1024
#undef T4096
#undef T16384
#undef T32768
} // namespace type_trait_expr_numargs_overflow

namespace is_trivially_relocatable {

static_assert(!__is_trivially_relocatable(void));
static_assert(__is_trivially_relocatable(int));
static_assert(__is_trivially_relocatable(int[]));
static_assert(__is_trivially_relocatable(const int));
static_assert(__is_trivially_relocatable(volatile int));

enum Enum {};
static_assert(__is_trivially_relocatable(Enum));
static_assert(__is_trivially_relocatable(Enum[]));

union Union {int x;};
static_assert(__is_trivially_relocatable(Union));
static_assert(__is_trivially_relocatable(Union[]));

struct Trivial {};
static_assert(__is_trivially_relocatable(Trivial));
static_assert(__is_trivially_relocatable(const Trivial));
static_assert(__is_trivially_relocatable(volatile Trivial));

static_assert(__is_trivially_relocatable(Trivial[]));
static_assert(__is_trivially_relocatable(const Trivial[]));
static_assert(__is_trivially_relocatable(volatile Trivial[]));

static_assert(__is_trivially_relocatable(int[10]));
static_assert(__is_trivially_relocatable(const int[10]));
static_assert(__is_trivially_relocatable(volatile int[10]));

static_assert(__is_trivially_relocatable(int[10][10]));
static_assert(__is_trivially_relocatable(const int[10][10]));
static_assert(__is_trivially_relocatable(volatile int[10][10]));

static_assert(__is_trivially_relocatable(int[]));
static_assert(__is_trivially_relocatable(const int[]));
static_assert(__is_trivially_relocatable(volatile int[]));

static_assert(__is_trivially_relocatable(int[][10]));
static_assert(__is_trivially_relocatable(const int[][10]));
static_assert(__is_trivially_relocatable(volatile int[][10]));

struct Incomplete; // expected-note {{forward declaration of 'is_trivially_relocatable::Incomplete'}}
bool unused = __is_trivially_relocatable(Incomplete); // expected-error {{incomplete type}}

struct NontrivialDtor {
  ~NontrivialDtor() {}
};
static_assert(!__is_trivially_relocatable(NontrivialDtor));
static_assert(!__is_trivially_relocatable(NontrivialDtor[]));
static_assert(!__is_trivially_relocatable(const NontrivialDtor));
static_assert(!__is_trivially_relocatable(volatile NontrivialDtor));

struct NontrivialCopyCtor {
  NontrivialCopyCtor(const NontrivialCopyCtor&) {}
};
static_assert(!__is_trivially_relocatable(NontrivialCopyCtor));
static_assert(!__is_trivially_relocatable(NontrivialCopyCtor[]));

struct NontrivialMoveCtor {
  NontrivialMoveCtor(NontrivialMoveCtor&&) {}
};
static_assert(!__is_trivially_relocatable(NontrivialMoveCtor));
static_assert(!__is_trivially_relocatable(NontrivialMoveCtor[]));

struct [[clang::trivial_abi]] TrivialAbiNontrivialDtor {
  ~TrivialAbiNontrivialDtor() {}
};
static_assert(__is_trivially_relocatable(TrivialAbiNontrivialDtor));
static_assert(__is_trivially_relocatable(TrivialAbiNontrivialDtor[]));
static_assert(__is_trivially_relocatable(const TrivialAbiNontrivialDtor));
static_assert(__is_trivially_relocatable(volatile TrivialAbiNontrivialDtor));

struct [[clang::trivial_abi]] TrivialAbiNontrivialCopyCtor {
  TrivialAbiNontrivialCopyCtor(const TrivialAbiNontrivialCopyCtor&) {}
};
static_assert(__is_trivially_relocatable(TrivialAbiNontrivialCopyCtor));
static_assert(__is_trivially_relocatable(TrivialAbiNontrivialCopyCtor[]));
static_assert(__is_trivially_relocatable(const TrivialAbiNontrivialCopyCtor));
static_assert(__is_trivially_relocatable(volatile TrivialAbiNontrivialCopyCtor));

// A more complete set of tests for the behavior of trivial_abi can be found in
// clang/test/SemaCXX/attr-trivial-abi.cpp
struct [[clang::trivial_abi]] TrivialAbiNontrivialMoveCtor {
  TrivialAbiNontrivialMoveCtor(TrivialAbiNontrivialMoveCtor&&) {}
};
static_assert(__is_trivially_relocatable(TrivialAbiNontrivialMoveCtor));
static_assert(__is_trivially_relocatable(TrivialAbiNontrivialMoveCtor[]));
static_assert(__is_trivially_relocatable(const TrivialAbiNontrivialMoveCtor));
static_assert(__is_trivially_relocatable(volatile TrivialAbiNontrivialMoveCtor));

} // namespace is_trivially_relocatable

namespace is_trivially_equality_comparable {
struct ForwardDeclared; // expected-note {{forward declaration of 'is_trivially_equality_comparable::ForwardDeclared'}}
static_assert(!__is_trivially_equality_comparable(ForwardDeclared)); // expected-error {{incomplete type 'ForwardDeclared' used in type trait expression}}

static_assert(!__is_trivially_equality_comparable(void));
static_assert(__is_trivially_equality_comparable(int));
static_assert(!__is_trivially_equality_comparable(int[]));
static_assert(!__is_trivially_equality_comparable(int[3]));
static_assert(!__is_trivially_equality_comparable(float));
static_assert(!__is_trivially_equality_comparable(double));
static_assert(!__is_trivially_equality_comparable(long double));

struct NonTriviallyEqualityComparableNoComparator {
  int i;
  int j;
};
static_assert(!__is_trivially_equality_comparable(NonTriviallyEqualityComparableNoComparator));

struct NonTriviallyEqualityComparableNonDefaultedComparator {
  int i;
  int j;
  bool operator==(const NonTriviallyEqualityComparableNonDefaultedComparator&);
};
static_assert(!__is_trivially_equality_comparable(NonTriviallyEqualityComparableNonDefaultedComparator));

#if __cplusplus >= 202002L

struct TriviallyEqualityComparable {
  int i;
  int j;

  void func();
  bool operator==(int) const { return false; }

  bool operator==(const TriviallyEqualityComparable&) const = default;
};
static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable));

struct TriviallyEqualityComparableContainsArray {
  int a[4];

  bool operator==(const TriviallyEqualityComparableContainsArray&) const = default;
};
static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparableContainsArray));

struct TriviallyEqualityComparableContainsMultiDimensionArray {
  int a[4][4];

  bool operator==(const TriviallyEqualityComparableContainsMultiDimensionArray&) const = default;
};
static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparableContainsMultiDimensionArray));

auto GetNonCapturingLambda() { return [](){ return 42; }; }

struct TriviallyEqualityComparableContainsLambda {
  [[no_unique_address]] decltype(GetNonCapturingLambda()) l;
  int i;

  bool operator==(const TriviallyEqualityComparableContainsLambda&) const = default;
};
static_assert(!__is_trivially_equality_comparable(decltype(GetNonCapturingLambda()))); // padding
static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparableContainsLambda));

struct TriviallyEqualityComparableNonTriviallyCopyable {
  TriviallyEqualityComparableNonTriviallyCopyable(const TriviallyEqualityComparableNonTriviallyCopyable&);
  ~TriviallyEqualityComparableNonTriviallyCopyable();
  bool operator==(const TriviallyEqualityComparableNonTriviallyCopyable&) const = default;
  int i;
};
static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparableNonTriviallyCopyable));

struct NotTriviallyEqualityComparableHasPadding {
  short i;
  int j;

  bool operator==(const NotTriviallyEqualityComparableHasPadding&) const = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasPadding));

struct NotTriviallyEqualityComparableHasFloat {
  float i;
  int j;

  bool operator==(const NotTriviallyEqualityComparableHasFloat&) const = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasFloat));

struct NotTriviallyEqualityComparableHasTailPadding {
  int i;
  char j;

  bool operator==(const NotTriviallyEqualityComparableHasTailPadding&) const = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasTailPadding));

struct NotTriviallyEqualityComparableBase : NotTriviallyEqualityComparableHasTailPadding {
  char j;

  bool operator==(const NotTriviallyEqualityComparableBase&) const = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBase));

class TriviallyEqualityComparablePaddedOutBase {
  int i;
  char c;

public:
  bool operator==(const TriviallyEqualityComparablePaddedOutBase&) const = default;
};
static_assert(!__is_trivially_equality_comparable(TriviallyEqualityComparablePaddedOutBase));

struct TriviallyEqualityComparablePaddedOut : TriviallyEqualityComparablePaddedOutBase {
  char j[3];

  bool operator==(const TriviallyEqualityComparablePaddedOut&) const = default;
};
static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparablePaddedOut));

struct TriviallyEqualityComparable1 {
  char i;

  bool operator==(const TriviallyEqualityComparable1&) const = default;
};
static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable1));

struct TriviallyEqualityComparable2 {
  int i;

  bool operator==(const TriviallyEqualityComparable2&) const = default;
};
static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable2));

struct NotTriviallyEqualityComparableTriviallyEqualityComparableBases
    : TriviallyEqualityComparable1, TriviallyEqualityComparable2 {
  bool operator==(const NotTriviallyEqualityComparableTriviallyEqualityComparableBases&) const = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableTriviallyEqualityComparableBases));

struct NotTriviallyEqualityComparableBitfield {
  int i : 1;

  bool operator==(const NotTriviallyEqualityComparableBitfield&) const = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBitfield));

// TODO: This is trivially equality comparable
struct NotTriviallyEqualityComparableBitfieldFilled {
  char i : __CHAR_BIT__;

  bool operator==(const NotTriviallyEqualityComparableBitfieldFilled&) const = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBitfield));

union U {
  int i;

  bool operator==(const U&) const = default;
};

struct NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion {
  U u;

  bool operator==(const NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion&) const = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion));

struct NotTriviallyEqualityComparableExplicitlyDeleted {
  int i;

  bool operator==(const NotTriviallyEqualityComparableExplicitlyDeleted&) const = delete;
};

struct NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct {
  NotTriviallyEqualityComparableExplicitlyDeleted u;

  bool operator==(const NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct&) const = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct));

struct NotTriviallyEqualityComparableHasReferenceMember {
  int& i;

  bool operator==(const NotTriviallyEqualityComparableHasReferenceMember&) const = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasReferenceMember));

struct NotTriviallyEqualityComparableNonTriviallyComparableBaseBase {
  int i;

  bool operator==(const NotTriviallyEqualityComparableNonTriviallyComparableBaseBase&) const {
    return true;
  }
};

struct NotTriviallyEqualityComparableNonTriviallyComparableBase : NotTriviallyEqualityComparableNonTriviallyComparableBaseBase {
  int i;

  bool operator==(const NotTriviallyEqualityComparableNonTriviallyComparableBase&) const = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableNonTriviallyComparableBase));

enum E {
  a,
  b
};
bool operator==(E, E) { return false; }
static_assert(!__is_trivially_equality_comparable(E));

struct NotTriviallyEqualityComparableHasEnum {
  E e;
  bool operator==(const NotTriviallyEqualityComparableHasEnum&) const = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasEnum));

struct NotTriviallyEqualityComparableNonTriviallyEqualityComparableArrs {
  E e[1];

  bool operator==(const NotTriviallyEqualityComparableNonTriviallyEqualityComparableArrs&) const = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableNonTriviallyEqualityComparableArrs));

struct NotTriviallyEqualityComparableNonTriviallyEqualityComparableArrs2 {
  E e[1][1];

  bool operator==(const NotTriviallyEqualityComparableNonTriviallyEqualityComparableArrs2&) const = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableNonTriviallyEqualityComparableArrs2));

namespace hidden_friend {

struct TriviallyEqualityComparable {
  int i;
  int j;

  void func();
  bool operator==(int) const { return false; }

  friend bool operator==(const TriviallyEqualityComparable&, const TriviallyEqualityComparable&) = default;
};
static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable));

struct TriviallyEqualityComparableNonTriviallyCopyable {
  TriviallyEqualityComparableNonTriviallyCopyable(const TriviallyEqualityComparableNonTriviallyCopyable&);
  ~TriviallyEqualityComparableNonTriviallyCopyable();
  friend bool operator==(const TriviallyEqualityComparableNonTriviallyCopyable&, const TriviallyEqualityComparableNonTriviallyCopyable&) = default;
  int i;
};
static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparableNonTriviallyCopyable));

struct NotTriviallyEqualityComparableHasPadding {
  short i;
  int j;

  friend bool operator==(const NotTriviallyEqualityComparableHasPadding&, const NotTriviallyEqualityComparableHasPadding&) = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasPadding));

struct NotTriviallyEqualityComparableHasFloat {
  float i;
  int j;

  friend bool operator==(const NotTriviallyEqualityComparableHasFloat&, const NotTriviallyEqualityComparableHasFloat&) = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasFloat));

struct NotTriviallyEqualityComparableHasTailPadding {
  int i;
  char j;

  friend bool operator==(const NotTriviallyEqualityComparableHasTailPadding&, const NotTriviallyEqualityComparableHasTailPadding&) = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasTailPadding));

struct NotTriviallyEqualityComparableBase : NotTriviallyEqualityComparableHasTailPadding {
  char j;

  friend bool operator==(const NotTriviallyEqualityComparableBase&, const NotTriviallyEqualityComparableBase&) = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBase));

class TriviallyEqualityComparablePaddedOutBase {
  int i;
  char c;

public:
  friend bool operator==(const TriviallyEqualityComparablePaddedOutBase&, const TriviallyEqualityComparablePaddedOutBase&) = default;
};
static_assert(!__is_trivially_equality_comparable(TriviallyEqualityComparablePaddedOutBase));

struct TriviallyEqualityComparablePaddedOut : TriviallyEqualityComparablePaddedOutBase {
  char j[3];

  friend bool operator==(const TriviallyEqualityComparablePaddedOut&, const TriviallyEqualityComparablePaddedOut&) = default;
};
static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparablePaddedOut));

struct TriviallyEqualityComparable1 {
  char i;

  friend bool operator==(const TriviallyEqualityComparable1&, const TriviallyEqualityComparable1&) = default;
};
static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable1));

struct TriviallyEqualityComparable2 {
  int i;

  friend bool operator==(const TriviallyEqualityComparable2&, const TriviallyEqualityComparable2&) = default;
};
static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable2));

struct NotTriviallyEqualityComparableTriviallyEqualityComparableBases
    : TriviallyEqualityComparable1, TriviallyEqualityComparable2 {
  friend bool operator==(const NotTriviallyEqualityComparableTriviallyEqualityComparableBases&, const NotTriviallyEqualityComparableTriviallyEqualityComparableBases&) = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableTriviallyEqualityComparableBases));

struct NotTriviallyEqualityComparableBitfield {
  int i : 1;

  friend bool operator==(const NotTriviallyEqualityComparableBitfield&, const NotTriviallyEqualityComparableBitfield&) = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBitfield));

// TODO: This is trivially equality comparable
struct NotTriviallyEqualityComparableBitfieldFilled {
  char i : __CHAR_BIT__;

  friend bool operator==(const NotTriviallyEqualityComparableBitfieldFilled&, const NotTriviallyEqualityComparableBitfieldFilled&) = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBitfield));

union U {
  int i;

  friend bool operator==(const U&, const U&) = default;
};

struct NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion {
  U u;

  friend bool operator==(const NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion&, const NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion&) = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion));

struct NotTriviallyEqualityComparableExplicitlyDeleted {
  int i;

  friend bool operator==(const NotTriviallyEqualityComparableExplicitlyDeleted&, const NotTriviallyEqualityComparableExplicitlyDeleted&) = delete;
};

struct NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct {
  NotTriviallyEqualityComparableExplicitlyDeleted u;

  friend bool operator==(const NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct&, const NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct&) = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct));

struct NotTriviallyEqualityComparableHasReferenceMember {
  int& i;

  friend bool operator==(const NotTriviallyEqualityComparableHasReferenceMember&, const NotTriviallyEqualityComparableHasReferenceMember&) = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasReferenceMember));

enum E {
  a,
  b
};
bool operator==(E, E) { return false; }
static_assert(!__is_trivially_equality_comparable(E));

struct NotTriviallyEqualityComparableHasEnum {
  E e;
  friend bool operator==(const NotTriviallyEqualityComparableHasEnum&, const NotTriviallyEqualityComparableHasEnum&) = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasEnum));

struct NonTriviallyEqualityComparableValueComparisonNonTriviallyCopyable {
  int i;
  NonTriviallyEqualityComparableValueComparisonNonTriviallyCopyable(const NonTriviallyEqualityComparableValueComparisonNonTriviallyCopyable&);

  friend bool operator==(NonTriviallyEqualityComparableValueComparisonNonTriviallyCopyable, NonTriviallyEqualityComparableValueComparisonNonTriviallyCopyable) = default;
};
static_assert(!__is_trivially_equality_comparable(NonTriviallyEqualityComparableValueComparisonNonTriviallyCopyable));

struct TriviallyEqualityComparableRefComparisonNonTriviallyCopyable {
  int i;
  TriviallyEqualityComparableRefComparisonNonTriviallyCopyable(const TriviallyEqualityComparableRefComparisonNonTriviallyCopyable&);

  friend bool operator==(const TriviallyEqualityComparableRefComparisonNonTriviallyCopyable&, const TriviallyEqualityComparableRefComparisonNonTriviallyCopyable&) = default;
};
static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparableRefComparisonNonTriviallyCopyable));
}

#endif // __cplusplus >= 202002L
};

namespace can_pass_in_regs {

struct A { };

struct B {
  ~B();
};

struct C; // expected-note {{forward declaration}}

union D {
  int x;
};

static_assert(__can_pass_in_regs(A));
static_assert(__can_pass_in_regs(A));
static_assert(!__can_pass_in_regs(B));
static_assert(__can_pass_in_regs(D));

void test_errors() {
  (void)__can_pass_in_regs(const A); // expected-error {{not an unqualified class type}}
  (void)__can_pass_in_regs(A&); // expected-error {{not an unqualified class type}}
  (void)__can_pass_in_regs(A&&); // expected-error {{not an unqualified class type}}
  (void)__can_pass_in_regs(const A&); // expected-error {{not an unqualified class type}}
  (void)__can_pass_in_regs(C); // expected-error {{incomplete type}}
  (void)__can_pass_in_regs(int); // expected-error {{not an unqualified class type}}
  (void)__can_pass_in_regs(int&); // expected-error {{not an unqualified class type}}
}
}

struct S {};
template <class T> using remove_const_t = __remove_const(T);

void check_remove_const() {
  static_assert(__is_same(remove_const_t<void>, void));
  static_assert(__is_same(remove_const_t<const void>, void));
  static_assert(__is_same(remove_const_t<int>, int));
  static_assert(__is_same(remove_const_t<const int>, int));
  static_assert(__is_same(remove_const_t<volatile int>, volatile int));
  static_assert(__is_same(remove_const_t<const volatile int>, volatile int));
  static_assert(__is_same(remove_const_t<int *>, int *));
  static_assert(__is_same(remove_const_t<int *const>, int *));
  static_assert(__is_same(remove_const_t<int const *const>, int const *));
  static_assert(__is_same(remove_const_t<int const *const __restrict>, int const *__restrict));
  static_assert(__is_same(remove_const_t<int &>, int &));
  static_assert(__is_same(remove_const_t<int const &>, int const &));
  static_assert(__is_same(remove_const_t<int &&>, int &&));
  static_assert(__is_same(remove_const_t<int const &&>, int const &&));
  static_assert(__is_same(remove_const_t<int()>, int()));
  static_assert(__is_same(remove_const_t<int (*const)()>, int (*)()));
  static_assert(__is_same(remove_const_t<int (&)()>, int (&)()));

  static_assert(__is_same(remove_const_t<S>, S));
  static_assert(__is_same(remove_const_t<const S>, S));
  static_assert(__is_same(remove_const_t<volatile S>, volatile S));
  static_assert(__is_same(remove_const_t<S *__restrict>, S *__restrict));
  static_assert(__is_same(remove_const_t<const volatile S>, volatile S));
  static_assert(__is_same(remove_const_t<S *const volatile __restrict>, S *volatile __restrict));
  static_assert(__is_same(remove_const_t<int S::*const>, int S::*));
  static_assert(__is_same(remove_const_t<int (S::*const)()>, int(S::*)()));
}

template <class T> using remove_restrict_t = __remove_restrict(T);

void check_remove_restrict() {
  static_assert(__is_same(remove_restrict_t<void>, void));
  static_assert(__is_same(remove_restrict_t<int>, int));
  static_assert(__is_same(remove_restrict_t<const int>, const int));
  static_assert(__is_same(remove_restrict_t<volatile int>, volatile int));
  static_assert(__is_same(remove_restrict_t<int *__restrict>, int *));
  static_assert(__is_same(remove_restrict_t<int *const volatile __restrict>, int *const volatile));
  static_assert(__is_same(remove_restrict_t<int *>, int *));
  static_assert(__is_same(remove_restrict_t<int *__restrict>, int *));
  static_assert(__is_same(remove_restrict_t<int &>, int &));
  static_assert(__is_same(remove_restrict_t<int &__restrict>, int &));
  static_assert(__is_same(remove_restrict_t<int &&>, int &&));
  static_assert(__is_same(remove_restrict_t<int &&__restrict>, int &&));
  static_assert(__is_same(remove_restrict_t<int()>, int()));
  static_assert(__is_same(remove_restrict_t<int (*const volatile)()>, int (*const volatile)()));
  static_assert(__is_same(remove_restrict_t<int (&)()>, int (&)()));

  static_assert(__is_same(remove_restrict_t<S>, S));
  static_assert(__is_same(remove_restrict_t<const S>, const S));
  static_assert(__is_same(remove_restrict_t<volatile S>, volatile S));
  static_assert(__is_same(remove_restrict_t<S *__restrict>, S *));
  static_assert(__is_same(remove_restrict_t<S *const volatile __restrict>, S *const volatile));
  static_assert(__is_same(remove_restrict_t<int S::*__restrict>, int S::*));
  static_assert(__is_same(remove_restrict_t<int (S::*const volatile)()>, int(S::*const volatile)()));
}

template <class T> using remove_volatile_t = __remove_volatile(T);

void check_remove_volatile() {
  static_assert(__is_same(remove_volatile_t<void>, void));
  static_assert(__is_same(remove_volatile_t<volatile void>, void));
  static_assert(__is_same(remove_volatile_t<int>, int));
  static_assert(__is_same(remove_volatile_t<const int>, const int));
  static_assert(__is_same(remove_volatile_t<volatile int>, int));
  static_assert(__is_same(remove_volatile_t<int *__restrict>, int *__restrict));
  static_assert(__is_same(remove_volatile_t<const volatile int>, const int));
  static_assert(__is_same(remove_volatile_t<int *const volatile __restrict>, int *const __restrict));
  static_assert(__is_same(remove_volatile_t<int *>, int *));
  static_assert(__is_same(remove_volatile_t<int *volatile>, int *));
  static_assert(__is_same(remove_volatile_t<int volatile *volatile>, int volatile *));
  static_assert(__is_same(remove_volatile_t<int &>, int &));
  static_assert(__is_same(remove_volatile_t<int volatile &>, int volatile &));
  static_assert(__is_same(remove_volatile_t<int &&>, int &&));
  static_assert(__is_same(remove_volatile_t<int volatile &&>, int volatile &&));
  static_assert(__is_same(remove_volatile_t<int()>, int()));
  static_assert(__is_same(remove_volatile_t<int (*volatile)()>, int (*)()));
  static_assert(__is_same(remove_volatile_t<int (&)()>, int (&)()));

  static_assert(__is_same(remove_volatile_t<S>, S));
  static_assert(__is_same(remove_volatile_t<const S>, const S));
  static_assert(__is_same(remove_volatile_t<volatile S>, S));
  static_assert(__is_same(remove_volatile_t<const volatile S>, const S));
  static_assert(__is_same(remove_volatile_t<int S::*volatile>, int S::*));
  static_assert(__is_same(remove_volatile_t<int (S::*volatile)()>, int(S::*)()));
}

template <class T> using remove_cv_t = __remove_cv(T);

void check_remove_cv() {
  static_assert(__is_same(remove_cv_t<void>, void));
  static_assert(__is_same(remove_cv_t<const volatile void>, void));
  static_assert(__is_same(remove_cv_t<int>, int));
  static_assert(__is_same(remove_cv_t<const int>, int));
  static_assert(__is_same(remove_cv_t<volatile int>, int));
  static_assert(__is_same(remove_cv_t<const volatile int>, int));
  static_assert(__is_same(remove_cv_t<int *>, int *));
  static_assert(__is_same(remove_cv_t<int *const volatile>, int *));
  static_assert(__is_same(remove_cv_t<int const *const volatile>, int const *));
  static_assert(__is_same(remove_cv_t<int const *const volatile __restrict>, int const *__restrict));
  static_assert(__is_same(remove_cv_t<int const *const volatile _Nonnull>, int const *_Nonnull));
  static_assert(__is_same(remove_cv_t<int &>, int &));
  static_assert(__is_same(remove_cv_t<int const volatile &>, int const volatile &));
  static_assert(__is_same(remove_cv_t<int &&>, int &&));
  static_assert(__is_same(remove_cv_t<int const volatile &&>, int const volatile &&));
  static_assert(__is_same(remove_cv_t<int()>, int()));
  static_assert(__is_same(remove_cv_t<int (*const volatile)()>, int (*)()));
  static_assert(__is_same(remove_cv_t<int (&)()>, int (&)()));

  static_assert(__is_same(remove_cv_t<S>, S));
  static_assert(__is_same(remove_cv_t<const S>, S));
  static_assert(__is_same(remove_cv_t<volatile S>, S));
  static_assert(__is_same(remove_cv_t<const volatile S>, S));
  static_assert(__is_same(remove_cv_t<int S::*const volatile>, int S::*));
  static_assert(__is_same(remove_cv_t<int (S::*const volatile)()>, int(S::*)()));
}

template <class T> using add_pointer_t = __add_pointer(T);

void add_pointer() {
  static_assert(__is_same(add_pointer_t<void>, void *));
  static_assert(__is_same(add_pointer_t<const void>, const void *));
  static_assert(__is_same(add_pointer_t<volatile void>, volatile void *));
  static_assert(__is_same(add_pointer_t<const volatile void>, const volatile void *));
  static_assert(__is_same(add_pointer_t<int>, int *));
  static_assert(__is_same(add_pointer_t<const int>, const int *));
  static_assert(__is_same(add_pointer_t<volatile int>, volatile int *));
  static_assert(__is_same(add_pointer_t<const volatile int>, const volatile int *));
  static_assert(__is_same(add_pointer_t<int *>, int **));
  static_assert(__is_same(add_pointer_t<int &>, int *));
  static_assert(__is_same(add_pointer_t<int &&>, int *));
  static_assert(__is_same(add_pointer_t<int()>, int (*)()));
  static_assert(__is_same(add_pointer_t<int (*)()>, int (**)()));
  static_assert(__is_same(add_pointer_t<int (&)()>, int (*)()));

  static_assert(__is_same(add_pointer_t<S>, S *));
  static_assert(__is_same(add_pointer_t<const S>, const S *));
  static_assert(__is_same(add_pointer_t<volatile S>, volatile S *));
  static_assert(__is_same(add_pointer_t<const volatile S>, const volatile S *));
  static_assert(__is_same(add_pointer_t<int S::*>, int S::**));
  static_assert(__is_same(add_pointer_t<int (S::*)()>, int(S::**)()));

  static_assert(__is_same(add_pointer_t<int __attribute__((address_space(1)))>, int __attribute__((address_space(1))) *));
  static_assert(__is_same(add_pointer_t<S __attribute__((address_space(2)))>, S __attribute__((address_space(2))) *));
}

template <class T> using remove_pointer_t = __remove_pointer(T);

void remove_pointer() {
  static_assert(__is_same(remove_pointer_t<void>, void));
  static_assert(__is_same(remove_pointer_t<const void>, const void));
  static_assert(__is_same(remove_pointer_t<volatile void>, volatile void));
  static_assert(__is_same(remove_pointer_t<const volatile void>, const volatile void));
  static_assert(__is_same(remove_pointer_t<int>, int));
  static_assert(__is_same(remove_pointer_t<const int>, const int));
  static_assert(__is_same(remove_pointer_t<volatile int>, volatile int));
  static_assert(__is_same(remove_pointer_t<const volatile int>, const volatile int));
  static_assert(__is_same(remove_pointer_t<int *>, int));
  static_assert(__is_same(remove_pointer_t<const int *>, const int));
  static_assert(__is_same(remove_pointer_t<volatile int *>, volatile int));
  static_assert(__is_same(remove_pointer_t<const volatile int *>, const volatile int));
  static_assert(__is_same(remove_pointer_t<int *const>, int));
  static_assert(__is_same(remove_pointer_t<int *volatile>, int));
  static_assert(__is_same(remove_pointer_t<int *const volatile>, int));
  static_assert(__is_same(remove_pointer_t<int &>, int &));
  static_assert(__is_same(remove_pointer_t<int &&>, int &&));
  static_assert(__is_same(remove_pointer_t<int()>, int()));
  static_assert(__is_same(remove_pointer_t<int (*)()>, int()));
  static_assert(__is_same(remove_pointer_t<int (&)()>, int (&)()));

  static_assert(__is_same(remove_pointer_t<S>, S));
  static_assert(__is_same(remove_pointer_t<const S>, const S));
  static_assert(__is_same(remove_pointer_t<volatile S>, volatile S));
  static_assert(__is_same(remove_pointer_t<const volatile S>, const volatile S));
  static_assert(__is_same(remove_pointer_t<int S::*>, int S::*));
  static_assert(__is_same(remove_pointer_t<int (S::*)()>, int(S::*)()));

  static_assert(__is_same(remove_pointer_t<int __attribute__((address_space(1))) *>, int __attribute__((address_space(1)))));
  static_assert(__is_same(remove_pointer_t<S __attribute__((address_space(2))) *>, S  __attribute__((address_space(2)))));

  static_assert(__is_same(remove_pointer_t<int (^)(char)>, int (^)(char)));
}

template <class T> using add_lvalue_reference_t = __add_lvalue_reference(T);

void add_lvalue_reference() {
  static_assert(__is_same(add_lvalue_reference_t<void>, void));
  static_assert(__is_same(add_lvalue_reference_t<const void>, const void));
  static_assert(__is_same(add_lvalue_reference_t<volatile void>, volatile void));
  static_assert(__is_same(add_lvalue_reference_t<const volatile void>, const volatile void));
  static_assert(__is_same(add_lvalue_reference_t<int>, int &));
  static_assert(__is_same(add_lvalue_reference_t<const int>, const int &));
  static_assert(__is_same(add_lvalue_reference_t<volatile int>, volatile int &));
  static_assert(__is_same(add_lvalue_reference_t<const volatile int>, const volatile int &));
  static_assert(__is_same(add_lvalue_reference_t<int *>, int *&));
  static_assert(__is_same(add_lvalue_reference_t<int &>, int &));
  static_assert(__is_same(add_lvalue_reference_t<int &&>, int &)); // reference collapsing
  static_assert(__is_same(add_lvalue_reference_t<int()>, int (&)()));
  static_assert(__is_same(add_lvalue_reference_t<int (*)()>, int (*&)()));
  static_assert(__is_same(add_lvalue_reference_t<int (&)()>, int (&)()));

  static_assert(__is_same(add_lvalue_reference_t<S>, S &));
  static_assert(__is_same(add_lvalue_reference_t<const S>, const S &));
  static_assert(__is_same(add_lvalue_reference_t<volatile S>, volatile S &));
  static_assert(__is_same(add_lvalue_reference_t<const volatile S>, const volatile S &));
  static_assert(__is_same(add_lvalue_reference_t<int S::*>, int S::*&));
  static_assert(__is_same(add_lvalue_reference_t<int (S::*)()>, int(S::*&)()));
}

template <class T> using add_rvalue_reference_t = __add_rvalue_reference(T);

void add_rvalue_reference() {
  static_assert(__is_same(add_rvalue_reference_t<void>, void));
  static_assert(__is_same(add_rvalue_reference_t<const void>, const void));
  static_assert(__is_same(add_rvalue_reference_t<volatile void>, volatile void));
  static_assert(__is_same(add_rvalue_reference_t<const volatile void>, const volatile void));
  static_assert(__is_same(add_rvalue_reference_t<int>, int &&));
  static_assert(__is_same(add_rvalue_reference_t<const int>, const int &&));
  static_assert(__is_same(add_rvalue_reference_t<volatile int>, volatile int &&));
  static_assert(__is_same(add_rvalue_reference_t<const volatile int>, const volatile int &&));
  static_assert(__is_same(add_rvalue_reference_t<int *>, int *&&));
  static_assert(__is_same(add_rvalue_reference_t<int &>, int &)); // reference collapsing
  static_assert(__is_same(add_rvalue_reference_t<int &&>, int &&));
  static_assert(__is_same(add_rvalue_reference_t<int()>, int(&&)()));
  static_assert(__is_same(add_rvalue_reference_t<int (*)()>, int (*&&)()));
  static_assert(__is_same(add_rvalue_reference_t<int (&)()>, int (&)())); // reference collapsing

  static_assert(__is_same(add_rvalue_reference_t<S>, S &&));
  static_assert(__is_same(add_rvalue_reference_t<const S>, const S &&));
  static_assert(__is_same(add_rvalue_reference_t<volatile S>, volatile S &&));
  static_assert(__is_same(add_rvalue_reference_t<const volatile S>, const volatile S &&));
  static_assert(__is_same(add_rvalue_reference_t<int S::*>, int S::*&&));
  static_assert(__is_same(add_rvalue_reference_t<int (S::*)()>, int(S::* &&)()));
}

template <class T> using remove_reference_t = __remove_reference_t(T);

void check_remove_reference() {
  static_assert(__is_same(remove_reference_t<void>, void));
  static_assert(__is_same(remove_reference_t<const volatile void>, const volatile void));
  static_assert(__is_same(remove_reference_t<int>, int));
  static_assert(__is_same(remove_reference_t<const int>, const int));
  static_assert(__is_same(remove_reference_t<volatile int>, volatile int));
  static_assert(__is_same(remove_reference_t<const volatile int>, const volatile int));
  static_assert(__is_same(remove_reference_t<int *>, int *));
  static_assert(__is_same(remove_reference_t<int *const volatile>, int *const volatile));
  static_assert(__is_same(remove_reference_t<int const *const volatile>, int const *const volatile));
  static_assert(__is_same(remove_reference_t<int &>, int));
  static_assert(__is_same(remove_reference_t<int const volatile &>, int const volatile));
  static_assert(__is_same(remove_reference_t<int &&>, int));
  static_assert(__is_same(remove_reference_t<int const volatile &&>, int const volatile));
  static_assert(__is_same(remove_reference_t<int()>, int()));
  static_assert(__is_same(remove_reference_t<int (*const volatile)()>, int (*const volatile)()));
  static_assert(__is_same(remove_reference_t<int (&)()>, int()));

  static_assert(__is_same(remove_reference_t<S>, S));
  static_assert(__is_same(remove_reference_t<S &>, S));
  static_assert(__is_same(remove_reference_t<S &&>, S));
  static_assert(__is_same(remove_reference_t<const S>, const S));
  static_assert(__is_same(remove_reference_t<const S &>, const S));
  static_assert(__is_same(remove_reference_t<const S &&>, const S));
  static_assert(__is_same(remove_reference_t<volatile S>, volatile S));
  static_assert(__is_same(remove_reference_t<volatile S &>, volatile S));
  static_assert(__is_same(remove_reference_t<volatile S &&>, volatile S));
  static_assert(__is_same(remove_reference_t<const volatile S>, const volatile S));
  static_assert(__is_same(remove_reference_t<const volatile S &>, const volatile S));
  static_assert(__is_same(remove_reference_t<const volatile S &&>, const volatile S));
  static_assert(__is_same(remove_reference_t<int S::*const volatile &>, int S::*const volatile));
  static_assert(__is_same(remove_reference_t<int (S::*const volatile &)()>, int(S::*const volatile)()));
  static_assert(__is_same(remove_reference_t<int (S::*const volatile &&)() &>, int(S::*const volatile)() &));
}

template <class T> using remove_cvref_t = __remove_cvref(T);

void check_remove_cvref() {
  static_assert(__is_same(remove_cvref_t<void>, void));
  static_assert(__is_same(remove_cvref_t<const volatile void>, void));
  static_assert(__is_same(remove_cvref_t<int>, int));
  static_assert(__is_same(remove_cvref_t<const int>, int));
  static_assert(__is_same(remove_cvref_t<volatile int>, int));
  static_assert(__is_same(remove_cvref_t<const volatile int>, int));
  static_assert(__is_same(remove_cvref_t<int *>, int *));
  static_assert(__is_same(remove_cvref_t<int *const volatile>, int *));
  static_assert(__is_same(remove_cvref_t<int const *const volatile>, int const *));
  static_assert(__is_same(remove_cvref_t<int const *const volatile __restrict>, int const *__restrict));
  static_assert(__is_same(remove_cvref_t<int const *const volatile _Nonnull>, int const *_Nonnull));
  static_assert(__is_same(remove_cvref_t<int &>, int));
  static_assert(__is_same(remove_cvref_t<int const volatile &>, int));
  static_assert(__is_same(remove_cvref_t<int &&>, int));
  static_assert(__is_same(remove_cvref_t<int const volatile &&>, int));
  static_assert(__is_same(remove_cvref_t<int()>, int()));
  static_assert(__is_same(remove_cvref_t<int (*const volatile)()>, int (*)()));
  static_assert(__is_same(remove_cvref_t<int (&)()>, int()));

  static_assert(__is_same(remove_cvref_t<S>, S));
  static_assert(__is_same(remove_cvref_t<S &>, S));
  static_assert(__is_same(remove_cvref_t<S &&>, S));
  static_assert(__is_same(remove_cvref_t<const S>, S));
  static_assert(__is_same(remove_cvref_t<const S &>, S));
  static_assert(__is_same(remove_cvref_t<const S &&>, S));
  static_assert(__is_same(remove_cvref_t<volatile S>, S));
  static_assert(__is_same(remove_cvref_t<volatile S &>, S));
  static_assert(__is_same(remove_cvref_t<volatile S &&>, S));
  static_assert(__is_same(remove_cvref_t<const volatile S>, S));
  static_assert(__is_same(remove_cvref_t<const volatile S &>, S));
  static_assert(__is_same(remove_cvref_t<const volatile S &&>, S));
  static_assert(__is_same(remove_cvref_t<int S::*const volatile>, int S::*));
  static_assert(__is_same(remove_cvref_t<int (S::*const volatile)()>, int(S::*)()));
  static_assert(__is_same(remove_cvref_t<int (S::*const volatile)() &>, int(S::*)() &));
  static_assert(__is_same(remove_cvref_t<int (S::*const volatile)() &&>, int(S::*)() &&));
}

template <class T> using decay_t = __decay(T);

void check_decay() {
  static_assert(__is_same(decay_t<void>, void));
  static_assert(__is_same(decay_t<const volatile void>, void));
  static_assert(__is_same(decay_t<int>, int));
  static_assert(__is_same(decay_t<const int>, int));
  static_assert(__is_same(decay_t<volatile int>, int));
  static_assert(__is_same(decay_t<const volatile int>, int));
  static_assert(__is_same(decay_t<int *>, int *));
  static_assert(__is_same(decay_t<int *const volatile>, int *));
  static_assert(__is_same(decay_t<int *const volatile __restrict>, int *));
  static_assert(__is_same(decay_t<int const *const volatile>, int const *));
  static_assert(__is_same(decay_t<int const *const volatile _Nonnull>, int const *));
  static_assert(__is_same(decay_t<int &>, int));
  static_assert(__is_same(decay_t<int const volatile &>, int));
  static_assert(__is_same(decay_t<int &&>, int));
  static_assert(__is_same(decay_t<int const volatile &&>, int));
  static_assert(__is_same(decay_t<int()>, int (*)()));
  static_assert(__is_same(decay_t<int (*)()>, int (*)()));
  static_assert(__is_same(decay_t<int (*const)()>, int (*)()));
  static_assert(__is_same(decay_t<int (*volatile)()>, int (*)()));
  static_assert(__is_same(decay_t<int (*const volatile)()>, int (*)()));
  static_assert(__is_same(decay_t<int (&)()>, int (*)()));
  static_assert(__is_same(decay_t<IntAr>, int *));
  static_assert(__is_same(decay_t<IntArNB>, int *));

  static_assert(__is_same(decay_t<S>, S));
  static_assert(__is_same(decay_t<S &>, S));
  static_assert(__is_same(decay_t<S &&>, S));
  static_assert(__is_same(decay_t<const S>, S));
  static_assert(__is_same(decay_t<const S &>, S));
  static_assert(__is_same(decay_t<const S &&>, S));
  static_assert(__is_same(decay_t<volatile S>, S));
  static_assert(__is_same(decay_t<volatile S &>, S));
  static_assert(__is_same(decay_t<volatile S &&>, S));
  static_assert(__is_same(decay_t<const volatile S>, S));
  static_assert(__is_same(decay_t<const volatile S &>, S));
  static_assert(__is_same(decay_t<const volatile S &&>, S));
  static_assert(__is_same(decay_t<int S::*const volatile>, int S::*));
  static_assert(__is_same(decay_t<int (S::*const volatile)()>, int(S::*)()));
  static_assert(__is_same(decay_t<int S::*const volatile &>, int S::*));
  static_assert(__is_same(decay_t<int (S::*const volatile &)()>, int(S::*)()));
  static_assert(__is_same(decay_t<int S::*const volatile &&>, int S::*));
}

template <class T> struct CheckAbominableFunction {};
template <class M>
struct CheckAbominableFunction<M S::*> {
  static void checks() {
    static_assert(__is_same(add_lvalue_reference_t<M>, M));
    static_assert(__is_same(add_pointer_t<M>, M));
    static_assert(__is_same(add_rvalue_reference_t<M>, M));
    static_assert(__is_same(decay_t<M>, M));
    static_assert(__is_same(remove_const_t<M>, M));
    static_assert(__is_same(remove_volatile_t<M>, M));
    static_assert(__is_same(remove_cv_t<M>, M));
    static_assert(__is_same(remove_cvref_t<M>, M));
    static_assert(__is_same(remove_pointer_t<M>, M));
    static_assert(__is_same(remove_reference_t<M>, M));

    static_assert(!__is_referenceable(M));
  }
};

void check_abominable_function() {
  { CheckAbominableFunction<int (S::*)() &> x; }
  { CheckAbominableFunction<int (S::*)() &&> x; }
  { CheckAbominableFunction<int (S::*)() const> x; }
  { CheckAbominableFunction<int (S::*)() const &> x; }
  { CheckAbominableFunction<int (S::*)() const &&> x; }
  { CheckAbominableFunction<int (S::*)() volatile> x; }
  { CheckAbominableFunction<int (S::*)() volatile &> x; }
  { CheckAbominableFunction<int (S::*)() volatile &&> x; }
  { CheckAbominableFunction<int (S::*)() const volatile> x; }
  { CheckAbominableFunction<int (S::*)() const volatile &> x; }
  { CheckAbominableFunction<int (S::*)() const volatile &&> x; }
}

template <class T> using make_signed_t = __make_signed(T);
template <class T, class Expected>
void check_make_signed() {
  static_assert(__is_same(make_signed_t<T>, Expected));
  static_assert(__is_same(make_signed_t<const T>, const Expected));
  static_assert(__is_same(make_signed_t<volatile T>, volatile Expected));
  static_assert(__is_same(make_signed_t<const volatile T>, const volatile Expected));
}

#if defined(__ILP32__) || defined(__LLP64__)
  using Int64 = long long;
  using UInt64 = unsigned long long;
#elif defined(__LP64__) || defined(__ILP64__) || defined(__SILP64__)
  using Int64 = long;
  using UInt64 = unsigned long;
#else
#error Programming model currently unsupported; please add a new entry.
#endif

enum UnscopedBool : bool {}; // deliberately char
enum class ScopedBool : bool {}; // deliberately char
enum UnscopedChar : char {}; // deliberately char
enum class ScopedChar : char {}; // deliberately char
enum UnscopedUChar : unsigned char {};
enum class ScopedUChar : unsigned char {};
enum UnscopedLongLong : long long {};
enum UnscopedULongLong : unsigned long long {};
enum class ScopedLongLong : long long {};
enum class ScopedULongLong : unsigned long long {};
enum class UnscopedInt128 : __int128 {};
enum class ScopedInt128 : __int128 {};
enum class UnscopedUInt128 : unsigned __int128 {};
enum class ScopedUInt128 : unsigned __int128 {};

void make_signed() {
  check_make_signed<char, signed char>();
  check_make_signed<signed char, signed char>();
  check_make_signed<unsigned char, signed char>();
  check_make_signed<short, short>();
  check_make_signed<unsigned short, short>();
  check_make_signed<int, int>();
  check_make_signed<unsigned int, int>();
  check_make_signed<long, long>();
  check_make_signed<unsigned long, long>();
  check_make_signed<long long, long long>();
  check_make_signed<unsigned long long, long long>();
  check_make_signed<__int128, __int128>();
  check_make_signed<__uint128_t, __int128>();
  check_make_signed<_BitInt(65), _BitInt(65)>();
  check_make_signed<unsigned _BitInt(65), _BitInt(65)>();

  check_make_signed<wchar_t, int>();
#if __cplusplus >= 202002L
  check_make_signed<char8_t, signed char>();
#endif
#if __cplusplus >= 201103L
  check_make_signed<char16_t, short>();
  check_make_signed<char32_t, int>();
#endif

  check_make_signed<UnscopedChar, signed char>();
  check_make_signed<ScopedChar, signed char>();
  check_make_signed<UnscopedUChar, signed char>();
  check_make_signed<ScopedUChar, signed char>();

  check_make_signed<UnscopedLongLong, Int64>();
  check_make_signed<UnscopedULongLong, Int64>();
  check_make_signed<ScopedLongLong, Int64>();
  check_make_signed<ScopedULongLong, Int64>();

  check_make_signed<UnscopedInt128, __int128>();
  check_make_signed<ScopedInt128, __int128>();
  check_make_signed<UnscopedUInt128, __int128>();
  check_make_signed<ScopedUInt128, __int128>();

  { using ExpectedError = __make_signed(bool); }
  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'bool'}}
  { using ExpectedError = __make_signed(UnscopedBool); }
  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'UnscopedBool' whose underlying type is 'bool'}}
  { using ExpectedError = __make_signed(ScopedBool); }
  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'ScopedBool' whose underlying type is 'bool'}}
  { using ExpectedError = __make_signed(unsigned _BitInt(1)); }
  // expected-error@*:*{{'make_signed' is only compatible with non-_BitInt(1) integers and enum types, but was given 'unsigned _BitInt(1)'}}
  { using ExpectedError = __make_signed(int[]); }
  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int[]'}}
  { using ExpectedError = __make_signed(int[5]); }
  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int[5]'}}
  { using ExpectedError = __make_signed(void); }
  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'void'}}
  { using ExpectedError = __make_signed(int *); }
  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int *'}}
  { using ExpectedError = __make_signed(int &); }
  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int &'}}
  { using ExpectedError = __make_signed(int &&); }
  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int &&'}}
  { using ExpectedError = __make_signed(float); }
  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'float'}}
  { using ExpectedError = __make_signed(double); }
  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'double'}}
  { using ExpectedError = __make_signed(long double); }
  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'long double'}}
  { using ExpectedError = __make_signed(S); }
  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'S'}}
  { using ExpectedError = __make_signed(S *); }
  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'S *'}}
  { using ExpectedError = __make_signed(int S::*); }
  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int S::*'}}
  { using ExpectedError = __make_signed(int(S::*)()); }
  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int (S::*)()'}}
}

template <class T>
using make_unsigned_t = __make_unsigned(T);

template <class T, class Expected>
void check_make_unsigned() {
  static_assert(__is_same(make_unsigned_t<T>, Expected));
  static_assert(__is_same(make_unsigned_t<const T>, const Expected));
  static_assert(__is_same(make_unsigned_t<volatile T>, volatile Expected));
  static_assert(__is_same(make_unsigned_t<const volatile T>, const volatile Expected));
}

void make_unsigned() {
  check_make_unsigned<char, unsigned char>();
  check_make_unsigned<signed char, unsigned char>();
  check_make_unsigned<unsigned char, unsigned char>();
  check_make_unsigned<short, unsigned short>();
  check_make_unsigned<unsigned short, unsigned short>();
  check_make_unsigned<int, unsigned int>();
  check_make_unsigned<unsigned int, unsigned int>();
  check_make_unsigned<long, unsigned long>();
  check_make_unsigned<unsigned long, unsigned long>();
  check_make_unsigned<long long, unsigned long long>();
  check_make_unsigned<unsigned long long, unsigned long long>();
  check_make_unsigned<__int128, __uint128_t>();
  check_make_unsigned<__uint128_t, __uint128_t>();
  check_make_unsigned<_BitInt(65), unsigned _BitInt(65)>();
  check_make_unsigned<unsigned _BitInt(65), unsigned _BitInt(65)>();

  check_make_unsigned<wchar_t, unsigned int>();
#if __cplusplus >= 202002L
  check_make_unsigned<char8_t, unsigned char>();
#endif
#if __cplusplus >= 201103L
  check_make_unsigned<char16_t, unsigned short>();
  check_make_unsigned<char32_t, unsigned int>();
#endif

  check_make_unsigned<UnscopedChar, unsigned char>();
  check_make_unsigned<ScopedChar, unsigned char>();
  check_make_unsigned<UnscopedUChar, unsigned char>();
  check_make_unsigned<ScopedUChar, unsigned char>();

  check_make_unsigned<UnscopedLongLong, UInt64>();
  check_make_unsigned<UnscopedULongLong, UInt64>();
  check_make_unsigned<ScopedLongLong, UInt64>();
  check_make_unsigned<ScopedULongLong, UInt64>();

  check_make_unsigned<UnscopedInt128, unsigned __int128>();
  check_make_unsigned<ScopedInt128, unsigned __int128>();
  check_make_unsigned<UnscopedUInt128, unsigned __int128>();
  check_make_unsigned<ScopedUInt128, unsigned __int128>();

  { using ExpectedError = __make_unsigned(bool); }
  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'bool'}}
  { using ExpectedError = __make_unsigned(UnscopedBool); }
  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'UnscopedBool' whose underlying type is 'bool'}}
  { using ExpectedError = __make_unsigned(ScopedBool); }
  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'ScopedBool' whose underlying type is 'bool'}}
  { using ExpectedError = __make_unsigned(unsigned _BitInt(1)); }
  // expected-error@*:*{{'make_unsigned' is only compatible with non-_BitInt(1) integers and enum types, but was given 'unsigned _BitInt(1)'}}
  { using ExpectedError = __make_unsigned(int[]); }
  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int[]'}}
  { using ExpectedError = __make_unsigned(int[5]); }
  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int[5]'}}
  { using ExpectedError = __make_unsigned(void); }
  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'void'}}
  { using ExpectedError = __make_unsigned(int *); }
  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int *'}}
  { using ExpectedError = __make_unsigned(int &); }
  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int &'}}
  { using ExpectedError = __make_unsigned(int &&); }
  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int &&'}}
  { using ExpectedError = __make_unsigned(float); }
  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'float'}}
  { using ExpectedError = __make_unsigned(double); }
  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'double'}}
  { using ExpectedError = __make_unsigned(long double); }
  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'long double'}}
  { using ExpectedError = __make_unsigned(S); }
  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'S'}}
  { using ExpectedError = __make_unsigned(S *); }
  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'S *'}}
  { using ExpectedError = __make_unsigned(int S::*); }
  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int S::*'}}
  { using ExpectedError = __make_unsigned(int(S::*)()); }
  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int (S::*)()'}}
}

template <class T> using remove_extent_t = __remove_extent(T);

void remove_extent() {
  static_assert(__is_same(remove_extent_t<void>, void));
  static_assert(__is_same(remove_extent_t<int>, int));
  static_assert(__is_same(remove_extent_t<int[]>, int));
  static_assert(__is_same(remove_extent_t<int[1]>, int));
  static_assert(__is_same(remove_extent_t<int[1][2]>, int[2]));
  static_assert(__is_same(remove_extent_t<int[][2]>, int[2]));
  static_assert(__is_same(remove_extent_t<const int[]>, const int));
  static_assert(__is_same(remove_extent_t<const int[1]>, const int));
  static_assert(__is_same(remove_extent_t<const int[1][2]>, const int[2]));
  static_assert(__is_same(remove_extent_t<const int[][2]>, const int[2]));
  static_assert(__is_same(remove_extent_t<volatile int[]>, volatile int));
  static_assert(__is_same(remove_extent_t<volatile int[1]>, volatile int));
  static_assert(__is_same(remove_extent_t<volatile int[1][2]>, volatile int[2]));
  static_assert(__is_same(remove_extent_t<volatile int[][2]>, volatile int[2]));
  static_assert(__is_same(remove_extent_t<const volatile int[]>, const volatile int));
  static_assert(__is_same(remove_extent_t<const volatile int[1]>, const volatile int));
  static_assert(__is_same(remove_extent_t<const volatile int[1][2]>, const volatile int[2]));
  static_assert(__is_same(remove_extent_t<const volatile int[][2]>, const volatile int[2]));
  static_assert(__is_same(remove_extent_t<int *>, int *));
  static_assert(__is_same(remove_extent_t<int &>, int &));
  static_assert(__is_same(remove_extent_t<int &&>, int &&));
  static_assert(__is_same(remove_extent_t<int()>, int()));
  static_assert(__is_same(remove_extent_t<int (*)()>, int (*)()));
  static_assert(__is_same(remove_extent_t<int (&)()>, int (&)()));

  static_assert(__is_same(remove_extent_t<S>, S));
  static_assert(__is_same(remove_extent_t<int S::*>, int S::*));
  static_assert(__is_same(remove_extent_t<int (S::*)()>, int(S::*)()));

  using SomeArray = int[1][2];
  static_assert(__is_same(remove_extent_t<const SomeArray>, const int[2]));
}

template <class T> using remove_all_extents_t = __remove_all_extents(T);

void remove_all_extents() {
  static_assert(__is_same(remove_all_extents_t<void>, void));
  static_assert(__is_same(remove_all_extents_t<int>, int));
  static_assert(__is_same(remove_all_extents_t<const int>, const int));
  static_assert(__is_same(remove_all_extents_t<volatile int>, volatile int));
  static_assert(__is_same(remove_all_extents_t<const volatile int>, const volatile int));
  static_assert(__is_same(remove_all_extents_t<int[]>, int));
  static_assert(__is_same(remove_all_extents_t<int[1]>, int));
  static_assert(__is_same(remove_all_extents_t<int[1][2]>, int));
  static_assert(__is_same(remove_all_extents_t<int[][2]>, int));
  static_assert(__is_same(remove_all_extents_t<const int[]>, const int));
  static_assert(__is_same(remove_all_extents_t<const int[1]>, const int));
  static_assert(__is_same(remove_all_extents_t<const int[1][2]>, const int));
  static_assert(__is_same(remove_all_extents_t<const int[][2]>, const int));
  static_assert(__is_same(remove_all_extents_t<volatile int[]>, volatile int));
  static_assert(__is_same(remove_all_extents_t<volatile int[1]>, volatile int));
  static_assert(__is_same(remove_all_extents_t<volatile int[1][2]>, volatile int));
  static_assert(__is_same(remove_all_extents_t<volatile int[][2]>, volatile int));
  static_assert(__is_same(remove_all_extents_t<const volatile int[]>, const volatile int));
  static_assert(__is_same(remove_all_extents_t<const volatile int[1]>, const volatile int));
  static_assert(__is_same(remove_all_extents_t<const volatile int[1][2]>, const volatile int));
  static_assert(__is_same(remove_all_extents_t<const volatile int[][2]>, const volatile int));
  static_assert(__is_same(remove_all_extents_t<int *>, int *));
  static_assert(__is_same(remove_all_extents_t<int &>, int &));
  static_assert(__is_same(remove_all_extents_t<int &&>, int &&));
  static_assert(__is_same(remove_all_extents_t<int()>, int()));
  static_assert(__is_same(remove_all_extents_t<int (*)()>, int (*)()));
  static_assert(__is_same(remove_all_extents_t<int (&)()>, int (&)()));

  static_assert(__is_same(remove_all_extents_t<S>, S));
  static_assert(__is_same(remove_all_extents_t<int S::*>, int S::*));
  static_assert(__is_same(remove_all_extents_t<int (S::*)()>, int(S::*)()));

  using SomeArray = int[1][2];
  static_assert(__is_same(remove_all_extents_t<const SomeArray>, const int));
}