diff options
Diffstat (limited to 'test/SemaCXX/type-traits.cpp')
| -rw-r--r-- | test/SemaCXX/type-traits.cpp | 149 |
1 files changed, 145 insertions, 4 deletions
diff --git a/test/SemaCXX/type-traits.cpp b/test/SemaCXX/type-traits.cpp index 1a2e329..340c0ae 100644 --- a/test/SemaCXX/type-traits.cpp +++ b/test/SemaCXX/type-traits.cpp @@ -7,14 +7,23 @@ struct NonPOD { NonPOD(int); }; // PODs enum Enum { EV }; struct POD { Enum e; int i; float f; NonPOD* p; }; +struct Empty {}; +typedef Empty EmptyAr[10]; typedef int Int; typedef Int IntAr[10]; class Statics { static int priv; static NonPOD np; }; +union EmptyUnion {}; +union Union { int i; float f; }; +struct HasFunc { void f (); }; +struct HasOp { void operator *(); }; +struct HasConv { operator int(); }; +struct HasAssign { void operator =(int); }; // Not PODs struct Derives : POD {}; +struct DerivesEmpty : Empty {}; struct HasCons { HasCons(int); }; -struct HasAssign { HasAssign operator =(const HasAssign&); }; +struct HasCopyAssign { HasCopyAssign operator =(const HasCopyAssign&); }; struct HasDest { ~HasDest(); }; class HasPriv { int priv; }; class HasProt { protected: int prot; }; @@ -22,6 +31,8 @@ struct HasRef { int i; int& ref; HasRef() : i(0), ref(i) {} }; struct HasNonPOD { NonPOD np; }; struct HasVirt { virtual void Virt() {}; }; typedef Derives NonPODAr[10]; +typedef HasVirt VirtAr[10]; +union NonPODUnion { int i; Derives n; }; void is_pod() { @@ -31,10 +42,17 @@ void is_pod() int t04[T(__is_pod(Int))]; int t05[T(__is_pod(IntAr))]; int t06[T(__is_pod(Statics))]; + int t07[T(__is_pod(Empty))]; + int t08[T(__is_pod(EmptyUnion))]; + int t09[T(__is_pod(Union))]; + int t10[T(__is_pod(HasFunc))]; + int t11[T(__is_pod(HasOp))]; + int t12[T(__is_pod(HasConv))]; + int t13[T(__is_pod(HasAssign))]; int t21[F(__is_pod(Derives))]; int t22[F(__is_pod(HasCons))]; - int t23[F(__is_pod(HasAssign))]; + int t23[F(__is_pod(HasCopyAssign))]; int t24[F(__is_pod(HasDest))]; int t25[F(__is_pod(HasPriv))]; int t26[F(__is_pod(HasProt))]; @@ -42,9 +60,40 @@ void is_pod() int t28[F(__is_pod(HasNonPOD))]; int t29[F(__is_pod(HasVirt))]; int t30[F(__is_pod(NonPODAr))]; + int t31[F(__is_pod(DerivesEmpty))]; + // int t32[F(__is_pod(NonPODUnion))]; +} + +typedef Empty EmptyAr[10]; +struct Bit0 { int : 0; }; +struct Bit0Cons { int : 0; Bit0Cons(); }; +struct BitOnly { int x : 3; }; +//struct DerivesVirt : virtual POD {}; + +void is_empty() +{ + int t01[T(__is_empty(Empty))]; + int t02[T(__is_empty(DerivesEmpty))]; + int t03[T(__is_empty(HasCons))]; + int t04[T(__is_empty(HasCopyAssign))]; + int t05[T(__is_empty(HasDest))]; + int t06[T(__is_empty(HasFunc))]; + int t07[T(__is_empty(HasOp))]; + int t08[T(__is_empty(HasConv))]; + int t09[T(__is_empty(HasAssign))]; + int t10[T(__is_empty(Bit0))]; + int t11[T(__is_empty(Bit0Cons))]; + + int t21[F(__is_empty(Int))]; + int t22[F(__is_empty(POD))]; + int t23[F(__is_empty(EmptyUnion))]; + int t24[F(__is_empty(EmptyAr))]; + int t25[F(__is_empty(HasRef))]; + int t26[F(__is_empty(HasVirt))]; + int t27[F(__is_empty(BitOnly))]; +// int t27[F(__is_empty(DerivesVirt))]; } -union Union { int i; float f; }; typedef Derives ClassType; void is_class() @@ -92,7 +141,7 @@ void is_enum() int t17[F(__is_enum(ClassType))]; } -struct Polymorph { virtual void f(); }; +typedef HasVirt Polymorph; struct InheritPolymorph : Polymorph {}; void is_polymorphic() @@ -109,3 +158,95 @@ void is_polymorphic() int t17[F(__is_polymorphic(ClassType))]; int t18[F(__is_polymorphic(Enum))]; } + +typedef Int& IntRef; +typedef const IntAr ConstIntAr; +typedef ConstIntAr ConstIntArAr[4]; + +struct HasCopy { + HasCopy(HasCopy& cp); +}; + +void has_trivial_default_constructor() { + int t01[T(__has_trivial_constructor(Int))]; + int t02[T(__has_trivial_constructor(IntAr))]; + int t03[T(__has_trivial_constructor(Union))]; + int t04[T(__has_trivial_constructor(UnionAr))]; + int t05[T(__has_trivial_constructor(POD))]; + int t06[T(__has_trivial_constructor(Derives))]; + int t07[T(__has_trivial_constructor(ConstIntAr))]; + int t08[T(__has_trivial_constructor(ConstIntArAr))]; + int t09[T(__has_trivial_constructor(HasDest))]; + int t10[T(__has_trivial_constructor(HasPriv))]; + int t11[F(__has_trivial_constructor(HasCons))]; + int t12[F(__has_trivial_constructor(HasRef))]; + int t13[F(__has_trivial_constructor(HasCopy))]; + int t14[F(__has_trivial_constructor(IntRef))]; + int t15[T(__has_trivial_constructor(HasCopyAssign))]; + int t16[T(__has_trivial_constructor(const Int))]; + int t17[T(__has_trivial_constructor(NonPODAr))]; + int t18[F(__has_trivial_constructor(VirtAr))]; +} + +void has_trivial_copy_constructor() { + int t01[T(__has_trivial_copy(Int))]; + int t02[T(__has_trivial_copy(IntAr))]; + int t03[T(__has_trivial_copy(Union))]; + int t04[T(__has_trivial_copy(UnionAr))]; + int t05[T(__has_trivial_copy(POD))]; + int t06[T(__has_trivial_copy(Derives))]; + int t07[T(__has_trivial_copy(ConstIntAr))]; + int t08[T(__has_trivial_copy(ConstIntArAr))]; + int t09[T(__has_trivial_copy(HasDest))]; + int t10[T(__has_trivial_copy(HasPriv))]; + int t11[T(__has_trivial_copy(HasCons))]; + int t12[T(__has_trivial_copy(HasRef))]; + int t13[F(__has_trivial_copy(HasCopy))]; + int t14[T(__has_trivial_copy(IntRef))]; + int t15[T(__has_trivial_copy(HasCopyAssign))]; + int t16[T(__has_trivial_copy(const Int))]; + int t17[F(__has_trivial_copy(NonPODAr))]; + int t18[F(__has_trivial_copy(VirtAr))]; +} + +void has_trivial_copy_assignment() { + int t01[T(__has_trivial_assign(Int))]; + int t02[T(__has_trivial_assign(IntAr))]; + int t03[T(__has_trivial_assign(Union))]; + int t04[T(__has_trivial_assign(UnionAr))]; + int t05[T(__has_trivial_assign(POD))]; + int t06[T(__has_trivial_assign(Derives))]; + int t07[F(__has_trivial_assign(ConstIntAr))]; + int t08[F(__has_trivial_assign(ConstIntArAr))]; + int t09[T(__has_trivial_assign(HasDest))]; + int t10[T(__has_trivial_assign(HasPriv))]; + int t11[T(__has_trivial_assign(HasCons))]; + int t12[T(__has_trivial_assign(HasRef))]; + int t13[T(__has_trivial_assign(HasCopy))]; + int t14[F(__has_trivial_assign(IntRef))]; + int t15[F(__has_trivial_assign(HasCopyAssign))]; + int t16[F(__has_trivial_assign(const Int))]; + int t17[F(__has_trivial_assign(NonPODAr))]; + int t18[F(__has_trivial_assign(VirtAr))]; +} + +void has_trivial_destructor() { + int t01[T(__has_trivial_destructor(Int))]; + int t02[T(__has_trivial_destructor(IntAr))]; + int t03[T(__has_trivial_destructor(Union))]; + int t04[T(__has_trivial_destructor(UnionAr))]; + int t05[T(__has_trivial_destructor(POD))]; + int t06[T(__has_trivial_destructor(Derives))]; + int t07[T(__has_trivial_destructor(ConstIntAr))]; + int t08[T(__has_trivial_destructor(ConstIntArAr))]; + int t09[F(__has_trivial_destructor(HasDest))]; + int t10[T(__has_trivial_destructor(HasPriv))]; + int t11[T(__has_trivial_destructor(HasCons))]; + int t12[T(__has_trivial_destructor(HasRef))]; + int t13[T(__has_trivial_destructor(HasCopy))]; + int t14[T(__has_trivial_destructor(IntRef))]; + int t15[T(__has_trivial_destructor(HasCopyAssign))]; + int t16[T(__has_trivial_destructor(const Int))]; + int t17[T(__has_trivial_destructor(NonPODAr))]; + int t18[T(__has_trivial_destructor(VirtAr))]; +} |
