| // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 -fms-extensions -Wno-microsoft %s |
| // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++14 -fms-extensions -Wno-microsoft %s |
| // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++1z -fms-extensions -Wno-microsoft %s |
| |
| #define T(b) (b) ? 1 : -1 |
| #define F(b) (b) ? -1 : 1 |
| |
| struct NonPOD { NonPOD(int); }; |
| typedef NonPOD NonPODAr[10]; |
| typedef NonPOD NonPODArNB[]; |
| typedef NonPOD NonPODArMB[10][2]; |
| |
| // PODs |
| enum Enum { EV }; |
| struct POD { Enum e; int i; float f; NonPOD* p; }; |
| struct Empty {}; |
| 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() |
| { |
| { int arr[T(__is_pod(int))]; } |
| { int arr[T(__is_pod(Enum))]; } |
| { int arr[T(__is_pod(POD))]; } |
| { int arr[T(__is_pod(Int))]; } |
| { int arr[T(__is_pod(IntAr))]; } |
| { int arr[T(__is_pod(Statics))]; } |
| { int arr[T(__is_pod(Empty))]; } |
| { int arr[T(__is_pod(EmptyUnion))]; } |
| { int arr[T(__is_pod(Union))]; } |
| { int arr[T(__is_pod(HasFunc))]; } |
| { int arr[T(__is_pod(HasOp))]; } |
| { int arr[T(__is_pod(HasConv))]; } |
| { int arr[T(__is_pod(HasAssign))]; } |
| { int arr[T(__is_pod(IntArNB))]; } |
| { int arr[T(__is_pod(HasAnonymousUnion))]; } |
| { int arr[T(__is_pod(Vector))]; } |
| { int arr[T(__is_pod(VectorExt))]; } |
| { int arr[T(__is_pod(Derives))]; } |
| { int arr[T(__is_pod(DerivesAr))]; } |
| { int arr[T(__is_pod(DerivesArNB))]; } |
| { int arr[T(__is_pod(DerivesEmpty))]; } |
| { int arr[T(__is_pod(HasPriv))]; } |
| { int arr[T(__is_pod(HasProt))]; } |
| { int arr[T(__is_pod(DerivesHasPriv))]; } |
| { int arr[T(__is_pod(DerivesHasProt))]; } |
| |
| { int arr[F(__is_pod(HasCons))]; } |
| { int arr[F(__is_pod(HasCopyAssign))]; } |
| { int arr[F(__is_pod(HasMoveAssign))]; } |
| { int arr[F(__is_pod(HasDest))]; } |
| { int arr[F(__is_pod(HasRef))]; } |
| { int arr[F(__is_pod(HasVirt))]; } |
| { int arr[F(__is_pod(DerivesHasCons))]; } |
| { int arr[F(__is_pod(DerivesHasCopyAssign))]; } |
| { int arr[F(__is_pod(DerivesHasMoveAssign))]; } |
| { int arr[F(__is_pod(DerivesHasDest))]; } |
| { int arr[F(__is_pod(DerivesHasRef))]; } |
| { int arr[F(__is_pod(DerivesHasVirt))]; } |
| { int arr[F(__is_pod(NonPOD))]; } |
| { int arr[F(__is_pod(HasNonPOD))]; } |
| { int arr[F(__is_pod(NonPODAr))]; } |
| { int arr[F(__is_pod(NonPODArNB))]; } |
| { int arr[F(__is_pod(void))]; } |
| { int arr[F(__is_pod(cvoid))]; } |
| // { int arr[F(__is_pod(NonPODUnion))]; } |
| |
| { int arr[T(__is_pod(ACompleteType))]; } |
| { int arr[F(__is_pod(AnIncompleteType))]; } // expected-error {{incomplete type}} |
| { int arr[F(__is_pod(AnIncompleteType[]))]; } // expected-error {{incomplete type}} |
| { int arr[F(__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() |
| { |
| { int arr[T(__is_empty(Empty))]; } |
| { int arr[T(__is_empty(DerivesEmpty))]; } |
| { int arr[T(__is_empty(HasCons))]; } |
| { int arr[T(__is_empty(HasCopyAssign))]; } |
| { int arr[T(__is_empty(HasMoveAssign))]; } |
| { int arr[T(__is_empty(HasDest))]; } |
| { int arr[T(__is_empty(HasFunc))]; } |
| { int arr[T(__is_empty(HasOp))]; } |
| { int arr[T(__is_empty(HasConv))]; } |
| { int arr[T(__is_empty(HasAssign))]; } |
| { int arr[T(__is_empty(Bit0))]; } |
| { int arr[T(__is_empty(Bit0Cons))]; } |
| |
| { int arr[F(__is_empty(Int))]; } |
| { int arr[F(__is_empty(POD))]; } |
| { int arr[F(__is_empty(EmptyUnion))]; } |
| { int arr[F(__is_empty(IncompleteUnion))]; } |
| { int arr[F(__is_empty(EmptyAr))]; } |
| { int arr[F(__is_empty(HasRef))]; } |
| { int arr[F(__is_empty(HasVirt))]; } |
| { int arr[F(__is_empty(AnonBitOnly))]; } |
| { int arr[F(__is_empty(BitOnly))]; } |
| { int arr[F(__is_empty(void))]; } |
| { int arr[F(__is_empty(IntArNB))]; } |
| { int arr[F(__is_empty(HasAnonymousUnion))]; } |
| // { int arr[F(__is_empty(DerivesVirt))]; } |
| |
| { int arr[T(__is_empty(ACompleteType))]; } |
| { int arr[F(__is_empty(AnIncompleteType))]; } // expected-error {{incomplete type}} |
| { int arr[F(__is_empty(AnIncompleteType[]))]; } |
| { int arr[F(__is_empty(AnIncompleteType[1]))]; } |
| } |
| |
| typedef Derives ClassType; |
| |
| void is_class() |
| { |
| { int arr[T(__is_class(Derives))]; } |
| { int arr[T(__is_class(HasPriv))]; } |
| { int arr[T(__is_class(ClassType))]; } |
| { int arr[T(__is_class(HasAnonymousUnion))]; } |
| |
| { int arr[F(__is_class(int))]; } |
| { int arr[F(__is_class(Enum))]; } |
| { int arr[F(__is_class(Int))]; } |
| { int arr[F(__is_class(IntAr))]; } |
| { int arr[F(__is_class(DerivesAr))]; } |
| { int arr[F(__is_class(Union))]; } |
| { int arr[F(__is_class(cvoid))]; } |
| { int arr[F(__is_class(IntArNB))]; } |
| } |
| |
| typedef Union UnionAr[10]; |
| typedef Union UnionType; |
| |
| void is_union() |
| { |
| { int arr[T(__is_union(Union))]; } |
| { int arr[T(__is_union(UnionType))]; } |
| |
| { int arr[F(__is_union(int))]; } |
| { int arr[F(__is_union(Enum))]; } |
| { int arr[F(__is_union(Int))]; } |
| { int arr[F(__is_union(IntAr))]; } |
| { int arr[F(__is_union(UnionAr))]; } |
| { int arr[F(__is_union(cvoid))]; } |
| { int arr[F(__is_union(IntArNB))]; } |
| { int arr[F(__is_union(HasAnonymousUnion))]; } |
| } |
| |
| typedef Enum EnumType; |
| |
| void is_enum() |
| { |
| { int arr[T(__is_enum(Enum))]; } |
| { int arr[T(__is_enum(EnumType))]; } |
| |
| { int arr[F(__is_enum(int))]; } |
| { int arr[F(__is_enum(Union))]; } |
| { int arr[F(__is_enum(Int))]; } |
| { int arr[F(__is_enum(IntAr))]; } |
| { int arr[F(__is_enum(UnionAr))]; } |
| { int arr[F(__is_enum(Derives))]; } |
| { int arr[F(__is_enum(ClassType))]; } |
| { int arr[F(__is_enum(cvoid))]; } |
| { int arr[F(__is_enum(IntArNB))]; } |
| { int arr[F(__is_enum(HasAnonymousUnion))]; } |
| } |
| |
| struct FinalClass final { |
| }; |
| |
| template<typename T> |
| struct PotentiallyFinal { }; |
| |
| template<typename T> |
| struct PotentiallyFinal<T*> final { }; |
| |
| template<> |
| struct PotentiallyFinal<int> final { }; |
| |
| struct SealedClass sealed { |
| }; |
| |
| template<typename T> |
| struct PotentiallySealed { }; |
| |
| template<typename T> |
| struct PotentiallySealed<T*> sealed { }; |
| |
| template<> |
| struct PotentiallySealed<int> sealed { }; |
| |
| void is_final() |
| { |
| { int arr[T(__is_final(SealedClass))]; } |
| { int arr[T(__is_final(PotentiallySealed<float*>))]; } |
| { int arr[T(__is_final(PotentiallySealed<int>))]; } |
| { int arr[T(__is_final(FinalClass))]; } |
| { int arr[T(__is_final(PotentiallyFinal<float*>))]; } |
| { int arr[T(__is_final(PotentiallyFinal<int>))]; } |
| |
| { int arr[F(__is_final(int))]; } |
| { int arr[F(__is_final(Union))]; } |
| { int arr[F(__is_final(Int))]; } |
| { int arr[F(__is_final(IntAr))]; } |
| { int arr[F(__is_final(UnionAr))]; } |
| { int arr[F(__is_final(Derives))]; } |
| { int arr[F(__is_final(ClassType))]; } |
| { int arr[F(__is_final(cvoid))]; } |
| { int arr[F(__is_final(IntArNB))]; } |
| { int arr[F(__is_final(HasAnonymousUnion))]; } |
| { int arr[F(__is_final(PotentiallyFinal<float>))]; } |
| { int arr[F(__is_final(PotentiallySealed<float>))]; } |
| } |
| |
| void is_sealed() |
| { |
| { int arr[T(__is_sealed(SealedClass))]; } |
| { int arr[T(__is_sealed(PotentiallySealed<float*>))]; } |
| { int arr[T(__is_sealed(PotentiallySealed<int>))]; } |
| { int arr[T(__is_sealed(FinalClass))]; } |
| { int arr[T(__is_sealed(PotentiallyFinal<float*>))]; } |
| { int arr[T(__is_sealed(PotentiallyFinal<int>))]; } |
| |
| { int arr[F(__is_sealed(int))]; } |
| { int arr[F(__is_sealed(Union))]; } |
| { int arr[F(__is_sealed(Int))]; } |
| { int arr[F(__is_sealed(IntAr))]; } |
| { int arr[F(__is_sealed(UnionAr))]; } |
| { int arr[F(__is_sealed(Derives))]; } |
| { int arr[F(__is_sealed(ClassType))]; } |
| { int arr[F(__is_sealed(cvoid))]; } |
| { int arr[F(__is_sealed(IntArNB))]; } |
| { int arr[F(__is_sealed(HasAnonymousUnion))]; } |
| { int arr[F(__is_sealed(PotentiallyFinal<float>))]; } |
| { int arr[F(__is_sealed(PotentiallySealed<float>))]; } |
| } |
| |
| typedef HasVirt Polymorph; |
| struct InheritPolymorph : Polymorph {}; |
| |
| void is_polymorphic() |
| { |
| { int arr[T(__is_polymorphic(Polymorph))]; } |
| { int arr[T(__is_polymorphic(InheritPolymorph))]; } |
| |
| { int arr[F(__is_polymorphic(int))]; } |
| { int arr[F(__is_polymorphic(Union))]; } |
| { int arr[F(__is_polymorphic(IncompleteUnion))]; } |
| { int arr[F(__is_polymorphic(Int))]; } |
| { int arr[F(__is_polymorphic(IntAr))]; } |
| { int arr[F(__is_polymorphic(UnionAr))]; } |
| { int arr[F(__is_polymorphic(Derives))]; } |
| { int arr[F(__is_polymorphic(ClassType))]; } |
| { int arr[F(__is_polymorphic(Enum))]; } |
| { int arr[F(__is_polymorphic(cvoid))]; } |
| { int arr[F(__is_polymorphic(IntArNB))]; } |
| } |
| |
| void is_integral() |
| { |
| int t01[T(__is_integral(bool))]; |
| int t02[T(__is_integral(char))]; |
| int t03[T(__is_integral(signed char))]; |
| int t04[T(__is_integral(unsigned char))]; |
| //int t05[T(__is_integral(char16_t))]; |
| //int t06[T(__is_integral(char32_t))]; |
| int t07[T(__is_integral(wchar_t))]; |
| int t08[T(__is_integral(short))]; |
| int t09[T(__is_integral(unsigned short))]; |
| int t10[T(__is_integral(int))]; |
| int t11[T(__is_integral(unsigned int))]; |
| int t12[T(__is_integral(long))]; |
| int t13[T(__is_integral(unsigned long))]; |
| |
| int t21[F(__is_integral(float))]; |
| int t22[F(__is_integral(double))]; |
| int t23[F(__is_integral(long double))]; |
| int t24[F(__is_integral(Union))]; |
| int t25[F(__is_integral(UnionAr))]; |
| int t26[F(__is_integral(Derives))]; |
| int t27[F(__is_integral(ClassType))]; |
| int t28[F(__is_integral(Enum))]; |
| int t29[F(__is_integral(void))]; |
| int t30[F(__is_integral(cvoid))]; |
| int t31[F(__is_integral(IntArNB))]; |
| } |
| |
| void is_floating_point() |
| { |
| int t01[T(__is_floating_point(float))]; |
| int t02[T(__is_floating_point(double))]; |
| int t03[T(__is_floating_point(long double))]; |
| |
| int t11[F(__is_floating_point(bool))]; |
| int t12[F(__is_floating_point(char))]; |
| int t13[F(__is_floating_point(signed char))]; |
| int t14[F(__is_floating_point(unsigned char))]; |
| //int t15[F(__is_floating_point(char16_t))]; |
| //int t16[F(__is_floating_point(char32_t))]; |
| int t17[F(__is_floating_point(wchar_t))]; |
| int t18[F(__is_floating_point(short))]; |
| int t19[F(__is_floating_point(unsigned short))]; |
| int t20[F(__is_floating_point(int))]; |
| int t21[F(__is_floating_point(unsigned int))]; |
| int t22[F(__is_floating_point(long))]; |
| int t23[F(__is_floating_point(unsigned long))]; |
| int t24[F(__is_floating_point(Union))]; |
| int t25[F(__is_floating_point(UnionAr))]; |
| int t26[F(__is_floating_point(Derives))]; |
| int t27[F(__is_floating_point(ClassType))]; |
| int t28[F(__is_floating_point(Enum))]; |
| int t29[F(__is_floating_point(void))]; |
| int t30[F(__is_floating_point(cvoid))]; |
| int t31[F(__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(AnIncompleteType[]); // expected-error {{incomplete type}} |
| __is_aggregate(AnIncompleteType[1]); // expected-error {{incomplete type}} |
| __is_aggregate(AnIncompleteTypeAr); // expected-error {{incomplete type}} |
| __is_aggregate(AnIncompleteTypeArNB); // expected-error {{incomplete type}} |
| __is_aggregate(AnIncompleteTypeArMB); // expected-error {{incomplete type}} |
| __is_aggregate(IncompleteUnion); // expected-error {{incomplete type}} |
| |
| 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), ""); |
| static_assert(__is_aggregate(HasDefaultCons), ""); |
| 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() |
| { |
| int t01[T(__is_arithmetic(float))]; |
| int t02[T(__is_arithmetic(double))]; |
| int t03[T(__is_arithmetic(long double))]; |
| int t11[T(__is_arithmetic(bool))]; |
| int t12[T(__is_arithmetic(char))]; |
| int t13[T(__is_arithmetic(signed char))]; |
| int t14[T(__is_arithmetic(unsigned char))]; |
| //int t15[T(__is_arithmetic(char16_t))]; |
| //int t16[T(__is_arithmetic(char32_t))]; |
| int t17[T(__is_arithmetic(wchar_t))]; |
| int t18[T(__is_arithmetic(short))]; |
| int t19[T(__is_arithmetic(unsigned short))]; |
| int t20[T(__is_arithmetic(int))]; |
| int t21[T(__is_arithmetic(unsigned int))]; |
| int t22[T(__is_arithmetic(long))]; |
| int t23[T(__is_arithmetic(unsigned long))]; |
| |
| int t24[F(__is_arithmetic(Union))]; |
| int t25[F(__is_arithmetic(UnionAr))]; |
| int t26[F(__is_arithmetic(Derives))]; |
| int t27[F(__is_arithmetic(ClassType))]; |
| int t28[F(__is_arithmetic(Enum))]; |
| int t29[F(__is_arithmetic(void))]; |
| int t30[F(__is_arithmetic(cvoid))]; |
| int t31[F(__is_arithmetic(IntArNB))]; |
| } |
| |
| void is_complete_type() |
| { |
| int t01[T(__is_complete_type(float))]; |
| int t02[T(__is_complete_type(double))]; |
| int t03[T(__is_complete_type(long double))]; |
| int t11[T(__is_complete_type(bool))]; |
| int t12[T(__is_complete_type(char))]; |
| int t13[T(__is_complete_type(signed char))]; |
| int t14[T(__is_complete_type(unsigned char))]; |
| //int t15[T(__is_complete_type(char16_t))]; |
| //int t16[T(__is_complete_type(char32_t))]; |
| int t17[T(__is_complete_type(wchar_t))]; |
| int t18[T(__is_complete_type(short))]; |
| int t19[T(__is_complete_type(unsigned short))]; |
| int t20[T(__is_complete_type(int))]; |
| int t21[T(__is_complete_type(unsigned int))]; |
| int t22[T(__is_complete_type(long))]; |
| int t23[T(__is_complete_type(unsigned long))]; |
| int t24[T(__is_complete_type(ACompleteType))]; |
| |
| int t30[F(__is_complete_type(AnIncompleteType))]; |
| } |
| |
| void is_void() |
| { |
| int t01[T(__is_void(void))]; |
| int t02[T(__is_void(cvoid))]; |
| |
| int t10[F(__is_void(float))]; |
| int t11[F(__is_void(double))]; |
| int t12[F(__is_void(long double))]; |
| int t13[F(__is_void(bool))]; |
| int t14[F(__is_void(char))]; |
| int t15[F(__is_void(signed char))]; |
| int t16[F(__is_void(unsigned char))]; |
| int t17[F(__is_void(wchar_t))]; |
| int t18[F(__is_void(short))]; |
| int t19[F(__is_void(unsigned short))]; |
| int t20[F(__is_void(int))]; |
| int t21[F(__is_void(unsigned int))]; |
| int t22[F(__is_void(long))]; |
| int t23[F(__is_void(unsigned long))]; |
| int t24[F(__is_void(Union))]; |
| int t25[F(__is_void(UnionAr))]; |
| int t26[F(__is_void(Derives))]; |
| int t27[F(__is_void(ClassType))]; |
| int t28[F(__is_void(Enum))]; |
| int t29[F(__is_void(IntArNB))]; |
| int t30[F(__is_void(void*))]; |
| int t31[F(__is_void(cvoid*))]; |
| } |
| |
| void is_array() |
| { |
| int t01[T(__is_array(IntAr))]; |
| int t02[T(__is_array(IntArNB))]; |
| int t03[T(__is_array(UnionAr))]; |
| |
| int t10[F(__is_array(void))]; |
| int t11[F(__is_array(cvoid))]; |
| int t12[F(__is_array(float))]; |
| int t13[F(__is_array(double))]; |
| int t14[F(__is_array(long double))]; |
| int t15[F(__is_array(bool))]; |
| int t16[F(__is_array(char))]; |
| int t17[F(__is_array(signed char))]; |
| int t18[F(__is_array(unsigned char))]; |
| int t19[F(__is_array(wchar_t))]; |
| int t20[F(__is_array(short))]; |
| int t21[F(__is_array(unsigned short))]; |
| int t22[F(__is_array(int))]; |
| int t23[F(__is_array(unsigned int))]; |
| int t24[F(__is_array(long))]; |
| int t25[F(__is_array(unsigned long))]; |
| int t26[F(__is_array(Union))]; |
| int t27[F(__is_array(Derives))]; |
| int t28[F(__is_array(ClassType))]; |
| int t29[F(__is_array(Enum))]; |
| int t30[F(__is_array(void*))]; |
| int t31[F(__is_array(cvoid*))]; |
| } |
| |
| 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() |
| { |
| int t01[T(__is_function(type_wrapper<void(void)>::type))]; |
| int t02[T(__is_function(typeof(tmpl_func<int>)))]; |
| |
| typedef void (*ptr_to_func_type)(void); |
| |
| int t10[F(__is_function(void))]; |
| int t11[F(__is_function(cvoid))]; |
| int t12[F(__is_function(float))]; |
| int t13[F(__is_function(double))]; |
| int t14[F(__is_function(long double))]; |
| int t15[F(__is_function(bool))]; |
| int t16[F(__is_function(char))]; |
| int t17[F(__is_function(signed char))]; |
| int t18[F(__is_function(unsigned char))]; |
| int t19[F(__is_function(wchar_t))]; |
| int t20[F(__is_function(short))]; |
| int t21[F(__is_function(unsigned short))]; |
| int t22[F(__is_function(int))]; |
| int t23[F(__is_function(unsigned int))]; |
| int t24[F(__is_function(long))]; |
| int t25[F(__is_function(unsigned long))]; |
| int t26[F(__is_function(Union))]; |
| int t27[F(__is_function(Derives))]; |
| int t28[F(__is_function(ClassType))]; |
| int t29[F(__is_function(Enum))]; |
| int t30[F(__is_function(void*))]; |
| int t31[F(__is_function(cvoid*))]; |
| int t32[F(__is_function(void(*)()))]; |
| int t33[F(__is_function(ptr_to_func_type))]; |
| int t34[F(__is_function(type_wrapper<void(void)>::ptrtype))]; |
| int t35[F(__is_function(type_wrapper<void(void)>::reftype))]; |
| } |
| |
| void is_reference() |
| { |
| int t01[T(__is_reference(int&))]; |
| int t02[T(__is_reference(const int&))]; |
| int t03[T(__is_reference(void *&))]; |
| |
| int t10[F(__is_reference(int))]; |
| int t11[F(__is_reference(const int))]; |
| int t12[F(__is_reference(void *))]; |
| } |
| |
| void is_lvalue_reference() |
| { |
| int t01[T(__is_lvalue_reference(int&))]; |
| int t02[T(__is_lvalue_reference(void *&))]; |
| int t03[T(__is_lvalue_reference(const int&))]; |
| int t04[T(__is_lvalue_reference(void * const &))]; |
| |
| int t10[F(__is_lvalue_reference(int))]; |
| int t11[F(__is_lvalue_reference(const int))]; |
| int t12[F(__is_lvalue_reference(void *))]; |
| } |
| |
| #if __has_feature(cxx_rvalue_references) |
| |
| void is_rvalue_reference() |
| { |
| int t01[T(__is_rvalue_reference(const int&&))]; |
| int t02[T(__is_rvalue_reference(void * const &&))]; |
| |
| int t10[F(__is_rvalue_reference(int&))]; |
| int t11[F(__is_rvalue_reference(void *&))]; |
| int t12[F(__is_rvalue_reference(const int&))]; |
| int t13[F(__is_rvalue_reference(void * const &))]; |
| int t14[F(__is_rvalue_reference(int))]; |
| int t15[F(__is_rvalue_reference(const int))]; |
| int t16[F(__is_rvalue_reference(void *))]; |
| } |
| |
| #endif |
| |
| void is_fundamental() |
| { |
| int t01[T(__is_fundamental(float))]; |
| int t02[T(__is_fundamental(double))]; |
| int t03[T(__is_fundamental(long double))]; |
| int t11[T(__is_fundamental(bool))]; |
| int t12[T(__is_fundamental(char))]; |
| int t13[T(__is_fundamental(signed char))]; |
| int t14[T(__is_fundamental(unsigned char))]; |
| //int t15[T(__is_fundamental(char16_t))]; |
| //int t16[T(__is_fundamental(char32_t))]; |
| int t17[T(__is_fundamental(wchar_t))]; |
| int t18[T(__is_fundamental(short))]; |
| int t19[T(__is_fundamental(unsigned short))]; |
| int t20[T(__is_fundamental(int))]; |
| int t21[T(__is_fundamental(unsigned int))]; |
| int t22[T(__is_fundamental(long))]; |
| int t23[T(__is_fundamental(unsigned long))]; |
| int t24[T(__is_fundamental(void))]; |
| int t25[T(__is_fundamental(cvoid))]; |
| |
| int t30[F(__is_fundamental(Union))]; |
| int t31[F(__is_fundamental(UnionAr))]; |
| int t32[F(__is_fundamental(Derives))]; |
| int t33[F(__is_fundamental(ClassType))]; |
| int t34[F(__is_fundamental(Enum))]; |
| int t35[F(__is_fundamental(IntArNB))]; |
| } |
| |
| void is_object() |
| { |
| int t01[T(__is_object(int))]; |
| int t02[T(__is_object(int *))]; |
| int t03[T(__is_object(void *))]; |
| int t04[T(__is_object(Union))]; |
| int t05[T(__is_object(UnionAr))]; |
| int t06[T(__is_object(ClassType))]; |
| int t07[T(__is_object(Enum))]; |
| |
| int t10[F(__is_object(type_wrapper<void(void)>::type))]; |
| int t11[F(__is_object(int&))]; |
| int t12[F(__is_object(void))]; |
| } |
| |
| void is_scalar() |
| { |
| int t01[T(__is_scalar(float))]; |
| int t02[T(__is_scalar(double))]; |
| int t03[T(__is_scalar(long double))]; |
| int t04[T(__is_scalar(bool))]; |
| int t05[T(__is_scalar(char))]; |
| int t06[T(__is_scalar(signed char))]; |
| int t07[T(__is_scalar(unsigned char))]; |
| int t08[T(__is_scalar(wchar_t))]; |
| int t09[T(__is_scalar(short))]; |
| int t10[T(__is_scalar(unsigned short))]; |
| int t11[T(__is_scalar(int))]; |
| int t12[T(__is_scalar(unsigned int))]; |
| int t13[T(__is_scalar(long))]; |
| int t14[T(__is_scalar(unsigned long))]; |
| int t15[T(__is_scalar(Enum))]; |
| int t16[T(__is_scalar(void*))]; |
| int t17[T(__is_scalar(cvoid*))]; |
| |
| int t20[F(__is_scalar(void))]; |
| int t21[F(__is_scalar(cvoid))]; |
| int t22[F(__is_scalar(Union))]; |
| int t23[F(__is_scalar(UnionAr))]; |
| int t24[F(__is_scalar(Derives))]; |
| int t25[F(__is_scalar(ClassType))]; |
| int t26[F(__is_scalar(IntArNB))]; |
| } |
| |
| struct StructWithMembers { |
| int member; |
| void method() {} |
| }; |
| |
| void is_compound() |
| { |
| int t01[T(__is_compound(void*))]; |
| int t02[T(__is_compound(cvoid*))]; |
| int t03[T(__is_compound(void (*)()))]; |
| int t04[T(__is_compound(int StructWithMembers::*))]; |
| int t05[T(__is_compound(void (StructWithMembers::*)()))]; |
| int t06[T(__is_compound(int&))]; |
| int t07[T(__is_compound(Union))]; |
| int t08[T(__is_compound(UnionAr))]; |
| int t09[T(__is_compound(Derives))]; |
| int t10[T(__is_compound(ClassType))]; |
| int t11[T(__is_compound(IntArNB))]; |
| int t12[T(__is_compound(Enum))]; |
| |
| int t20[F(__is_compound(float))]; |
| int t21[F(__is_compound(double))]; |
| int t22[F(__is_compound(long double))]; |
| int t23[F(__is_compound(bool))]; |
| int t24[F(__is_compound(char))]; |
| int t25[F(__is_compound(signed char))]; |
| int t26[F(__is_compound(unsigned char))]; |
| int t27[F(__is_compound(wchar_t))]; |
| int t28[F(__is_compound(short))]; |
| int t29[F(__is_compound(unsigned short))]; |
| int t30[F(__is_compound(int))]; |
| int t31[F(__is_compound(unsigned int))]; |
| int t32[F(__is_compound(long))]; |
| int t33[F(__is_compound(unsigned long))]; |
| int t34[F(__is_compound(void))]; |
| int t35[F(__is_compound(cvoid))]; |
| } |
| |
| void is_pointer() |
| { |
| StructWithMembers x; |
| |
| int t01[T(__is_pointer(void*))]; |
| int t02[T(__is_pointer(cvoid*))]; |
| int t03[T(__is_pointer(cvoid*))]; |
| int t04[T(__is_pointer(char*))]; |
| int t05[T(__is_pointer(int*))]; |
| int t06[T(__is_pointer(int**))]; |
| int t07[T(__is_pointer(ClassType*))]; |
| int t08[T(__is_pointer(Derives*))]; |
| int t09[T(__is_pointer(Enum*))]; |
| int t10[T(__is_pointer(IntArNB*))]; |
| int t11[T(__is_pointer(Union*))]; |
| int t12[T(__is_pointer(UnionAr*))]; |
| int t13[T(__is_pointer(StructWithMembers*))]; |
| int t14[T(__is_pointer(void (*)()))]; |
| |
| int t20[F(__is_pointer(void))]; |
| int t21[F(__is_pointer(cvoid))]; |
| int t22[F(__is_pointer(cvoid))]; |
| int t23[F(__is_pointer(char))]; |
| int t24[F(__is_pointer(int))]; |
| int t25[F(__is_pointer(int))]; |
| int t26[F(__is_pointer(ClassType))]; |
| int t27[F(__is_pointer(Derives))]; |
| int t28[F(__is_pointer(Enum))]; |
| int t29[F(__is_pointer(IntArNB))]; |
| int t30[F(__is_pointer(Union))]; |
| int t31[F(__is_pointer(UnionAr))]; |
| int t32[F(__is_pointer(StructWithMembers))]; |
| int t33[F(__is_pointer(int StructWithMembers::*))]; |
| int t34[F(__is_pointer(void (StructWithMembers::*) ()))]; |
| } |
| |
| void is_member_object_pointer() |
| { |
| StructWithMembers x; |
| |
| int t01[T(__is_member_object_pointer(int StructWithMembers::*))]; |
| |
| int t10[F(__is_member_object_pointer(void (StructWithMembers::*) ()))]; |
| int t11[F(__is_member_object_pointer(void*))]; |
| int t12[F(__is_member_object_pointer(cvoid*))]; |
| int t13[F(__is_member_object_pointer(cvoid*))]; |
| int t14[F(__is_member_object_pointer(char*))]; |
| int t15[F(__is_member_object_pointer(int*))]; |
| int t16[F(__is_member_object_pointer(int**))]; |
| int t17[F(__is_member_object_pointer(ClassType*))]; |
| int t18[F(__is_member_object_pointer(Derives*))]; |
| int t19[F(__is_member_object_pointer(Enum*))]; |
| int t20[F(__is_member_object_pointer(IntArNB*))]; |
| int t21[F(__is_member_object_pointer(Union*))]; |
| int t22[F(__is_member_object_pointer(UnionAr*))]; |
| int t23[F(__is_member_object_pointer(StructWithMembers*))]; |
| int t24[F(__is_member_object_pointer(void))]; |
| int t25[F(__is_member_object_pointer(cvoid))]; |
| int t26[F(__is_member_object_pointer(cvoid))]; |
| int t27[F(__is_member_object_pointer(char))]; |
| int t28[F(__is_member_object_pointer(int))]; |
| int t29[F(__is_member_object_pointer(int))]; |
| int t30[F(__is_member_object_pointer(ClassType))]; |
| int t31[F(__is_member_object_pointer(Derives))]; |
| int t32[F(__is_member_object_pointer(Enum))]; |
| int t33[F(__is_member_object_pointer(IntArNB))]; |
| int t34[F(__is_member_object_pointer(Union))]; |
| int t35[F(__is_member_object_pointer(UnionAr))]; |
| int t36[F(__is_member_object_pointer(StructWithMembers))]; |
| int t37[F(__is_member_object_pointer(void (*)()))]; |
| } |
| |
| void is_member_function_pointer() |
| { |
| StructWithMembers x; |
| |
| int t01[T(__is_member_function_pointer(void (StructWithMembers::*) ()))]; |
| |
| int t10[F(__is_member_function_pointer(int StructWithMembers::*))]; |
| int t11[F(__is_member_function_pointer(void*))]; |
| int t12[F(__is_member_function_pointer(cvoid*))]; |
| int t13[F(__is_member_function_pointer(cvoid*))]; |
| int t14[F(__is_member_function_pointer(char*))]; |
| int t15[F(__is_member_function_pointer(int*))]; |
| int t16[F(__is_member_function_pointer(int**))]; |
| int t17[F(__is_member_function_pointer(ClassType*))]; |
| int t18[F(__is_member_function_pointer(Derives*))]; |
| int t19[F(__is_member_function_pointer(Enum*))]; |
| int t20[F(__is_member_function_pointer(IntArNB*))]; |
| int t21[F(__is_member_function_pointer(Union*))]; |
| int t22[F(__is_member_function_pointer(UnionAr*))]; |
| int t23[F(__is_member_function_pointer(StructWithMembers*))]; |
| int t24[F(__is_member_function_pointer(void))]; |
| int t25[F(__is_member_function_pointer(cvoid))]; |
| int t26[F(__is_member_function_pointer(cvoid))]; |
| int t27[F(__is_member_function_pointer(char))]; |
| int t28[F(__is_member_function_pointer(int))]; |
| int t29[F(__is_member_function_pointer(int))]; |
| int t30[F(__is_member_function_pointer(ClassType))]; |
| int t31[F(__is_member_function_pointer(Derives))]; |
| int t32[F(__is_member_function_pointer(Enum))]; |
| int t33[F(__is_member_function_pointer(IntArNB))]; |
| int t34[F(__is_member_function_pointer(Union))]; |
| int t35[F(__is_member_function_pointer(UnionAr))]; |
| int t36[F(__is_member_function_pointer(StructWithMembers))]; |
| int t37[F(__is_member_function_pointer(void (*)()))]; |
| } |
| |
| void is_member_pointer() |
| { |
| StructWithMembers x; |
| |
| int t01[T(__is_member_pointer(int StructWithMembers::*))]; |
| int t02[T(__is_member_pointer(void (StructWithMembers::*) ()))]; |
| |
| int t10[F(__is_member_pointer(void*))]; |
| int t11[F(__is_member_pointer(cvoid*))]; |
| int t12[F(__is_member_pointer(cvoid*))]; |
| int t13[F(__is_member_pointer(char*))]; |
| int t14[F(__is_member_pointer(int*))]; |
| int t15[F(__is_member_pointer(int**))]; |
| int t16[F(__is_member_pointer(ClassType*))]; |
| int t17[F(__is_member_pointer(Derives*))]; |
| int t18[F(__is_member_pointer(Enum*))]; |
| int t19[F(__is_member_pointer(IntArNB*))]; |
| int t20[F(__is_member_pointer(Union*))]; |
| int t21[F(__is_member_pointer(UnionAr*))]; |
| int t22[F(__is_member_pointer(StructWithMembers*))]; |
| int t23[F(__is_member_pointer(void))]; |
| int t24[F(__is_member_pointer(cvoid))]; |
| int t25[F(__is_member_pointer(cvoid))]; |
| int t26[F(__is_member_pointer(char))]; |
| int t27[F(__is_member_pointer(int))]; |
| int t28[F(__is_member_pointer(int))]; |
| int t29[F(__is_member_pointer(ClassType))]; |
| int t30[F(__is_member_pointer(Derives))]; |
| int t31[F(__is_member_pointer(Enum))]; |
| int t32[F(__is_member_pointer(IntArNB))]; |
| int t33[F(__is_member_pointer(Union))]; |
| int t34[F(__is_member_pointer(UnionAr))]; |
| int t35[F(__is_member_pointer(StructWithMembers))]; |
| int t36[F(__is_member_pointer(void (*)()))]; |
| } |
| |
| void is_const() |
| { |
| int t01[T(__is_const(cvoid))]; |
| int t02[T(__is_const(const char))]; |
| int t03[T(__is_const(const int))]; |
| int t04[T(__is_const(const long))]; |
| int t05[T(__is_const(const short))]; |
| int t06[T(__is_const(const signed char))]; |
| int t07[T(__is_const(const wchar_t))]; |
| int t08[T(__is_const(const bool))]; |
| int t09[T(__is_const(const float))]; |
| int t10[T(__is_const(const double))]; |
| int t11[T(__is_const(const long double))]; |
| int t12[T(__is_const(const unsigned char))]; |
| int t13[T(__is_const(const unsigned int))]; |
| int t14[T(__is_const(const unsigned long long))]; |
| int t15[T(__is_const(const unsigned long))]; |
| int t16[T(__is_const(const unsigned short))]; |
| int t17[T(__is_const(const void))]; |
| int t18[T(__is_const(const ClassType))]; |
| int t19[T(__is_const(const Derives))]; |
| int t20[T(__is_const(const Enum))]; |
| int t21[T(__is_const(const IntArNB))]; |
| int t22[T(__is_const(const Union))]; |
| int t23[T(__is_const(const UnionAr))]; |
| |
| int t30[F(__is_const(char))]; |
| int t31[F(__is_const(int))]; |
| int t32[F(__is_const(long))]; |
| int t33[F(__is_const(short))]; |
| int t34[F(__is_const(signed char))]; |
| int t35[F(__is_const(wchar_t))]; |
| int t36[F(__is_const(bool))]; |
| int t37[F(__is_const(float))]; |
| int t38[F(__is_const(double))]; |
| int t39[F(__is_const(long double))]; |
| int t40[F(__is_const(unsigned char))]; |
| int t41[F(__is_const(unsigned int))]; |
| int t42[F(__is_const(unsigned long long))]; |
| int t43[F(__is_const(unsigned long))]; |
| int t44[F(__is_const(unsigned short))]; |
| int t45[F(__is_const(void))]; |
| int t46[F(__is_const(ClassType))]; |
| int t47[F(__is_const(Derives))]; |
| int t48[F(__is_const(Enum))]; |
| int t49[F(__is_const(IntArNB))]; |
| int t50[F(__is_const(Union))]; |
| int t51[F(__is_const(UnionAr))]; |
| } |
| |
| void is_volatile() |
| { |
| int t02[T(__is_volatile(volatile char))]; |
| int t03[T(__is_volatile(volatile int))]; |
| int t04[T(__is_volatile(volatile long))]; |
| int t05[T(__is_volatile(volatile short))]; |
| int t06[T(__is_volatile(volatile signed char))]; |
| int t07[T(__is_volatile(volatile wchar_t))]; |
| int t08[T(__is_volatile(volatile bool))]; |
| int t09[T(__is_volatile(volatile float))]; |
| int t10[T(__is_volatile(volatile double))]; |
| int t11[T(__is_volatile(volatile long double))]; |
| int t12[T(__is_volatile(volatile unsigned char))]; |
| int t13[T(__is_volatile(volatile unsigned int))]; |
| int t14[T(__is_volatile(volatile unsigned long long))]; |
| int t15[T(__is_volatile(volatile unsigned long))]; |
| int t16[T(__is_volatile(volatile unsigned short))]; |
| int t17[T(__is_volatile(volatile void))]; |
| int t18[T(__is_volatile(volatile ClassType))]; |
| int t19[T(__is_volatile(volatile Derives))]; |
| int t20[T(__is_volatile(volatile Enum))]; |
| int t21[T(__is_volatile(volatile IntArNB))]; |
| int t22[T(__is_volatile(volatile Union))]; |
| int t23[T(__is_volatile(volatile UnionAr))]; |
| |
| int t30[F(__is_volatile(char))]; |
| int t31[F(__is_volatile(int))]; |
| int t32[F(__is_volatile(long))]; |
| int t33[F(__is_volatile(short))]; |
| int t34[F(__is_volatile(signed char))]; |
| int t35[F(__is_volatile(wchar_t))]; |
| int t36[F(__is_volatile(bool))]; |
| int t37[F(__is_volatile(float))]; |
| int t38[F(__is_volatile(double))]; |
| int t39[F(__is_volatile(long double))]; |
| int t40[F(__is_volatile(unsigned char))]; |
| int t41[F(__is_volatile(unsigned int))]; |
| int t42[F(__is_volatile(unsigned long long))]; |
| int t43[F(__is_volatile(unsigned long))]; |
| int t44[F(__is_volatile(unsigned short))]; |
| int t45[F(__is_volatile(void))]; |
| int t46[F(__is_volatile(ClassType))]; |
| int t47[F(__is_volatile(Derives))]; |
| int t48[F(__is_volatile(Enum))]; |
| int t49[F(__is_volatile(IntArNB))]; |
| int t50[F(__is_volatile(Union))]; |
| int t51[F(__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() |
| { |
| int t01[T(__is_trivial(char))]; |
| int t02[T(__is_trivial(int))]; |
| int t03[T(__is_trivial(long))]; |
| int t04[T(__is_trivial(short))]; |
| int t05[T(__is_trivial(signed char))]; |
| int t06[T(__is_trivial(wchar_t))]; |
| int t07[T(__is_trivial(bool))]; |
| int t08[T(__is_trivial(float))]; |
| int t09[T(__is_trivial(double))]; |
| int t10[T(__is_trivial(long double))]; |
| int t11[T(__is_trivial(unsigned char))]; |
| int t12[T(__is_trivial(unsigned int))]; |
| int t13[T(__is_trivial(unsigned long long))]; |
| int t14[T(__is_trivial(unsigned long))]; |
| int t15[T(__is_trivial(unsigned short))]; |
| int t16[T(__is_trivial(ClassType))]; |
| int t17[T(__is_trivial(Derives))]; |
| int t18[T(__is_trivial(Enum))]; |
| int t19[T(__is_trivial(IntAr))]; |
| int t20[T(__is_trivial(Union))]; |
| int t21[T(__is_trivial(UnionAr))]; |
| int t22[T(__is_trivial(TrivialStruct))]; |
| int t23[T(__is_trivial(AllDefaulted))]; |
| int t24[T(__is_trivial(AllDeleted))]; |
| |
| int t30[F(__is_trivial(void))]; |
| int t31[F(__is_trivial(NonTrivialStruct))]; |
| int t32[F(__is_trivial(SuperNonTrivialStruct))]; |
| int t33[F(__is_trivial(NonTCStruct))]; |
| int t34[F(__is_trivial(ExtDefaulted))]; |
| |
| int t40[T(__is_trivial(ACompleteType))]; |
| int t41[F(__is_trivial(AnIncompleteType))]; // expected-error {{incomplete type}} |
| int t42[F(__is_trivial(AnIncompleteType[]))]; // expected-error {{incomplete type}} |
| int t43[F(__is_trivial(AnIncompleteType[1]))]; // expected-error {{incomplete type}} |
| int t44[F(__is_trivial(void))]; |
| int t45[F(__is_trivial(const volatile void))]; |
| } |
| |
| void is_trivially_copyable2() |
| { |
| int t01[T(__is_trivially_copyable(char))]; |
| int t02[T(__is_trivially_copyable(int))]; |
| int t03[T(__is_trivially_copyable(long))]; |
| int t04[T(__is_trivially_copyable(short))]; |
| int t05[T(__is_trivially_copyable(signed char))]; |
| int t06[T(__is_trivially_copyable(wchar_t))]; |
| int t07[T(__is_trivially_copyable(bool))]; |
| int t08[T(__is_trivially_copyable(float))]; |
| int t09[T(__is_trivially_copyable(double))]; |
| int t10[T(__is_trivially_copyable(long double))]; |
| int t11[T(__is_trivially_copyable(unsigned char))]; |
| int t12[T(__is_trivially_copyable(unsigned int))]; |
| int t13[T(__is_trivially_copyable(unsigned long long))]; |
| int t14[T(__is_trivially_copyable(unsigned long))]; |
| int t15[T(__is_trivially_copyable(unsigned short))]; |
| int t16[T(__is_trivially_copyable(ClassType))]; |
| int t17[T(__is_trivially_copyable(Derives))]; |
| int t18[T(__is_trivially_copyable(Enum))]; |
| int t19[T(__is_trivially_copyable(IntAr))]; |
| int t20[T(__is_trivially_copyable(Union))]; |
| int t21[T(__is_trivially_copyable(UnionAr))]; |
| int t22[T(__is_trivially_copyable(TrivialStruct))]; |
| int t23[T(__is_trivially_copyable(NonTrivialStruct))]; |
| int t24[T(__is_trivially_copyable(AllDefaulted))]; |
| int t25[T(__is_trivially_copyable(AllDeleted))]; |
| |
| int t30[F(__is_trivially_copyable(void))]; |
| int t31[F(__is_trivially_copyable(SuperNonTrivialStruct))]; |
| int t32[F(__is_trivially_copyable(NonTCStruct))]; |
| int t33[F(__is_trivially_copyable(ExtDefaulted))]; |
| |
| int t34[T(__is_trivially_copyable(const int))]; |
| int t35[T(__is_trivially_copyable(volatile int))]; |
| |
| int t40[T(__is_trivially_copyable(ACompleteType))]; |
| int t41[F(__is_trivially_copyable(AnIncompleteType))]; // expected-error {{incomplete type}} |
| int t42[F(__is_trivially_copyable(AnIncompleteType[]))]; // expected-error {{incomplete type}} |
| int t43[F(__is_trivially_copyable(AnIncompleteType[1]))]; // expected-error {{incomplete type}} |
| int t44[F(__is_trivially_copyable(void))]; |
| int t45[F(__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]; |
| |
| int t01[T(__is_standard_layout(int))]; |
| int t02[T(__is_standard_layout(ConstInt))]; |
| int t03[T(__is_standard_layout(ConstIntAr))]; |
| int t04[T(__is_standard_layout(CStruct))]; |
| int t05[T(__is_standard_layout(CppStructStandard))]; |
| int t06[T(__is_standard_layout(CppStructStandardAr))]; |
| int t07[T(__is_standard_layout(Vector))]; |
| int t08[T(__is_standard_layout(VectorExt))]; |
| |
| typedef CppStructNonStandardByBase CppStructNonStandardByBaseAr[4]; |
| |
| int t10[F(__is_standard_layout(CppStructNonStandardByVirt))]; |
| int t11[F(__is_standard_layout(CppStructNonStandardByMemb))]; |
| int t12[F(__is_standard_layout(CppStructNonStandardByProt))]; |
| int t13[F(__is_standard_layout(CppStructNonStandardByVirtBase))]; |
| int t14[F(__is_standard_layout(CppStructNonStandardByBase))]; |
| int t15[F(__is_standard_layout(CppStructNonStandardByBaseAr))]; |
| int t16[F(__is_standard_layout(CppStructNonStandardBySameBase))]; |
| int t17[F(__is_standard_layout(CppStructNonStandardBy2ndVirtBase))]; |
| |
| int t40[T(__is_standard_layout(ACompleteType))]; |
| int t41[F(__is_standard_layout(AnIncompleteType))]; // expected-error {{incomplete type}} |
| int t42[F(__is_standard_layout(AnIncompleteType[]))]; // expected-error {{incomplete type}} |
| int t43[F(__is_standard_layout(AnIncompleteType[1]))]; // expected-error {{incomplete type}} |
| int t44[F(__is_standard_layout(void))]; |
| int t45[F(__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 {}; |
| |
| int t50[T(__is_standard_layout(HasAnonEmptyBitfield))]; |
| int t51[T(__is_standard_layout(HasAnonBitfield))]; |
| int t52[T(__is_standard_layout(DerivesFromBitfield))]; |
| int t53[F(__is_standard_layout(DerivesFromBitfieldWithBitfield))]; |
| int t54[F(__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; }; |
| |
| int t60[T(__is_standard_layout(Empty))]; |
| int t61[T(__is_standard_layout(HasEmptyBase))]; |
| int t62[F(__is_standard_layout(HasRepeatedEmptyBase))]; |
| int t63[F(__is_standard_layout(HasEmptyBaseAsMember))]; |
| int t64[F(__is_standard_layout(HasEmptyBaseAsSubobjectOfMember1))]; |
| int t65[T(__is_standard_layout(HasEmptyBaseAsSubobjectOfMember2))]; // FIXME: standard bug? |
| int t66[F(__is_standard_layout(HasEmptyBaseAsSubobjectOfMember3))]; |
| int t67[F(__is_standard_layout(HasEmptyIndirectBaseAsMember))]; |
| int t68[T(__is_standard_layout(HasEmptyIndirectBaseAsSecondMember))]; |
| int t69[F(__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; |
| }; |
| |
| int t70[T(__is_standard_layout(HasEmptyIndirectBaseAsSecondStructMember))]; |
| int t71[F(__is_standard_layout(HasEmptyIndirectBaseAsSecondUnionMember))]; |
| } |
| |
| void is_signed() |
| { |
| //int t01[T(__is_signed(char))]; |
| int t02[T(__is_signed(int))]; |
| int t03[T(__is_signed(long))]; |
| int t04[T(__is_signed(short))]; |
| int t05[T(__is_signed(signed char))]; |
| int t06[T(__is_signed(wchar_t))]; |
| |
| int t10[F(__is_signed(bool))]; |
| int t11[F(__is_signed(cvoid))]; |
| int t12[F(__is_signed(float))]; |
| int t13[F(__is_signed(double))]; |
| int t14[F(__is_signed(long double))]; |
| int t15[F(__is_signed(unsigned char))]; |
| int t16[F(__is_signed(unsigned int))]; |
| int t17[F(__is_signed(unsigned long long))]; |
| int t18[F(__is_signed(unsigned long))]; |
| int t19[F(__is_signed(unsigned short))]; |
| int t20[F(__is_signed(void))]; |
| int t21[F(__is_signed(ClassType))]; |
| int t22[F(__is_signed(Derives))]; |
| int t23[F(__is_signed(Enum))]; |
| int t24[F(__is_signed(IntArNB))]; |
| int t25[F(__is_signed(Union))]; |
| int t26[F(__is_signed(UnionAr))]; |
| } |
| |
| void is_unsigned() |
| { |
| int t01[T(__is_unsigned(bool))]; |
| int t02[T(__is_unsigned(unsigned char))]; |
| int t03[T(__is_unsigned(unsigned short))]; |
| int t04[T(__is_unsigned(unsigned int))]; |
| int t05[T(__is_unsigned(unsigned long))]; |
| int t06[T(__is_unsigned(unsigned long long))]; |
| int t07[T(__is_unsigned(Enum))]; |
| |
| int t10[F(__is_unsigned(void))]; |
| int t11[F(__is_unsigned(cvoid))]; |
| int t12[F(__is_unsigned(float))]; |
| int t13[F(__is_unsigned(double))]; |
| int t14[F(__is_unsigned(long double))]; |
| int t16[F(__is_unsigned(char))]; |
| int t17[F(__is_unsigned(signed char))]; |
| int t18[F(__is_unsigned(wchar_t))]; |
| int t19[F(__is_unsigned(short))]; |
| int t20[F(__is_unsigned(int))]; |
| int t21[F(__is_unsigned(long))]; |
| int t22[F(__is_unsigned(Union))]; |
| int t23[F(__is_unsigned(UnionAr))]; |
| int t24[F(__is_unsigned(Derives))]; |
| int t25[F(__is_unsigned(ClassType))]; |
| int t26[F(__is_unsigned(IntArNB))]; |
| } |
| |
| 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() { |
| { int arr[T(__has_trivial_constructor(Int))]; } |
| { int arr[T(__has_trivial_constructor(IntAr))]; } |
| { int arr[T(__has_trivial_constructor(Union))]; } |
| { int arr[T(__has_trivial_constructor(UnionAr))]; } |
| { int arr[T(__has_trivial_constructor(POD))]; } |
| { int arr[T(__has_trivial_constructor(Derives))]; } |
| { int arr[T(__has_trivial_constructor(DerivesAr))]; } |
| { int arr[T(__has_trivial_constructor(ConstIntAr))]; } |
| { int arr[T(__has_trivial_constructor(ConstIntArAr))]; } |
| { int arr[T(__has_trivial_constructor(HasDest))]; } |
| { int arr[T(__has_trivial_constructor(HasPriv))]; } |
| { int arr[T(__has_trivial_constructor(HasCopyAssign))]; } |
| { int arr[T(__has_trivial_constructor(HasMoveAssign))]; } |
| { int arr[T(__has_trivial_constructor(const Int))]; } |
| { int arr[T(__has_trivial_constructor(AllDefaulted))]; } |
| { int arr[T(__has_trivial_constructor(AllDeleted))]; } |
| { int arr[T(__has_trivial_constructor(ACompleteType[]))]; } |
| |
| { int arr[F(__has_trivial_constructor(AnIncompleteType[]))]; } // expected-error {{incomplete type}} |
| { int arr[F(__has_trivial_constructor(HasCons))]; } |
| { int arr[F(__has_trivial_constructor(HasRef))]; } |
| { int arr[F(__has_trivial_constructor(HasCopy))]; } |
| { int arr[F(__has_trivial_constructor(IntRef))]; } |
| { int arr[F(__has_trivial_constructor(VirtAr))]; } |
| { int arr[F(__has_trivial_constructor(void))]; } |
| { int arr[F(__has_trivial_constructor(cvoid))]; } |
| { int arr[F(__has_trivial_constructor(HasTemplateCons))]; } |
| { int arr[F(__has_trivial_constructor(AllPrivate))]; } |
| { int arr[F(__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. |
| { int arr[T(__has_trivial_move_constructor(POD))]; } |
| { int arr[T(__has_trivial_move_constructor(Union))]; } |
| { int arr[T(__has_trivial_move_constructor(HasCons))]; } |
| { int arr[T(__has_trivial_move_constructor(HasStaticMemberMoveCtor))]; } |
| { int arr[T(__has_trivial_move_constructor(AllDeleted))]; } |
| { int arr[T(__has_trivial_move_constructor(ACompleteType[]))]; } |
| |
| { int arr[F(__has_trivial_move_constructor(AnIncompleteType[]))]; } // expected-error {{incomplete type}} |
| { int arr[F(__has_trivial_move_constructor(HasVirt))]; } |
| { int arr[F(__has_trivial_move_constructor(DerivesVirt))]; } |
| { int arr[F(__has_trivial_move_constructor(HasMoveCtor))]; } |
| { int arr[F(__has_trivial_move_constructor(DerivesHasMoveCtor))]; } |
| { int arr[F(__has_trivial_move_constructor(HasMemberMoveCtor))]; } |
| } |
| |
| void has_trivial_copy_constructor() { |
| { int arr[T(__has_trivial_copy(Int))]; } |
| { int arr[T(__has_trivial_copy(IntAr))]; } |
| { int arr[T(__has_trivial_copy(Union))]; } |
| { int arr[T(__has_trivial_copy(UnionAr))]; } |
| { int arr[T(__has_trivial_copy(POD))]; } |
| { int arr[T(__has_trivial_copy(Derives))]; } |
| { int arr[T(__has_trivial_copy(ConstIntAr))]; } |
| { int arr[T(__has_trivial_copy(ConstIntArAr))]; } |
| { int arr[T(__has_trivial_copy(HasDest))]; } |
| { int arr[T(__has_trivial_copy(HasPriv))]; } |
| { int arr[T(__has_trivial_copy(HasCons))]; } |
| { int arr[T(__has_trivial_copy(HasRef))]; } |
| { int arr[T(__has_trivial_copy(HasMove))]; } |
| { int arr[T(__has_trivial_copy(IntRef))]; } |
| { int arr[T(__has_trivial_copy(HasCopyAssign))]; } |
| { int arr[T(__has_trivial_copy(HasMoveAssign))]; } |
| { int arr[T(__has_trivial_copy(const Int))]; } |
| { int arr[T(__has_trivial_copy(AllDefaulted))]; } |
| { int arr[T(__has_trivial_copy(AllDeleted))]; } |
| { int arr[T(__has_trivial_copy(DerivesAr))]; } |
| { int arr[T(__has_trivial_copy(DerivesHasRef))]; } |
| { int arr[T(__has_trivial_copy(ACompleteType[]))]; } |
| |
| { int arr[F(__has_trivial_copy(AnIncompleteType[]))]; } // expected-error {{incomplete type}} |
| { int arr[F(__has_trivial_copy(HasCopy))]; } |
| { int arr[F(__has_trivial_copy(HasTemplateCons))]; } |
| { int arr[F(__has_trivial_copy(VirtAr))]; } |
| { int arr[F(__has_trivial_copy(void))]; } |
| { int arr[F(__has_trivial_copy(cvoid))]; } |
| { int arr[F(__has_trivial_copy(AllPrivate))]; } |
| { int arr[F(__has_trivial_copy(ExtDefaulted))]; } |
| } |
| |
| void has_trivial_copy_assignment() { |
| { int arr[T(__has_trivial_assign(Int))]; } |
| { int arr[T(__has_trivial_assign(IntAr))]; } |
| { int arr[T(__has_trivial_assign(Union))]; } |
| { int arr[T(__has_trivial_assign(UnionAr))]; } |
| { int arr[T(__has_trivial_assign(POD))]; } |
| { int arr[T(__has_trivial_assign(Derives))]; } |
| { int arr[T(__has_trivial_assign(HasDest))]; } |
| { int arr[T(__has_trivial_assign(HasPriv))]; } |
| { int arr[T(__has_trivial_assign(HasCons))]; } |
| { int arr[T(__has_trivial_assign(HasRef))]; } |
| { int arr[T(__has_trivial_assign(HasCopy))]; } |
| { int arr[T(__has_trivial_assign(HasMove))]; } |
| { int arr[T(__has_trivial_assign(HasMoveAssign))]; } |
| { int arr[T(__has_trivial_assign(AllDefaulted))]; } |
| { int arr[T(__has_trivial_assign(AllDeleted))]; } |
| { int arr[T(__has_trivial_assign(DerivesAr))]; } |
| { int arr[T(__has_trivial_assign(DerivesHasRef))]; } |
| { int arr[T(__has_trivial_assign(ACompleteType[]))]; } |
| |
| { int arr[F(__has_trivial_assign(AnIncompleteType[]))]; } // expected-error {{incomplete type}} |
| { int arr[F(__has_trivial_assign(IntRef))]; } |
| { int arr[F(__has_trivial_assign(HasCopyAssign))]; } |
| { int arr[F(__has_trivial_assign(const Int))]; } |
| { int arr[F(__has_trivial_assign(ConstIntAr))]; } |
| { int arr[F(__has_trivial_assign(ConstIntArAr))]; } |
| { int arr[F(__has_trivial_assign(VirtAr))]; } |
| { int arr[F(__has_trivial_assign(void))]; } |
| { int arr[F(__has_trivial_assign(cvoid))]; } |
| { int arr[F(__has_trivial_assign(AllPrivate))]; } |
| { int arr[F(__has_trivial_assign(ExtDefaulted))]; } |
| } |
| |
| void has_trivial_destructor() { |
| { int arr[T(__has_trivial_destructor(Int))]; } |
| { int arr[T(__has_trivial_destructor(IntAr))]; } |
| { int arr[T(__has_trivial_destructor(Union))]; } |
| { int arr[T(__has_trivial_destructor(UnionAr))]; } |
| { int arr[T(__has_trivial_destructor(POD))]; } |
| { int arr[T(__has_trivial_destructor(Derives))]; } |
| { int arr[T(__has_trivial_destructor(ConstIntAr))]; } |
| { int arr[T(__has_trivial_destructor(ConstIntArAr))]; } |
| { int arr[T(__has_trivial_destructor(HasPriv))]; } |
| { int arr[T(__has_trivial_destructor(HasCons))]; } |
| { int arr[T(__has_trivial_destructor(HasRef))]; } |
| { int arr[T(__has_trivial_destructor(HasCopy))]; } |
| { int arr[T(__has_trivial_destructor(HasMove))]; } |
| { int arr[T(__has_trivial_destructor(IntRef))]; } |
| { int arr[T(__has_trivial_destructor(HasCopyAssign))]; } |
| { int arr[T(__has_trivial_destructor(HasMoveAssign))]; } |
| { int arr[T(__has_trivial_destructor(const Int))]; } |
| { int arr[T(__has_trivial_destructor(DerivesAr))]; } |
| { int arr[T(__has_trivial_destructor(VirtAr))]; } |
| { int arr[T(__has_trivial_destructor(AllDefaulted))]; } |
| { int arr[T(__has_trivial_destructor(AllDeleted))]; } |
| { int arr[T(__has_trivial_destructor(DerivesHasRef))]; } |
| { int arr[T(__has_trivial_destructor(ACompleteType[]))]; } |
| |
| { int arr[F(__has_trivial_destructor(HasDest))]; } |
| { int arr[F(__has_trivial_destructor(AnIncompleteType[]))]; } // expected-error {{incomplete type}} |
| { int arr[F(__has_trivial_destructor(void))]; } |
| { int arr[F(__has_trivial_destructor(cvoid))]; } |
| { int arr[F(__has_trivial_destructor(AllPrivate))]; } |
| { int arr[F(__has_trivial_destructor(ExtDefaulted))]; } |
| } |
| |
| struct A { ~A() {} }; |
| template<typename> struct B : A { }; |
| |
| void f() { |
| { int arr[F(__has_trivial_destructor(A))]; } |
| { int arr[F(__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() { |
| { int arr[T(__has_nothrow_assign(Int))]; } |
| { int arr[T(__has_nothrow_assign(IntAr))]; } |
| { int arr[T(__has_nothrow_assign(Union))]; } |
| { int arr[T(__has_nothrow_assign(UnionAr))]; } |
| { int arr[T(__has_nothrow_assign(POD))]; } |
| { int arr[T(__has_nothrow_assign(Derives))]; } |
| { int arr[T(__has_nothrow_assign(HasDest))]; } |
| { int arr[T(__has_nothrow_assign(HasPriv))]; } |
| { int arr[T(__has_nothrow_assign(HasCons))]; } |
| { int arr[T(__has_nothrow_assign(HasRef))]; } |
| { int arr[T(__has_nothrow_assign(HasCopy))]; } |
| { int arr[T(__has_nothrow_assign(HasMove))]; } |
| { int arr[T(__has_nothrow_assign(HasMoveAssign))]; } |
| { int arr[T(__has_nothrow_assign(HasNoThrowCopyAssign))]; } |
| { int arr[T(__has_nothrow_assign(HasMultipleNoThrowCopyAssign))]; } |
| { int arr[T(__has_nothrow_assign(HasVirtDest))]; } |
| { int arr[T(__has_nothrow_assign(AllPrivate))]; } |
| { int arr[T(__has_nothrow_assign(UsingAssign))]; } |
| { int arr[T(__has_nothrow_assign(DerivesAr))]; } |
| { int arr[T(__has_nothrow_assign(ACompleteType[]))]; } |
| |
| { int arr[F(__has_nothrow_assign(AnIncompleteType[]))]; } // expected-error {{incomplete type}} |
| { int arr[F(__has_nothrow_assign(IntRef))]; } |
| { int arr[F(__has_nothrow_assign(HasCopyAssign))]; } |
| { int arr[F(__has_nothrow_assign(HasMultipleCopyAssign))]; } |
| { int arr[F(__has_nothrow_assign(const Int))]; } |
| { int arr[F(__has_nothrow_assign(ConstIntAr))]; } |
| { int arr[F(__has_nothrow_assign(ConstIntArAr))]; } |
| { int arr[F(__has_nothrow_assign(VirtAr))]; } |
| { int arr[F(__has_nothrow_assign(void))]; } |
| { int arr[F(__has_nothrow_assign(cvoid))]; } |
| { int arr[F(__has_nothrow_assign(PR11110))]; } |
| } |
| |
| void has_nothrow_move_assign() { |
| { int arr[T(__has_nothrow_move_assign(Int))]; } |
| { int arr[T(__has_nothrow_move_assign(Enum))]; } |
| { int arr[T(__has_nothrow_move_assign(Int*))]; } |
| { int arr[T(__has_nothrow_move_assign(Enum POD::*))]; } |
| { int arr[T(__has_nothrow_move_assign(POD))]; } |
| { int arr[T(__has_nothrow_move_assign(HasPriv))]; } |
| { int arr[T(__has_nothrow_move_assign(HasNoThrowMoveAssign))]; } |
| { int arr[T(__has_nothrow_move_assign(HasNoExceptNoThrowMoveAssign))]; } |
| { int arr[T(__has_nothrow_move_assign(HasMemberNoThrowMoveAssign))]; } |
| { int arr[T(__has_nothrow_move_assign(HasMemberNoExceptNoThrowMoveAssign))]; } |
| { int arr[T(__has_nothrow_move_assign(AllDeleted))]; } |
| { int arr[T(__has_nothrow_move_assign(ACompleteType[]))]; } |
| |
| { int arr[F(__has_nothrow_move_assign(AnIncompleteType[]))]; } // expected-error {{incomplete type}} |
| { int arr[F(__has_nothrow_move_assign(HasThrowMoveAssign))]; } |
| { int arr[F(__has_nothrow_move_assign(HasNoExceptFalseMoveAssign))]; } |
| { int arr[F(__has_nothrow_move_assign(HasMemberThrowMoveAssign))]; } |
| { int arr[F(__has_nothrow_move_assign(HasMemberNoExceptFalseMoveAssign))]; } |
| { int arr[F(__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyCtor))]; } |
| { int arr[F(__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyAssign))]; } |
| { int arr[F(__has_nothrow_move_assign(NoDefaultMoveAssignDueToDtor))]; } |
| |
| |
| { int arr[T(__is_nothrow_assignable(HasNoThrowMoveAssign, HasNoThrowMoveAssign))]; } |
| { int arr[F(__is_nothrow_assignable(HasThrowMoveAssign, HasThrowMoveAssign))]; } |
| |
| { int arr[T(__is_assignable(HasNoThrowMoveAssign, HasNoThrowMoveAssign))]; } |
| { int arr[T(__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; |
| { int arr[T(__has_trivial_move_assign(Int))]; } |
| { int arr[T(__has_trivial_move_assign(HasStaticMemberMoveAssign))]; } |
| { int arr[T(__has_trivial_move_assign(AllDeleted))]; } |
| { int arr[T(__has_trivial_move_assign(ACompleteType[]))]; } |
| |
| { int arr[F(__has_trivial_move_assign(AnIncompleteType[]))]; } // expected-error {{incomplete type}} |
| { int arr[F(__has_trivial_move_assign(HasVirt))]; } |
| { int arr[F(__has_trivial_move_assign(DerivesVirt))]; } |
| { int arr[F(__has_trivial_move_assign(HasMoveAssign))]; } |
| { int arr[F(__has_trivial_move_assign(DerivesHasMoveAssign))]; } |
| { int arr[F(__has_trivial_move_assign(HasMemberMoveAssign))]; } |
| { int arr[F(__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyCtor))]; } |
| { int arr[F(__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyAssign))]; } |
| } |
| |
| void has_nothrow_copy() { |
| { int arr[T(__has_nothrow_copy(Int))]; } |
| { int arr[T(__has_nothrow_copy(IntAr))]; } |
| { int arr[T(__has_nothrow_copy(Union))]; } |
| { int arr[T(__has_nothrow_copy(UnionAr))]; } |
| { int arr[T(__has_nothrow_copy(POD))]; } |
| { int arr[T(__has_nothrow_copy(const Int))]; } |
| { int arr[T(__has_nothrow_copy(ConstIntAr))]; } |
| { int arr[T(__has_nothrow_copy(ConstIntArAr))]; } |
| { int arr[T(__has_nothrow_copy(Derives))]; } |
| { int arr[T(__has_nothrow_copy(IntRef))]; } |
| { int arr[T(__has_nothrow_copy(HasDest))]; } |
| { int arr[T(__has_nothrow_copy(HasPriv))]; } |
| { int arr[T(__has_nothrow_copy(HasCons))]; } |
| { int arr[T(__has_nothrow_copy(HasRef))]; } |
| { int arr[T(__has_nothrow_copy(HasMove))]; } |
| { int arr[T(__has_nothrow_copy(HasCopyAssign))]; } |
| { int arr[T(__has_nothrow_copy(HasMoveAssign))]; } |
| { int arr[T(__has_nothrow_copy(HasNoThrowCopy))]; } |
| { int arr[T(__has_nothrow_copy(HasMultipleNoThrowCopy))]; } |
| { int arr[T(__has_nothrow_copy(HasVirtDest))]; } |
| { int arr[T(__has_nothrow_copy(HasTemplateCons))]; } |
| { int arr[T(__has_nothrow_copy(AllPrivate))]; } |
| { int arr[T(__has_nothrow_copy(DerivesAr))]; } |
| { int arr[T(__has_nothrow_copy(ACompleteType[]))]; } |
| |
| { int arr[F(__has_nothrow_copy(AnIncompleteType[]))]; } // expected-error {{incomplete type}} |
| { int arr[F(__has_nothrow_copy(HasCopy))]; } |
| { int arr[F(__has_nothrow_copy(HasMultipleCopy))]; } |
| { int arr[F(__has_nothrow_copy(VirtAr))]; } |
| { int arr[F(__has_nothrow_copy(void))]; } |
| { int arr[F(__has_nothrow_copy(cvoid))]; } |
| } |
| |
| void has_nothrow_constructor() { |
| { int arr[T(__has_nothrow_constructor(Int))]; } |
| { int arr[T(__has_nothrow_constructor(IntAr))]; } |
| { int arr[T(__has_nothrow_constructor(Union))]; } |
| { int arr[T(__has_nothrow_constructor(UnionAr))]; } |
| { int arr[T(__has_nothrow_constructor(POD))]; } |
| { int arr[T(__has_nothrow_constructor(Derives))]; } |
| { int arr[T(__has_nothrow_constructor(DerivesAr))]; } |
| { int arr[T(__has_nothrow_constructor(ConstIntAr))]; } |
| { int arr[T(__has_nothrow_constructor(ConstIntArAr))]; } |
| { int arr[T(__has_nothrow_constructor(HasDest))]; } |
| { int arr[T(__has_nothrow_constructor(HasPriv))]; } |
| { int arr[T(__has_nothrow_constructor(HasCopyAssign))]; } |
| { int arr[T(__has_nothrow_constructor(const Int))]; } |
| { int arr[T(__has_nothrow_constructor(HasNoThrowConstructor))]; } |
| { int arr[T(__has_nothrow_constructor(HasVirtDest))]; } |
| // { int arr[T(__has_nothrow_constructor(VirtAr))]; } // not implemented |
| { int arr[T(__has_nothrow_constructor(AllPrivate))]; } |
| { int arr[T(__has_nothrow_constructor(ACompleteType[]))]; } |
| |
| { int arr[F(__has_nothrow_constructor(AnIncompleteType[]))]; } // expected-error {{incomplete type}} |
| { int arr[F(__has_nothrow_constructor(HasCons))]; } |
| { int arr[F(__has_nothrow_constructor(HasRef))]; } |
| { int arr[F(__has_nothrow_constructor(HasCopy))]; } |
| { int arr[F(__has_nothrow_constructor(HasMove))]; } |
| { int arr[F(__has_nothrow_constructor(HasNoThrowConstructorWithArgs))]; } |
| { int arr[F(__has_nothrow_constructor(IntRef))]; } |
| { int arr[F(__has_nothrow_constructor(void))]; } |
| { int arr[F(__has_nothrow_constructor(cvoid))]; } |
| { int arr[F(__has_nothrow_constructor(HasTemplateCons))]; } |
| |
| { int arr[F(__has_nothrow_constructor(HasMultipleDefaultConstructor1))]; } |
| { int arr[F(__has_nothrow_constructor(HasMultipleDefaultConstructor2))]; } |
| } |
| |
| void has_virtual_destructor() { |
| { int arr[F(__has_virtual_destructor(Int))]; } |
| { int arr[F(__has_virtual_destructor(IntAr))]; } |
| { int arr[F(__has_virtual_destructor(Union))]; } |
| { int arr[F(__has_virtual_destructor(UnionAr))]; } |
| { int arr[F(__has_virtual_destructor(POD))]; } |
| { int arr[F(__has_virtual_destructor(Derives))]; } |
| { int arr[F(__has_virtual_destructor(DerivesAr))]; } |
| { int arr[F(__has_virtual_destructor(const Int))]; } |
| { int arr[F(__has_virtual_destructor(ConstIntAr))]; } |
| { int arr[F(__has_virtual_destructor(ConstIntArAr))]; } |
| { int arr[F(__has_virtual_destructor(HasDest))]; } |
| { int arr[F(__has_virtual_destructor(HasPriv))]; } |
| { int arr[F(__has_virtual_destructor(HasCons))]; } |
| { int arr[F(__has_virtual_destructor(HasRef))]; } |
| { int arr[F(__has_virtual_destructor(HasCopy))]; } |
| { int arr[F(__has_virtual_destructor(HasMove))]; } |
| { int arr[F(__has_virtual_destructor(HasCopyAssign))]; } |
| { int arr[F(__has_virtual_destructor(HasMoveAssign))]; } |
| { int arr[F(__has_virtual_destructor(IntRef))]; } |
| { int arr[F(__has_virtual_destructor(VirtAr))]; } |
| { int arr[F(__has_virtual_destructor(ACompleteType[]))]; } |
| |
| { int arr[F(__has_virtual_destructor(AnIncompleteType[]))]; } // expected-error {{incomplete type}} |
| { int arr[T(__has_virtual_destructor(HasVirtDest))]; } |
| { int arr[T(__has_virtual_destructor(DerivedVirtDest))]; } |
| { int arr[F(__has_virtual_destructor(VirtDestAr))]; } |
| { int arr[F(__has_virtual_destructor(void))]; } |
| { int arr[F(__has_virtual_destructor(cvoid))]; } |
| { int arr[F(__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 <typename Base, typename Derived> |
| void isBaseOfT() { |
| int t[T(__is_base_of(Base, Derived))]; |
| }; |
| template <typename Base, typename Derived> |
| void isBaseOfF() { |
| int t[F(__is_base_of(Base, Derived))]; |
| }; |
| |
| template <class T> class DerivedTemp : Base {}; |
| template <class T> class NonderivedTemp {}; |
| template <class T> class UndefinedTemp; // expected-note {{declared here}} |
| |
| void is_base_of() { |
| { int arr[T(__is_base_of(Base, Derived))]; } |
| { int arr[T(__is_base_of(const Base, Derived))]; } |
| { int arr[F(__is_base_of(Derived, Base))]; } |
| { int arr[F(__is_base_of(Derived, int))]; } |
| { int arr[T(__is_base_of(Base, Base))]; } |
| { int arr[T(__is_base_of(Base, Derived3))]; } |
| { int arr[T(__is_base_of(Derived, Derived3))]; } |
| { int arr[T(__is_base_of(Derived2b, Derived3))]; } |
| { int arr[T(__is_base_of(Derived2a, Derived3))]; } |
| { int arr[T(__is_base_of(BaseA<int>, DerivedB<int>))]; } |
| { int arr[F(__is_base_of(DerivedB<int>, BaseA<int>))]; } |
| { int arr[T(__is_base_of(Base, CrazyDerived<Base>))]; } |
| { int arr[F(__is_base_of(Union, Union))]; } |
| { int arr[T(__is_base_of(Empty, Empty))]; } |
| { int arr[T(__is_base_of(class_forward, class_forward))]; } |
| { int arr[F(__is_base_of(Empty, class_forward))]; } // expected-error {{incomplete type 'class_forward' used in type trait expression}} |
| { int arr[F(__is_base_of(Base&, Derived&))]; } |
| int t18[F(__is_base_of(Base[10], Derived[10]))]; |
| { int arr[F(__is_base_of(int, int))]; } |
| { int arr[F(__is_base_of(long, int))]; } |
| { int arr[T(__is_base_of(Base, DerivedTemp<int>))]; } |
| { int arr[F(__is_base_of(Base, NonderivedTemp<int>))]; } |
| { int arr[F(__is_base_of(Base, UndefinedTemp<int>))]; } // expected-error {{implicit instantiation of undefined template 'UndefinedTemp<int>'}} |
| |
| isBaseOfT<Base, Derived>(); |
| isBaseOfF<Derived, Base>(); |
| |
| isBaseOfT<Base, CrazyDerived<Base> >(); |
| isBaseOfF<CrazyDerived<Base>, Base>(); |
| |
| isBaseOfT<BaseA<int>, DerivedB<int> >(); |
| isBaseOfF<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() |
| { |
| int t01[T(__is_same(Base, Base))]; |
| int t02[T(__is_same(Base, BaseTypedef))]; |
| int t03[T(__is_same(TemplateClass<int, int>, TemplateAlias<int>))]; |
| |
| int t10[F(__is_same(Base, const Base))]; |
| int t11[F(__is_same(Base, Base&))]; |
| int t12[F(__is_same(Base, Derived))]; |
| } |
| |
| struct IntWrapper |
| { |
| int value; |
| IntWrapper(int _value) : value(_value) {} |
| operator int() const { |
| return value; |
| } |
| }; |
| |
| struct FloatWrapper |
| { |
| float value; |
| FloatWrapper(float _value) : 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() |
| { |
| int t01[T(__is_convertible(IntWrapper, IntWrapper))]; |
| int t02[T(__is_convertible(IntWrapper, const IntWrapper))]; |
| int t03[T(__is_convertible(IntWrapper, int))]; |
| int t04[T(__is_convertible(int, IntWrapper))]; |
| int t05[T(__is_convertible(IntWrapper, FloatWrapper))]; |
| int t06[T(__is_convertible(FloatWrapper, IntWrapper))]; |
| int t07[T(__is_convertible(FloatWrapper, float))]; |
| int t08[T(__is_convertible(float, 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() { |
| { int arr[T(__is_convertible_to(Int, Int))]; } |
| { int arr[F(__is_convertible_to(Int, IntAr))]; } |
| { int arr[F(__is_convertible_to(IntAr, IntAr))]; } |
| { int arr[T(__is_convertible_to(void, void))]; } |
| { int arr[T(__is_convertible_to(cvoid, void))]; } |
| { int arr[T(__is_convertible_to(void, cvoid))]; } |
| { int arr[T(__is_convertible_to(cvoid, cvoid))]; } |
| { int arr[T(__is_convertible_to(int, FromInt))]; } |
| { int arr[T(__is_convertible_to(long, FromInt))]; } |
| { int arr[T(__is_convertible_to(double, FromInt))]; } |
| { int arr[T(__is_convertible_to(const int, FromInt))]; } |
| { int arr[T(__is_convertible_to(const int&, FromInt))]; } |
| { int arr[T(__is_convertible_to(ToInt, int))]; } |
| { int arr[T(__is_convertible_to(ToInt, const int&))]; } |
| { int arr[T(__is_convertible_to(ToInt, long))]; } |
| { int arr[F(__is_convertible_to(ToInt, int&))]; } |
| { int arr[F(__is_convertible_to(ToInt, FromInt))]; } |
| { int arr[T(__is_convertible_to(IntAr&, IntAr&))]; } |
| { int arr[T(__is_convertible_to(IntAr&, const IntAr&))]; } |
| { int arr[F(__is_convertible_to(const IntAr&, IntAr&))]; } |
| { int arr[F(__is_convertible_to(Function, Function))]; } |
| { int arr[F(__is_convertible_to(PrivateCopy, PrivateCopy))]; } |
| { int arr[T(__is_convertible_to(X0<int>, X0<float>))]; } |
| { int arr[F(__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() |
| { |
| { int arr[T(__is_trivial(int))]; } |
| { int arr[T(__is_trivial(Enum))]; } |
| { int arr[T(__is_trivial(POD))]; } |
| { int arr[T(__is_trivial(Int))]; } |
| { int arr[T(__is_trivial(IntAr))]; } |
| { int arr[T(__is_trivial(IntArNB))]; } |
| { int arr[T(__is_trivial(Statics))]; } |
| { int arr[T(__is_trivial(Empty))]; } |
| { int arr[T(__is_trivial(EmptyUnion))]; } |
| { int arr[T(__is_trivial(Union))]; } |
| { int arr[T(__is_trivial(Derives))]; } |
| { int arr[T(__is_trivial(DerivesAr))]; } |
| { int arr[T(__is_trivial(DerivesArNB))]; } |
| { int arr[T(__is_trivial(DerivesEmpty))]; } |
| { int arr[T(__is_trivial(HasFunc))]; } |
| { int arr[T(__is_trivial(HasOp))]; } |
| { int arr[T(__is_trivial(HasConv))]; } |
| { int arr[T(__is_trivial(HasAssign))]; } |
| { int arr[T(__is_trivial(HasAnonymousUnion))]; } |
| { int arr[T(__is_trivial(HasPriv))]; } |
| { int arr[T(__is_trivial(HasProt))]; } |
| { int arr[T(__is_trivial(DerivesHasPriv))]; } |
| { int arr[T(__is_trivial(DerivesHasProt))]; } |
| { int arr[T(__is_trivial(Vector))]; } |
| { int arr[T(__is_trivial(VectorExt))]; } |
| |
| { int arr[F(__is_trivial(HasCons))]; } |
| { int arr[F(__is_trivial(HasCopyAssign))]; } |
| { int arr[F(__is_trivial(HasMoveAssign))]; } |
| { int arr[F(__is_trivial(HasDest))]; } |
| { int arr[F(__is_trivial(HasRef))]; } |
| { int arr[F(__is_trivial(HasNonPOD))]; } |
| { int arr[F(__is_trivial(HasVirt))]; } |
| { int arr[F(__is_trivial(DerivesHasCons))]; } |
| { int arr[F(__is_trivial(DerivesHasCopyAssign))]; } |
| { int arr[F(__is_trivial(DerivesHasMoveAssign))]; } |
| { int arr[F(__is_trivial(DerivesHasDest))]; } |
| { int arr[F(__is_trivial(DerivesHasRef))]; } |
| { int arr[F(__is_trivial(DerivesHasVirt))]; } |
| { int arr[F(__is_trivial(void))]; } |
| { int arr[F(__is_trivial(cvoid))]; } |
| } |
| |
| template<typename T> struct TriviallyConstructibleTemplate {}; |
| |
| void trivial_checks() |
| { |
| { int arr[T(__is_trivially_copyable(int))]; } |
| { int arr[T(__is_trivially_copyable(Enum))]; } |
| { int arr[T(__is_trivially_copyable(POD))]; } |
| { int arr[T(__is_trivially_copyable(Int))]; } |
| { int arr[T(__is_trivially_copyable(IntAr))]; } |
| { int arr[T(__is_trivially_copyable(IntArNB))]; } |
| { int arr[T(__is_trivially_copyable(Statics))]; } |
| { int arr[T(__is_trivially_copyable(Empty))]; } |
| { int arr[T(__is_trivially_copyable(EmptyUnion))]; } |
| { int arr[T(__is_trivially_copyable(Union))]; } |
| { int arr[T(__is_trivially_copyable(Derives))]; } |
| { int arr[T(__is_trivially_copyable(DerivesAr))]; } |
| { int arr[T(__is_trivially_copyable(DerivesArNB))]; } |
| { int arr[T(__is_trivially_copyable(DerivesEmpty))]; } |
| { int arr[T(__is_trivially_copyable(HasFunc))]; } |
| { int arr[T(__is_trivially_copyable(HasOp))]; } |
| { int arr[T(__is_trivially_copyable(HasConv))]; } |
| { int arr[T(__is_trivially_copyable(HasAssign))]; } |
| { int arr[T(__is_trivially_copyable(HasAnonymousUnion))]; } |
| { int arr[T(__is_trivially_copyable(HasPriv))]; } |
| { int arr[T(__is_trivially_copyable(HasProt))]; } |
| { int arr[T(__is_trivially_copyable(DerivesHasPriv))]; } |
| { int arr[T(__is_trivially_copyable(DerivesHasProt))]; } |
| { int arr[T(__is_trivially_copyable(Vector))]; } |
| { int arr[T(__is_trivially_copyable(VectorExt))]; } |
| { int arr[T(__is_trivially_copyable(HasCons))]; } |
| { int arr[T(__is_trivially_copyable(HasRef))]; } |
| { int arr[T(__is_trivially_copyable(HasNonPOD))]; } |
| { int arr[T(__is_trivially_copyable(DerivesHasCons))]; } |
| { int arr[T(__is_trivially_copyable(DerivesHasRef))]; } |
| { int arr[T(__is_trivially_copyable(NonTrivialDefault))]; } |
| { int arr[T(__is_trivially_copyable(NonTrivialDefault[]))]; } |
| { int arr[T(__is_trivially_copyable(NonTrivialDefault[3]))]; } |
| |
| { int arr[F(__is_trivially_copyable(HasCopyAssign))]; } |
| { int arr[F(__is_trivially_copyable(HasMoveAssign))]; } |
| { int arr[F(__is_trivially_copyable(HasDest))]; } |
| { int arr[F(__is_trivially_copyable(HasVirt))]; } |
| { int arr[F(__is_trivially_copyable(DerivesHasCopyAssign))]; } |
| { int arr[F(__is_trivially_copyable(DerivesHasMoveAssign))]; } |
| { int arr[F(__is_trivially_copyable(DerivesHasDest))]; } |
| { int arr[F(__is_trivially_copyable(DerivesHasVirt))]; } |
| { int arr[F(__is_trivially_copyable(void))]; } |
| { int arr[F(__is_trivially_copyable(cvoid))]; } |
| |
| { int arr[T((__is_trivially_constructible(int)))]; } |
| { int arr[T((__is_trivially_constructible(int, int)))]; } |
| { int arr[T((__is_trivially_constructible(int, float)))]; } |
| { int arr[T((__is_trivially_constructible(int, int&)))]; } |
| { int arr[T((__is_trivially_constructible(int, const int&)))]; } |
| { int arr[T((__is_trivially_constructible(int, int)))]; } |
| { int arr[T((__is_trivially_constructible(HasCopyAssign, HasCopyAssign)))]; } |
| { int arr[T((__is_trivially_constructible(HasCopyAssign, const HasCopyAssign&)))]; } |
| { int arr[T((__is_trivially_constructible(HasCopyAssign, HasCopyAssign&&)))]; } |
| { int arr[T((__is_trivially_constructible(HasCopyAssign)))]; } |
| { int arr[T((__is_trivially_constructible(NonTrivialDefault, |
| const NonTrivialDefault&)))]; } |
| { int arr[T((__is_trivially_constructible(NonTrivialDefault, |
| NonTrivialDefault&&)))]; } |
| { int arr[T((__is_trivially_constructible(AllDefaulted)))]; } |
| { int arr[T((__is_trivially_constructible(AllDefaulted, |
| const AllDefaulted &)))]; } |
| { int arr[T((__is_trivially_constructible(AllDefaulted, |
| AllDefaulted &&)))]; } |
| |
| { int arr[F((__is_trivially_constructible(int, int*)))]; } |
| { int arr[F((__is_trivially_constructible(NonTrivialDefault)))]; } |
| { int arr[F((__is_trivially_constructible(ThreeArgCtor, int*, char*, int&)))]; } |
| { int arr[F((__is_trivially_constructible(AllDeleted)))]; } |
| { int arr[F((__is_trivially_constructible(AllDeleted, |
| const AllDeleted &)))]; } |
| { int arr[F((__is_trivially_constructible(AllDeleted, |
| AllDeleted &&)))]; } |
| { int arr[F((__is_trivially_constructible(ExtDefaulted)))]; } |
| { int arr[F((__is_trivially_constructible(ExtDefaulted, |
| const ExtDefaulted &)))]; } |
| { int arr[F((__is_trivially_constructible(ExtDefaulted, |
| ExtDefaulted &&)))]; } |
| |
| { int arr[T((__is_trivially_constructible(TriviallyConstructibleTemplate<int>)))]; } |
| { int arr[F((__is_trivially_constructible(class_forward)))]; } // expected-error {{incomplete type 'class_forward' used in type trait expression}} |
| { int arr[F((__is_trivially_constructible(class_forward[])))]; } |
| { int arr[F((__is_trivially_constructible(void)))]; } |
| |
| { int arr[T((__is_trivially_assignable(int&, int)))]; } |
| { int arr[T((__is_trivially_assignable(int&, int&)))]; } |
| { int arr[T((__is_trivially_assignable(int&, int&&)))]; } |
| { int arr[T((__is_trivially_assignable(int&, const int&)))]; } |
| { int arr[T((__is_trivially_assignable(POD&, POD)))]; } |
| { int arr[T((__is_trivially_assignable(POD&, POD&)))]; } |
| { int arr[T((__is_trivially_assignable(POD&, POD&&)))]; } |
| { int arr[T((__is_trivially_assignable(POD&, const POD&)))]; } |
| { int arr[T((__is_trivially_assignable(int*&, int*)))]; } |
| { int arr[T((__is_trivially_assignable(AllDefaulted, |
| const AllDefaulted &)))]; } |
| { int arr[T((__is_trivially_assignable(AllDefaulted, |
| AllDefaulted &&)))]; } |
| |
| { int arr[F((__is_trivially_assignable(int*&, float*)))]; } |
| { int arr[F((__is_trivially_assignable(HasCopyAssign&, HasCopyAssign)))]; } |
| { int arr[F((__is_trivially_assignable(HasCopyAssign&, HasCopyAssign&)))]; } |
| { int arr[F((__is_trivially_assignable(HasCopyAssign&, const HasCopyAssign&)))]; } |
| { int arr[F((__is_trivially_assignable(HasCopyAssign&, HasCopyAssign&&)))]; } |
| { int arr[F((__is_trivially_assignable(TrivialMoveButNotCopy&, |
| TrivialMoveButNotCopy&)))]; } |
| { int arr[F((__is_trivially_assignable(TrivialMoveButNotCopy&, |
| const TrivialMoveButNotCopy&)))]; } |
| { int arr[F((__is_trivially_assignable(AllDeleted, |
| const AllDeleted &)))]; } |
| { int arr[F((__is_trivially_assignable(AllDeleted, |
| AllDeleted &&)))]; } |
| { int arr[F((__is_trivially_assignable(ExtDefaulted, |
| const ExtDefaulted &)))]; } |
| { int arr[F((__is_trivially_assignable(ExtDefaulted, |
| ExtDefaulted &&)))]; } |
| |
| { int arr[T((__is_trivially_assignable(HasDefaultTrivialCopyAssign&, |
| HasDefaultTrivialCopyAssign&)))]; } |
| { int arr[T((__is_trivially_assignable(HasDefaultTrivialCopyAssign&, |
| const HasDefaultTrivialCopyAssign&)))]; } |
| { int arr[T((__is_trivially_assignable(TrivialMoveButNotCopy&, |
| TrivialMoveButNotCopy)))]; } |
| { int arr[T((__is_trivially_assignable(TrivialMoveButNotCopy&, |
| TrivialMoveButNotCopy&&)))]; } |
| { int arr[T((__is_trivially_assignable(int&, int)))]; } |
| { int arr[T((__is_trivially_assignable(int&, int&)))]; } |
| { int arr[T((__is_trivially_assignable(int&, int&&)))]; } |
| { int arr[T((__is_trivially_assignable(int&, const int&)))]; } |
| { int arr[T((__is_trivially_assignable(POD&, POD)))]; } |
| { int arr[T((__is_trivially_assignable(POD&, POD&)))]; } |
| { int arr[T((__is_trivially_assignable(POD&, POD&&)))]; } |
| { int arr[T((__is_trivially_assignable(POD&, const POD&)))]; } |
| { int arr[T((__is_trivially_assignable(int*&, int*)))]; } |
| { int arr[T((__is_trivially_assignable(AllDefaulted, |
| const AllDefaulted &)))]; } |
| { int arr[T((__is_trivially_assignable(AllDefaulted, |
| AllDefaulted &&)))]; } |
| |
| { int arr[F((__is_assignable(int *&, float *)))]; } |
| { int arr[T((__is_assignable(HasCopyAssign &, HasCopyAssign)))]; } |
| { int arr[T((__is_assignable(HasCopyAssign &, HasCopyAssign &)))]; } |
| { int arr[T((__is_assignable(HasCopyAssign &, const HasCopyAssign &)))]; } |
| { int arr[T((__is_assignable(HasCopyAssign &, HasCopyAssign &&)))]; } |
| { int arr[T((__is_assignable(TrivialMoveButNotCopy &, |
| TrivialMoveButNotCopy &)))]; } |
| { int arr[T((__is_assignable(TrivialMoveButNotCopy &, |
| const TrivialMoveButNotCopy &)))]; } |
| { int arr[F((__is_assignable(AllDeleted, |
| const AllDeleted &)))]; } |
| { int arr[F((__is_assignable(AllDeleted, |
| AllDeleted &&)))]; } |
| { int arr[T((__is_assignable(ExtDefaulted, |
| const ExtDefaulted &)))]; } |
| { int arr[T((__is_assignable(ExtDefaulted, |
| ExtDefaulted &&)))]; } |
| |
| { int arr[T((__is_assignable(HasDefaultTrivialCopyAssign &, |
| HasDefaultTrivialCopyAssign &)))]; } |
| { int arr[T((__is_assignable(HasDefaultTrivialCopyAssign &, |
| const HasDefaultTrivialCopyAssign &)))]; } |
| { int arr[T((__is_assignable(TrivialMoveButNotCopy &, |
| TrivialMoveButNotCopy)))]; } |
| { int arr[T((__is_assignable(TrivialMoveButNotCopy &, |
| TrivialMoveButNotCopy &&)))]; } |
| |
| { int arr[T(__is_assignable(ACompleteType, ACompleteType))]; } |
| { int arr[F(__is_assignable(AnIncompleteType, AnIncompleteType))]; } // expected-error {{incomplete type}} |
| { int arr[F(__is_assignable(AnIncompleteType[], AnIncompleteType[]))]; } |
| { int arr[F(__is_assignable(AnIncompleteType[1], AnIncompleteType[1]))]; } // expected-error {{incomplete type}} |
| { int arr[F(__is_assignable(void, void))]; } |
| { int arr[F(__is_assignable(const volatile void, const volatile void))]; } |
| } |
| |
| void constructible_checks() { |
| { int arr[T(__is_constructible(HasNoThrowConstructorWithArgs))]; } |
| { int arr[F(__is_nothrow_constructible(HasNoThrowConstructorWithArgs))]; } // MSVC doesn't look into default args and gets this wrong. |
| |
| { int arr[T(__is_constructible(HasNoThrowConstructorWithArgs, HasCons))]; } |
| { int arr[T(__is_nothrow_constructible(HasNoThrowConstructorWithArgs, HasCons))]; } |
| |
| { int arr[T(__is_constructible(NonTrivialDefault))]; } |
| { int arr[F(__is_nothrow_constructible(NonTrivialDefault))]; } |
| |
| { int arr[T(__is_constructible(int))]; } |
| { int arr[T(__is_nothrow_constructible(int))]; } |
| |
| { int arr[F(__is_constructible(NonPOD))]; } |
| { int arr[F(__is_nothrow_constructible(NonPOD))]; } |
| |
| { int arr[T(__is_constructible(NonPOD, int))]; } |
| { int arr[F(__is_nothrow_constructible(NonPOD, int))]; } |
| |
| // PR19178 |
| { int arr[F(__is_constructible(Abstract))]; } |
| { int arr[F(__is_nothrow_constructible(Abstract))]; } |
| |
| // PR20228 |
| { int arr[T(__is_constructible(VariadicCtor, |
| int, int, int, int, int, int, int, int, int))]; } |
| |
| // PR25513 |
| { int arr[F(__is_constructible(int(int)))]; } |
| { int arr[T(__is_constructible(int const &, long))]; } |
| |
| { int arr[T(__is_constructible(ACompleteType))]; } |
| { int arr[T(__is_nothrow_constructible(ACompleteType))]; } |
| { int arr[F(__is_constructible(AnIncompleteType))]; } // expected-error {{incomplete type}} |
| { int arr[F(__is_nothrow_constructible(AnIncompleteType))]; } // expected-error {{incomplete type}} |
| { int arr[F(__is_constructible(AnIncompleteType[]))]; } |
| { int arr[F(__is_nothrow_constructible(AnIncompleteType[]))]; } |
| { int arr[F(__is_constructible(AnIncompleteType[1]))]; } // expected-error {{incomplete type}} |
| { int arr[F(__is_nothrow_constructible(AnIncompleteType[1]))]; } // expected-error {{incomplete type}} |
| { int arr[F(__is_constructible(void))]; } |
| { int arr[F(__is_nothrow_constructible(void))]; } |
| { int arr[F(__is_constructible(const volatile void))]; } |
| { int arr[F(__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() { |
| { int arr[T((is_trivially_constructible<int>::value))]; } |
| { int arr[T((is_trivially_constructible<int, int>::value))]; } |
| { int arr[T((is_trivially_constructible<int, float>::value))]; } |
| { int arr[T((is_trivially_constructible<int, int&>::value))]; } |
| { int arr[T((is_trivially_constructible<int, const int&>::value))]; } |
| { int arr[T((is_trivially_constructible<int, int>::value))]; } |
| { int arr[T((is_trivially_constructible<HasCopyAssign, HasCopyAssign>::value))]; } |
| { int arr[T((is_trivially_constructible<HasCopyAssign, const HasCopyAssign&>::value))]; } |
| { int arr[T((is_trivially_constructible<HasCopyAssign, HasCopyAssign&&>::value))]; } |
| { int arr[T((is_trivially_constructible<HasCopyAssign>::value))]; } |
| { int arr[T((is_trivially_constructible<NonTrivialDefault, |
| const NonTrivialDefault&>::value))]; } |
| { int arr[T((is_trivially_constructible<NonTrivialDefault, |
| NonTrivialDefault&&>::value))]; } |
| |
| { int arr[F((is_trivially_constructible<int, int*>::value))]; } |
| { int arr[F((is_trivially_constructible<NonTrivialDefault>::value))]; } |
| { int arr[F((is_trivially_constructible<ThreeArgCtor, int*, char*, int&>::value))]; } |
| { int arr[F((is_trivially_constructible<Abstract>::value))]; } // PR19178 |
| |
| { int arr[T(__is_trivially_constructible(ACompleteType))]; } |
| { int arr[F(__is_trivially_constructible(AnIncompleteType))]; } // expected-error {{incomplete type}} |
| { int arr[F(__is_trivially_constructible(AnIncompleteType[]))]; } |
| { int arr[F(__is_trivially_constructible(AnIncompleteType[1]))]; } // expected-error {{incomplete type}} |
| { int arr[F(__is_trivially_constructible(void))]; } |
| { int arr[F(__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() { |
| { int arr[F((__reference_binds_to_temporary(int &, int &)))]; } |
| { int arr[F((__reference_binds_to_temporary(int &, int &&)))]; } |
| |
| { int arr[F((__reference_binds_to_temporary(int const &, int &)))]; } |
| { int arr[F((__reference_binds_to_temporary(int const &, int const &)))]; } |
| { int arr[F((__reference_binds_to_temporary(int const &, int &&)))]; } |
| |
| { int arr[F((__reference_binds_to_temporary(int &, long &)))]; } // doesn't construct |
| { int arr[T((__reference_binds_to_temporary(int const &, long &)))]; } |
| { int arr[T((__reference_binds_to_temporary(int const &, long &&)))]; } |
| { int arr[T((__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 &>; |
| { int arr[T((__is_constructible(int &, LRef)))]; } |
| { int arr[F((__reference_binds_to_temporary(int &, LRef)))]; } |
| |
| { int arr[T((__is_constructible(int &&, RRef)))]; } |
| { int arr[F((__reference_binds_to_temporary(int &&, RRef)))]; } |
| |
| { int arr[T((__is_constructible(int const &, CLRef)))]; } |
| { int arr[F((__reference_binds_to_temporary(int &&, CLRef)))]; } |
| |
| { int arr[T((__is_constructible(int const &, LongRef)))]; } |
| { int arr[T((__reference_binds_to_temporary(int const &, LongRef)))]; } |
| |
| // Test that it doesn't accept non-reference types as input. |
| { int arr[F((__reference_binds_to_temporary(int, long)))]; } |
| |
| { int arr[T((__reference_binds_to_temporary(const int &, long)))]; } |
| } |
| |
| void array_rank() { |
| int t01[T(__array_rank(IntAr) == 1)]; |
| int t02[T(__array_rank(ConstIntArAr) == 2)]; |
| } |
| |
| void array_extent() { |
| int t01[T(__array_extent(IntAr, 0) == 10)]; |
| int t02[T(__array_extent(ConstIntArAr, 0) == 4)]; |
| int t03[T(__array_extent(ConstIntArAr, 1) == 10)]; |
| } |
| |
| void is_destructible_test() { |
| { int arr[T(__is_destructible(int))]; } |
| { int arr[T(__is_destructible(int[2]))]; } |
| { int arr[F(__is_destructible(int[]))]; } |
| { int arr[F(__is_destructible(void))]; } |
| { int arr[T(__is_destructible(int &))]; } |
| { int arr[T(__is_destructible(HasDest))]; } |
| { int arr[F(__is_destructible(AllPrivate))]; } |
| { int arr[T(__is_destructible(SuperNonTrivialStruct))]; } |
| { int arr[T(__is_destructible(AllDefaulted))]; } |
| { int arr[F(__is_destructible(AllDeleted))]; } |
| { int arr[T(__is_destructible(ThrowingDtor))]; } |
| { int arr[T(__is_destructible(NoThrowDtor))]; } |
| |
| { int arr[T(__is_destructible(ACompleteType))]; } |
| { int arr[F(__is_destructible(AnIncompleteType))]; } // expected-error {{incomplete type}} |
| { int arr[F(__is_destructible(AnIncompleteType[]))]; } |
| { int arr[F(__is_destructible(AnIncompleteType[1]))]; } // expected-error {{incomplete type}} |
| { int arr[F(__is_destructible(void))]; } |
| { int arr[F(__is_destructible(const volatile void))]; } |
| } |
| |
| void is_nothrow_destructible_test() { |
| { int arr[T(__is_nothrow_destructible(int))]; } |
| { int arr[T(__is_nothrow_destructible(int[2]))]; } |
| { int arr[F(__is_nothrow_destructible(int[]))]; } |
| { int arr[F(__is_nothrow_destructible(void))]; } |
| { int arr[T(__is_nothrow_destructible(int &))]; } |
| { int arr[T(__is_nothrow_destructible(HasDest))]; } |
| { int arr[F(__is_nothrow_destructible(AllPrivate))]; } |
| { int arr[T(__is_nothrow_destructible(SuperNonTrivialStruct))]; } |
| { int arr[T(__is_nothrow_destructible(AllDefaulted))]; } |
| { int arr[F(__is_nothrow_destructible(AllDeleted))]; } |
| { int arr[F(__is_nothrow_destructible(ThrowingDtor))]; } |
| { int arr[T(__is_nothrow_destructible(NoExceptDtor))]; } |
| { int arr[T(__is_nothrow_destructible(NoThrowDtor))]; } |
| |
| { int arr[T(__is_nothrow_destructible(ACompleteType))]; } |
| { int arr[F(__is_nothrow_destructible(AnIncompleteType))]; } // expected-error {{incomplete type}} |
| { int arr[F(__is_nothrow_destructible(AnIncompleteType[]))]; } |
| { int arr[F(__is_nothrow_destructible(AnIncompleteType[1]))]; } // expected-error {{incomplete type}} |
| { int arr[F(__is_nothrow_destructible(void))]; } |
| { int arr[F(__is_nothrow_destructible(const volatile void))]; } |
| } |
| |
| void is_trivially_destructible_test() { |
| { int arr[T(__is_trivially_destructible(int))]; } |
| { int arr[T(__is_trivially_destructible(int[2]))]; } |
| { int arr[F(__is_trivially_destructible(int[]))]; } |
| { int arr[F(__is_trivially_destructible(void))]; } |
| { int arr[T(__is_trivially_destructible(int &))]; } |
| { int arr[F(__is_trivially_destructible(HasDest))]; } |
| { int arr[F(__is_trivially_destructible(AllPrivate))]; } |
| { int arr[F(__is_trivially_destructible(SuperNonTrivialStruct))]; } |
| { int arr[T(__is_trivially_destructible(AllDefaulted))]; } |
| { int arr[F(__is_trivially_destructible(AllDeleted))]; } |
| { int arr[F(__is_trivially_destructible(ThrowingDtor))]; } |
| { int arr[F(__is_trivially_destructible(NoThrowDtor))]; } |
| |
| { int arr[T(__is_trivially_destructible(ACompleteType))]; } |
| { int arr[F(__is_trivially_destructible(AnIncompleteType))]; } // expected-error {{incomplete type}} |
| { int arr[F(__is_trivially_destructible(AnIncompleteType[]))]; } |
| { int arr[F(__is_trivially_destructible(AnIncompleteType[1]))]; } // expected-error {{incomplete type}} |
| { int arr[F(__is_trivially_destructible(void))]; } |
| { int arr[F(__is_trivially_destructible(const volatile void))]; } |
| } |
| |
| // Instantiation of __has_unique_object_representations |
| template <typename T> |
| struct has_unique_object_representations { |
| static const bool value = __has_unique_object_representations(T); |
| }; |
| |
| static_assert(!has_unique_object_representations<void>::value, "void is never unique"); |
| static_assert(!has_unique_object_representations<const void>::value, "void is never unique"); |
| static_assert(!has_unique_object_representations<volatile void>::value, "void is never unique"); |
| static_assert(!has_unique_object_representations<const volatile void>::value, "void is never unique"); |
| |
| static_assert(has_unique_object_representations<int>::value, "integrals are"); |
| static_assert(has_unique_object_representations<const int>::value, "integrals are"); |
| static_assert(has_unique_object_representations<volatile int>::value, "integrals are"); |
| static_assert(has_unique_object_representations<const volatile int>::value, "integrals are"); |
| |
| static_assert(has_unique_object_representations<void *>::value, "as are pointers"); |
| static_assert(has_unique_object_representations<const void *>::value, "as are pointers"); |
| static_assert(has_unique_object_representations<volatile void *>::value, "are pointers"); |
| static_assert(has_unique_object_representations<const volatile void *>::value, "as are pointers"); |
| |
| static_assert(has_unique_object_representations<int *>::value, "as are pointers"); |
| static_assert(has_unique_object_representations<const int *>::value, "as are pointers"); |
| static_assert(has_unique_object_representations<volatile int *>::value, "as are pointers"); |
| static_assert(has_unique_object_representations<const volatile int *>::value, "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>::value, "even function pointers"); |
| static_assert(has_unique_object_representations<const FP>::value, "even function pointers"); |
| static_assert(has_unique_object_representations<volatile FP>::value, "even function pointers"); |
| static_assert(has_unique_object_representations<const volatile FP>::value, "even function pointers"); |
| |
| static_assert(has_unique_object_representations<PMF>::value, "and pointer to members"); |
| static_assert(has_unique_object_representations<const PMF>::value, "and pointer to members"); |
| static_assert(has_unique_object_representations<volatile PMF>::value, "and pointer to members"); |
| static_assert(has_unique_object_representations<const volatile PMF>::value, "and pointer to members"); |
| |
| static_assert(has_unique_object_representations<PMD>::value, "and pointer to members"); |
| static_assert(has_unique_object_representations<const PMD>::value, "and pointer to members"); |
| static_assert(has_unique_object_representations<volatile PMD>::value, "and pointer to members"); |
| static_assert(has_unique_object_representations<const volatile PMD>::value, "and pointer to members"); |
| |
| static_assert(has_unique_object_representations<bool>::value, "yes, all integral types"); |
| static_assert(has_unique_object_representations<char>::value, "yes, all integral types"); |
| static_assert(has_unique_object_representations<signed char>::value, "yes, all integral types"); |
| static_assert(has_unique_object_representations<unsigned char>::value, "yes, all integral types"); |
| static_assert(has_unique_object_representations<short>::value, "yes, all integral types"); |
| static_assert(has_unique_object_representations<unsigned short>::value, "yes, all integral types"); |
| static_assert(has_unique_object_representations<int>::value, "yes, all integral types"); |
| static_assert(has_unique_object_representations<unsigned int>::value, "yes, all integral types"); |
| static_assert(has_unique_object_representations<long>::value, "yes, all integral types"); |
| static_assert(has_unique_object_representations<unsigned long>::value, "yes, all integral types"); |
| static_assert(has_unique_object_representations<long long>::value, "yes, all integral types"); |
| static_assert(has_unique_object_representations<unsigned long long>::value, "yes, all integral types"); |
| static_assert(has_unique_object_representations<wchar_t>::value, "yes, all integral types"); |
| static_assert(has_unique_object_representations<char16_t>::value, "yes, all integral types"); |
| static_assert(has_unique_object_representations<char32_t>::value, "yes, all integral types"); |
| |
| static_assert(!has_unique_object_representations<void>::value, "but not void!"); |
| static_assert(!has_unique_object_representations<decltype(nullptr)>::value, "or nullptr_t"); |
| static_assert(!has_unique_object_representations<float>::value, "definitely not Floating Point"); |
| static_assert(!has_unique_object_representations<double>::value, "definitely not Floating Point"); |
| static_assert(!has_unique_object_representations<long double>::value, "definitely not Floating Point"); |
| |
| struct NoPadding { |
| int a; |
| int b; |
| }; |
| |
| static_assert(has_unique_object_representations<NoPadding>::value, "types without padding are"); |
| |
| struct InheritsFromNoPadding : NoPadding { |
| int c; |
| int d; |
| }; |
| |
| static_assert(has_unique_object_representations<InheritsFromNoPadding>::value, "types without padding are"); |
| |
| struct VirtuallyInheritsFromNoPadding : virtual NoPadding { |
| int c; |
| int d; |
| }; |
| |
| static_assert(!has_unique_object_representations<VirtuallyInheritsFromNoPadding>::value, "No virtual inheritance"); |
| |
| struct Padding { |
| char a; |
| int b; |
| }; |
| |
| //static_assert(!has_unique_object_representations<Padding>::value, "but not with padding"); |
| |
| struct InheritsFromPadding : Padding { |
| int c; |
| int d; |
| }; |
| |
| static_assert(!has_unique_object_representations<InheritsFromPadding>::value, "or its subclasses"); |
| |
| struct TailPadding { |
| int a; |
| char b; |
| }; |
| |
| static_assert(!has_unique_object_representations<TailPadding>::value, "even at the end"); |
| |
| struct TinyStruct { |
| char a; |
| }; |
| |
| static_assert(has_unique_object_representations<TinyStruct>::value, "Should be no padding"); |
| |
| struct InheritsFromTinyStruct : TinyStruct { |
| int b; |
| }; |
| |
| static_assert(!has_unique_object_representations<InheritsFromTinyStruct>::value, "Inherit causes padding"); |
| |
| union NoPaddingUnion { |
| int a; |
| unsigned int b; |
| }; |
| |
| static_assert(has_unique_object_representations<NoPaddingUnion>::value, "unions follow the same rules as structs"); |
| |
| union PaddingUnion { |
| int a; |
| long long b; |
| }; |
| |
| static_assert(!has_unique_object_representations<PaddingUnion>::value, "unions follow the same rules as structs"); |
| |
| struct NotTriviallyCopyable { |
| int x; |
| NotTriviallyCopyable(const NotTriviallyCopyable &) {} |
| }; |
| |
| static_assert(!has_unique_object_representations<NotTriviallyCopyable>::value, "must be trivially copyable"); |
| |
| struct HasNonUniqueMember { |
| float x; |
| }; |
| |
| static_assert(!has_unique_object_representations<HasNonUniqueMember>::value, "all members must be unique"); |
| |
| enum ExampleEnum { xExample, |
| yExample }; |
| enum LLEnum : long long { xLongExample, |
| yLongExample }; |
| |
| static_assert(has_unique_object_representations<ExampleEnum>::value, "Enums are integrals, so unique!"); |
| static_assert(has_unique_object_representations<LLEnum>::value, "Enums are integrals, so unique!"); |
| |
| enum class ExampleEnumClass { xExample, |
| yExample }; |
| enum class LLEnumClass : long long { xLongExample, |
| yLongExample }; |
| |
| static_assert(has_unique_object_representations<ExampleEnumClass>::value, "Enums are integrals, so unique!"); |
| static_assert(has_unique_object_representations<LLEnumClass>::value, "Enums are integrals, so unique!"); |
| |
| // because references aren't trivially copyable. |
| static_assert(!has_unique_object_representations<int &>::value, "No references!"); |
| static_assert(!has_unique_object_representations<const int &>::value, "No references!"); |
| static_assert(!has_unique_object_representations<volatile int &>::value, "No references!"); |
| static_assert(!has_unique_object_representations<const volatile int &>::value, "No references!"); |
| static_assert(!has_unique_object_representations<Empty>::value, "No empty types!"); |
| static_assert(!has_unique_object_representations<EmptyUnion>::value, "No empty types!"); |
| |
| class Compressed : Empty { |
| int x; |
| }; |
| |
| static_assert(has_unique_object_representations<Compressed>::value, "But inheriting from one is ok"); |
| |
| class EmptyInheritor : Compressed {}; |
| |
| static_assert(has_unique_object_representations<EmptyInheritor>::value, "As long as the base has items, empty is ok"); |
| |
| class Dynamic { |
| virtual void A(); |
| int i; |
| }; |
| |
| static_assert(!has_unique_object_representations<Dynamic>::value, "Dynamic types are not valid"); |
| |
| class InheritsDynamic : Dynamic { |
| int j; |
| }; |
| |
| static_assert(!has_unique_object_representations<InheritsDynamic>::value, "Dynamic types are not valid"); |
| |
| static_assert(has_unique_object_representations<int[42]>::value, "Arrays are fine, as long as their value type is"); |
| static_assert(has_unique_object_representations<int[]>::value, "Arrays are fine, as long as their value type is"); |
| static_assert(has_unique_object_representations<int[][42]>::value, "Arrays are fine, as long as their value type is"); |
| static_assert(!has_unique_object_representations<double[42]>::value, "So no array of doubles!"); |
| static_assert(!has_unique_object_representations<double[]>::value, "So no array of doubles!"); |
| static_assert(!has_unique_object_representations<double[][42]>::value, "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>::value, "Alignment causes padding"); |
| static_assert(!has_unique_object_representations<WeirdAlignmentUnion>::value, "Alignment causes padding"); |
| static_assert(!has_unique_object_representations<WeirdAlignment[42]>::value, "Also no arrays that have padding"); |
| |
| static_assert(!has_unique_object_representations<int(int)>::value, "Functions are not unique"); |
| static_assert(!has_unique_object_representations<int(int) const>::value, "Functions are not unique"); |
| static_assert(!has_unique_object_representations<int(int) volatile>::value, "Functions are not unique"); |
| static_assert(!has_unique_object_representations<int(int) const volatile>::value, "Functions are not unique"); |
| static_assert(!has_unique_object_representations<int(int) &>::value, "Functions are not unique"); |
| static_assert(!has_unique_object_representations<int(int) const &>::value, "Functions are not unique"); |
| static_assert(!has_unique_object_representations<int(int) volatile &>::value, "Functions are not unique"); |
| static_assert(!has_unique_object_representations<int(int) const volatile &>::value, "Functions are not unique"); |
| static_assert(!has_unique_object_representations<int(int) &&>::value, "Functions are not unique"); |
| static_assert(!has_unique_object_representations<int(int) const &&>::value, "Functions are not unique"); |
| static_assert(!has_unique_object_representations<int(int) volatile &&>::value, "Functions are not unique"); |
| static_assert(!has_unique_object_representations<int(int) const volatile &&>::value, "Functions are not unique"); |
| |
| static_assert(!has_unique_object_representations<int(int, ...)>::value, "Functions are not unique"); |
| static_assert(!has_unique_object_representations<int(int, ...) const>::value, "Functions are not unique"); |
| static_assert(!has_unique_object_representations<int(int, ...) volatile>::value, "Functions are not unique"); |
| static_assert(!has_unique_object_representations<int(int, ...) const volatile>::value, "Functions are not unique"); |
| static_assert(!has_unique_object_representations<int(int, ...) &>::value, "Functions are not unique"); |
| static_assert(!has_unique_object_representations<int(int, ...) const &>::value, "Functions are not unique"); |
| static_assert(!has_unique_object_representations<int(int, ...) volatile &>::value, "Functions are not unique"); |
| static_assert(!has_unique_object_representations<int(int, ...) const volatile &>::value, "Functions are not unique"); |
| static_assert(!has_unique_object_representations<int(int, ...) &&>::value, "Functions are not unique"); |
| static_assert(!has_unique_object_representations<int(int, ...) const &&>::value, "Functions are not unique"); |
| static_assert(!has_unique_object_representations<int(int, ...) volatile &&>::value, "Functions are not unique"); |
| static_assert(!has_unique_object_representations<int(int, ...) const volatile &&>::value, "Functions are not unique"); |
| |
| void foo(){ |
| static auto lambda = []() {}; |
| static_assert(!has_unique_object_representations<decltype(lambda)>::value, "Lambdas follow struct rules"); |
| int i; |
| static auto lambda2 = [i]() {}; |
| static_assert(has_unique_object_representations<decltype(lambda2)>::value, "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; |
| }; |
| |
| static_assert(!has_unique_object_representations<PaddedBitfield>::value, "Bitfield padding"); |
| static_assert(has_unique_object_representations<UnPaddedBitfield>::value, "Bitfield padding"); |
| static_assert(!has_unique_object_representations<AlignedPaddedBitfield>::value, "Bitfield padding"); |
| |
| struct BoolBitfield { |
| bool b : 8; |
| }; |
| |
| static_assert(has_unique_object_representations<BoolBitfield>::value, "Bitfield bool"); |
| |
| struct BoolBitfield2 { |
| bool b : 16; |
| }; |
| |
| static_assert(!has_unique_object_representations<BoolBitfield2>::value, "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>::value, "Bitfield padding"); |
| |
| struct StructWithRef { |
| int &I; |
| }; |
| |
| static_assert(has_unique_object_representations<StructWithRef>::value, "References are still unique"); |
| |
| struct NotUniqueBecauseTailPadding { |
| int &r; |
| char a; |
| }; |
| struct CanBeUniqueIfNoPadding : NotUniqueBecauseTailPadding { |
| char b[7]; |
| }; |
| |
| static_assert(!has_unique_object_representations<NotUniqueBecauseTailPadding>::value, |
| "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>::value, |
| "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 'ErrorType::S'}} |
| }; |
| bool b = __has_unique_object_representations(T); |
| }; |