[cfe-commits] r130072 - /cfe/trunk/test/SemaCXX/type-traits.cpp
Chandler Carruth
chandlerc at gmail.com
Sat Apr 23 13:51:37 PDT 2011
Author: chandlerc
Date: Sat Apr 23 15:51:37 2011
New Revision: 130072
URL: http://llvm.org/viewvc/llvm-project?rev=130072&view=rev
Log:
Mechanical change moving all of the test statements away from a pattern
that requires needless noise in every patch (due to numbers changing) or
poorly grouped test cases in order to have strictly increasing numbers.
This will make my subsequent patches much less ugly. =D
Modified:
cfe/trunk/test/SemaCXX/type-traits.cpp
Modified: cfe/trunk/test/SemaCXX/type-traits.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/SemaCXX/type-traits.cpp?rev=130072&r1=130071&r2=130072&view=diff
==============================================================================
--- cfe/trunk/test/SemaCXX/type-traits.cpp (original)
+++ cfe/trunk/test/SemaCXX/type-traits.cpp Sat Apr 23 15:51:37 2011
@@ -77,37 +77,37 @@
void is_pod()
{
- int t01[T(__is_pod(int))];
- int t02[T(__is_pod(Enum))];
- int t03[T(__is_pod(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 t14[T(__is_pod(IntArNB))];
- int t15[T(__is_pod(HasAnonymousUnion))];
-
- int t21[F(__is_pod(Derives))];
- int t22[F(__is_pod(HasCons))];
- int t23[F(__is_pod(HasCopyAssign))];
- int t24[F(__is_pod(HasDest))];
- int t25[F(__is_pod(HasPriv))];
- int t26[F(__is_pod(HasProt))];
- int t27[F(__is_pod(HasRef))];
- 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(void))];
- int t33[F(__is_pod(cvoid))];
- int t34[F(__is_pod(NonPODArNB))];
- // int t32[F(__is_pod(NonPODUnion))];
+ { 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[F(__is_pod(Derives))]; }
+ { int arr[F(__is_pod(HasCons))]; }
+ { int arr[F(__is_pod(HasCopyAssign))]; }
+ { int arr[F(__is_pod(HasDest))]; }
+ { int arr[F(__is_pod(HasPriv))]; }
+ { int arr[F(__is_pod(HasProt))]; }
+ { int arr[F(__is_pod(HasRef))]; }
+ { int arr[F(__is_pod(HasNonPOD))]; }
+ { int arr[F(__is_pod(HasVirt))]; }
+ { int arr[F(__is_pod(NonPODAr))]; }
+ { int arr[F(__is_pod(DerivesEmpty))]; }
+ { int arr[F(__is_pod(void))]; }
+ { int arr[F(__is_pod(cvoid))]; }
+ { int arr[F(__is_pod(NonPODArNB))]; }
+// { int arr[F(__is_pod(NonPODUnion))]; }
}
typedef Empty EmptyAr[10];
@@ -118,48 +118,48 @@
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 t28[F(__is_empty(void))];
- int t29[F(__is_empty(IntArNB))];
- int t30[F(__is_empty(HasAnonymousUnion))];
-// int t27[F(__is_empty(DerivesVirt))];
+ { 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(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(EmptyAr))]; }
+ { int arr[F(__is_empty(HasRef))]; }
+ { int arr[F(__is_empty(HasVirt))]; }
+ { 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))]; }
}
typedef Derives ClassType;
void is_class()
{
- int t01[T(__is_class(Derives))];
- int t02[T(__is_class(HasPriv))];
- int t03[T(__is_class(ClassType))];
- int t04[T(__is_class(HasAnonymousUnion))];
-
- int t11[F(__is_class(int))];
- int t12[F(__is_class(Enum))];
- int t13[F(__is_class(Int))];
- int t14[F(__is_class(IntAr))];
- int t15[F(__is_class(NonPODAr))];
- int t16[F(__is_class(Union))];
- int t17[F(__is_class(cvoid))];
- int t18[F(__is_class(IntArNB))];
+ { 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(NonPODAr))]; }
+ { int arr[F(__is_class(Union))]; }
+ { int arr[F(__is_class(cvoid))]; }
+ { int arr[F(__is_class(IntArNB))]; }
}
typedef Union UnionAr[10];
@@ -167,36 +167,36 @@
void is_union()
{
- int t01[T(__is_union(Union))];
- int t02[T(__is_union(UnionType))];
+ { int arr[T(__is_union(Union))]; }
+ { int arr[T(__is_union(UnionType))]; }
- int t11[F(__is_union(int))];
- int t12[F(__is_union(Enum))];
- int t13[F(__is_union(Int))];
- int t14[F(__is_union(IntAr))];
- int t15[F(__is_union(UnionAr))];
- int t16[F(__is_union(cvoid))];
- int t17[F(__is_union(IntArNB))];
- int t18[F(__is_union(HasAnonymousUnion))];
+ { 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 t01[T(__is_enum(Enum))];
- int t02[T(__is_enum(EnumType))];
+ { int arr[T(__is_enum(Enum))]; }
+ { int arr[T(__is_enum(EnumType))]; }
- int t11[F(__is_enum(int))];
- int t12[F(__is_enum(Union))];
- int t13[F(__is_enum(Int))];
- int t14[F(__is_enum(IntAr))];
- int t15[F(__is_enum(UnionAr))];
- int t16[F(__is_enum(Derives))];
- int t17[F(__is_enum(ClassType))];
- int t18[F(__is_enum(cvoid))];
- int t19[F(__is_enum(IntArNB))];
- int t20[F(__is_enum(HasAnonymousUnion))];
+ { 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))]; }
}
typedef HasVirt Polymorph;
@@ -204,19 +204,19 @@
void is_polymorphic()
{
- int t01[T(__is_polymorphic(Polymorph))];
- int t02[T(__is_polymorphic(InheritPolymorph))];
+ { int arr[T(__is_polymorphic(Polymorph))]; }
+ { int arr[T(__is_polymorphic(InheritPolymorph))]; }
- int t11[F(__is_polymorphic(int))];
- int t12[F(__is_polymorphic(Union))];
- int t13[F(__is_polymorphic(Int))];
- int t14[F(__is_polymorphic(IntAr))];
- int t15[F(__is_polymorphic(UnionAr))];
- int t16[F(__is_polymorphic(Derives))];
- int t17[F(__is_polymorphic(ClassType))];
- int t18[F(__is_polymorphic(Enum))];
- int t19[F(__is_polymorphic(cvoid))];
- int t20[F(__is_polymorphic(IntArNB))];
+ { int arr[F(__is_polymorphic(int))]; }
+ { int arr[F(__is_polymorphic(Union))]; }
+ { 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))]; }
}
typedef Int& IntRef;
@@ -235,216 +235,216 @@
};
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))];
- int t19[F(__has_trivial_constructor(void))];
- int t20[F(__has_trivial_constructor(cvoid))];
- int t21[F(__has_trivial_constructor(HasTemplateCons))];
+ { 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(ConstIntAr))]; }
+ { int arr[T(__has_trivial_constructor(ConstIntArAr))]; }
+ { int arr[T(__has_trivial_constructor(HasDest))]; }
+ { int arr[T(__has_trivial_constructor(HasPriv))]; }
+ { 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[T(__has_trivial_constructor(HasCopyAssign))]; }
+ { int arr[T(__has_trivial_constructor(const Int))]; }
+ { int arr[T(__has_trivial_constructor(NonPODAr))]; }
+ { 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))]; }
}
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))];
- int t19[F(__has_trivial_copy(void))];
- int t20[F(__has_trivial_copy(cvoid))];
- int t21[F(__has_trivial_copy(HasTemplateCons))];
+ { 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[F(__has_trivial_copy(HasCopy))]; }
+ { int arr[T(__has_trivial_copy(IntRef))]; }
+ { int arr[T(__has_trivial_copy(HasCopyAssign))]; }
+ { int arr[T(__has_trivial_copy(const Int))]; }
+ { int arr[F(__has_trivial_copy(NonPODAr))]; }
+ { 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(HasTemplateCons))]; }
}
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))];
- int t19[F(__has_trivial_assign(void))];
- int t20[F(__has_trivial_assign(cvoid))];
+ { 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[F(__has_trivial_assign(ConstIntAr))]; }
+ { int arr[F(__has_trivial_assign(ConstIntArAr))]; }
+ { 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[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(NonPODAr))]; }
+ { int arr[F(__has_trivial_assign(VirtAr))]; }
+ { int arr[F(__has_trivial_assign(void))]; }
+ { int arr[F(__has_trivial_assign(cvoid))]; }
}
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))];
- int t19[F(__has_trivial_destructor(void))];
- int t20[F(__has_trivial_destructor(cvoid))];
+ { 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[F(__has_trivial_destructor(HasDest))]; }
+ { 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(IntRef))]; }
+ { int arr[T(__has_trivial_destructor(HasCopyAssign))]; }
+ { int arr[T(__has_trivial_destructor(const Int))]; }
+ { int arr[T(__has_trivial_destructor(NonPODAr))]; }
+ { int arr[T(__has_trivial_destructor(VirtAr))]; }
+ { int arr[F(__has_trivial_destructor(void))]; }
+ { int arr[F(__has_trivial_destructor(cvoid))]; }
}
struct A { ~A() {} };
template<typename> struct B : A { };
void f() {
- int t01[F(__has_trivial_destructor(A))];
- int t02[F(__has_trivial_destructor(B<int>))];
+ { int arr[F(__has_trivial_destructor(A))]; }
+ { int arr[F(__has_trivial_destructor(B<int>))]; }
}
void has_nothrow_assign() {
- int t01[T(__has_nothrow_assign(Int))];
- int t02[T(__has_nothrow_assign(IntAr))];
- int t03[T(__has_nothrow_assign(Union))];
- int t04[T(__has_nothrow_assign(UnionAr))];
- int t05[T(__has_nothrow_assign(POD))];
- int t06[T(__has_nothrow_assign(Derives))];
- int t07[F(__has_nothrow_assign(ConstIntAr))];
- int t08[F(__has_nothrow_assign(ConstIntArAr))];
- int t09[T(__has_nothrow_assign(HasDest))];
- int t10[T(__has_nothrow_assign(HasPriv))];
- int t11[T(__has_nothrow_assign(HasCons))];
- int t12[T(__has_nothrow_assign(HasRef))];
- int t13[T(__has_nothrow_assign(HasCopy))];
- int t14[F(__has_nothrow_assign(IntRef))];
- int t15[F(__has_nothrow_assign(HasCopyAssign))];
- int t16[F(__has_nothrow_assign(const Int))];
- int t17[F(__has_nothrow_assign(NonPODAr))];
- int t18[F(__has_nothrow_assign(VirtAr))];
- int t19[T(__has_nothrow_assign(HasNoThrowCopyAssign))];
- int t20[F(__has_nothrow_assign(HasMultipleCopyAssign))];
- int t21[T(__has_nothrow_assign(HasMultipleNoThrowCopyAssign))];
- int t22[F(__has_nothrow_assign(void))];
- int t23[F(__has_nothrow_assign(cvoid))];
- int t24[T(__has_nothrow_assign(HasVirtDest))];
+ { 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[F(__has_nothrow_assign(ConstIntAr))]; }
+ { int arr[F(__has_nothrow_assign(ConstIntArAr))]; }
+ { 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[F(__has_nothrow_assign(IntRef))]; }
+ { int arr[F(__has_nothrow_assign(HasCopyAssign))]; }
+ { int arr[F(__has_nothrow_assign(const Int))]; }
+ { int arr[F(__has_nothrow_assign(NonPODAr))]; }
+ { int arr[F(__has_nothrow_assign(VirtAr))]; }
+ { int arr[T(__has_nothrow_assign(HasNoThrowCopyAssign))]; }
+ { int arr[F(__has_nothrow_assign(HasMultipleCopyAssign))]; }
+ { int arr[T(__has_nothrow_assign(HasMultipleNoThrowCopyAssign))]; }
+ { int arr[F(__has_nothrow_assign(void))]; }
+ { int arr[F(__has_nothrow_assign(cvoid))]; }
+ { int arr[T(__has_nothrow_assign(HasVirtDest))]; }
}
void has_nothrow_copy() {
- int t01[T(__has_nothrow_copy(Int))];
- int t02[T(__has_nothrow_copy(IntAr))];
- int t03[T(__has_nothrow_copy(Union))];
- int t04[T(__has_nothrow_copy(UnionAr))];
- int t05[T(__has_nothrow_copy(POD))];
- int t06[T(__has_nothrow_copy(Derives))];
- int t07[T(__has_nothrow_copy(ConstIntAr))];
- int t08[T(__has_nothrow_copy(ConstIntArAr))];
- int t09[T(__has_nothrow_copy(HasDest))];
- int t10[T(__has_nothrow_copy(HasPriv))];
- int t11[T(__has_nothrow_copy(HasCons))];
- int t12[T(__has_nothrow_copy(HasRef))];
- int t13[F(__has_nothrow_copy(HasCopy))];
- int t14[T(__has_nothrow_copy(IntRef))];
- int t15[T(__has_nothrow_copy(HasCopyAssign))];
- int t16[T(__has_nothrow_copy(const Int))];
- int t17[F(__has_nothrow_copy(NonPODAr))];
- int t18[F(__has_nothrow_copy(VirtAr))];
-
- int t19[T(__has_nothrow_copy(HasNoThrowCopy))];
- int t20[F(__has_nothrow_copy(HasMultipleCopy))];
- int t21[T(__has_nothrow_copy(HasMultipleNoThrowCopy))];
- int t22[F(__has_nothrow_copy(void))];
- int t23[F(__has_nothrow_copy(cvoid))];
- int t24[T(__has_nothrow_copy(HasVirtDest))];
- int t25[T(__has_nothrow_copy(HasTemplateCons))];
+ { 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(Derives))]; }
+ { int arr[T(__has_nothrow_copy(ConstIntAr))]; }
+ { int arr[T(__has_nothrow_copy(ConstIntArAr))]; }
+ { 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[F(__has_nothrow_copy(HasCopy))]; }
+ { int arr[T(__has_nothrow_copy(IntRef))]; }
+ { int arr[T(__has_nothrow_copy(HasCopyAssign))]; }
+ { int arr[T(__has_nothrow_copy(const Int))]; }
+ { int arr[F(__has_nothrow_copy(NonPODAr))]; }
+ { int arr[F(__has_nothrow_copy(VirtAr))]; }
+
+ { int arr[T(__has_nothrow_copy(HasNoThrowCopy))]; }
+ { int arr[F(__has_nothrow_copy(HasMultipleCopy))]; }
+ { int arr[T(__has_nothrow_copy(HasMultipleNoThrowCopy))]; }
+ { int arr[F(__has_nothrow_copy(void))]; }
+ { int arr[F(__has_nothrow_copy(cvoid))]; }
+ { int arr[T(__has_nothrow_copy(HasVirtDest))]; }
+ { int arr[T(__has_nothrow_copy(HasTemplateCons))]; }
}
void has_nothrow_constructor() {
- int t01[T(__has_nothrow_constructor(Int))];
- int t02[T(__has_nothrow_constructor(IntAr))];
- int t03[T(__has_nothrow_constructor(Union))];
- int t04[T(__has_nothrow_constructor(UnionAr))];
- int t05[T(__has_nothrow_constructor(POD))];
- int t06[T(__has_nothrow_constructor(Derives))];
- int t07[T(__has_nothrow_constructor(ConstIntAr))];
- int t08[T(__has_nothrow_constructor(ConstIntArAr))];
- int t09[T(__has_nothrow_constructor(HasDest))];
- int t10[T(__has_nothrow_constructor(HasPriv))];
- int t11[F(__has_nothrow_constructor(HasCons))];
- int t12[F(__has_nothrow_constructor(HasRef))];
- int t13[F(__has_nothrow_constructor(HasCopy))];
- int t14[F(__has_nothrow_constructor(IntRef))];
- int t15[T(__has_nothrow_constructor(HasCopyAssign))];
- int t16[T(__has_nothrow_constructor(const Int))];
- int t17[T(__has_nothrow_constructor(NonPODAr))];
- // int t18[T(__has_nothrow_constructor(VirtAr))]; // not implemented
-
- int t19[T(__has_nothrow_constructor(HasNoThrowConstructor))];
- int t20[F(__has_nothrow_constructor(HasNoThrowConstructorWithArgs))];
- int t21[F(__has_nothrow_constructor(void))];
- int t22[F(__has_nothrow_constructor(cvoid))];
- int t23[T(__has_nothrow_constructor(HasVirtDest))];
- int t24[F(__has_nothrow_constructor(HasTemplateCons))];
+ { 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(ConstIntAr))]; }
+ { int arr[T(__has_nothrow_constructor(ConstIntArAr))]; }
+ { int arr[T(__has_nothrow_constructor(HasDest))]; }
+ { int arr[T(__has_nothrow_constructor(HasPriv))]; }
+ { 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(IntRef))]; }
+ { int arr[T(__has_nothrow_constructor(HasCopyAssign))]; }
+ { int arr[T(__has_nothrow_constructor(const Int))]; }
+ { int arr[T(__has_nothrow_constructor(NonPODAr))]; }
+ // { int arr[T(__has_nothrow_constructor(VirtAr))]; } // not implemented
+
+ { int arr[T(__has_nothrow_constructor(HasNoThrowConstructor))]; }
+ { int arr[F(__has_nothrow_constructor(HasNoThrowConstructorWithArgs))]; }
+ { int arr[F(__has_nothrow_constructor(void))]; }
+ { int arr[F(__has_nothrow_constructor(cvoid))]; }
+ { int arr[T(__has_nothrow_constructor(HasVirtDest))]; }
+ { int arr[F(__has_nothrow_constructor(HasTemplateCons))]; }
}
void has_virtual_destructor() {
- int t01[F(__has_virtual_destructor(Int))];
- int t02[F(__has_virtual_destructor(IntAr))];
- int t03[F(__has_virtual_destructor(Union))];
- int t04[F(__has_virtual_destructor(UnionAr))];
- int t05[F(__has_virtual_destructor(POD))];
- int t06[F(__has_virtual_destructor(Derives))];
- int t07[F(__has_virtual_destructor(ConstIntAr))];
- int t08[F(__has_virtual_destructor(ConstIntArAr))];
- int t09[F(__has_virtual_destructor(HasDest))];
- int t10[F(__has_virtual_destructor(HasPriv))];
- int t11[F(__has_virtual_destructor(HasCons))];
- int t12[F(__has_virtual_destructor(HasRef))];
- int t13[F(__has_virtual_destructor(HasCopy))];
- int t14[F(__has_virtual_destructor(IntRef))];
- int t15[F(__has_virtual_destructor(HasCopyAssign))];
- int t16[F(__has_virtual_destructor(const Int))];
- int t17[F(__has_virtual_destructor(NonPODAr))];
- int t18[F(__has_virtual_destructor(VirtAr))];
-
- int t19[T(__has_virtual_destructor(HasVirtDest))];
- int t20[T(__has_virtual_destructor(DerivedVirtDest))];
- int t21[F(__has_virtual_destructor(VirtDestAr))];
- int t22[F(__has_virtual_destructor(void))];
- int t23[F(__has_virtual_destructor(cvoid))];
+ { 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(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(IntRef))]; }
+ { int arr[F(__has_virtual_destructor(HasCopyAssign))]; }
+ { int arr[F(__has_virtual_destructor(const Int))]; }
+ { int arr[F(__has_virtual_destructor(NonPODAr))]; }
+ { int arr[F(__has_virtual_destructor(VirtAr))]; }
+
+ { 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))]; }
}
@@ -474,29 +474,29 @@
template <class T> class UndefinedTemp; // expected-note {{declared here}}
void is_base_of() {
- int t01[T(__is_base_of(Base, Derived))];
- int t02[T(__is_base_of(const Base, Derived))];
- int t03[F(__is_base_of(Derived, Base))];
- int t04[F(__is_base_of(Derived, int))];
- int t05[T(__is_base_of(Base, Base))];
- int t06[T(__is_base_of(Base, Derived3))];
- int t07[T(__is_base_of(Derived, Derived3))];
- int t08[T(__is_base_of(Derived2b, Derived3))];
- int t09[T(__is_base_of(Derived2a, Derived3))];
- int t10[T(__is_base_of(BaseA<int>, DerivedB<int>))];
- int t11[F(__is_base_of(DerivedB<int>, BaseA<int>))];
- int t12[T(__is_base_of(Base, CrazyDerived<Base>))];
- int t13[F(__is_base_of(Union, Union))];
- int t14[T(__is_base_of(Empty, Empty))];
- int t15[T(__is_base_of(class_forward, class_forward))];
- int t16[F(__is_base_of(Empty, class_forward))]; // expected-error {{incomplete type 'class_forward' used in type trait expression}}
- int t17[F(__is_base_of(Base&, Derived&))];
+ { 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 t19[F(__is_base_of(int, int))];
- int t20[F(__is_base_of(long, int))];
- int t21[T(__is_base_of(Base, DerivedTemp<int>))];
- int t22[F(__is_base_of(Base, NonderivedTemp<int>))];
- int t23[F(__is_base_of(Base, UndefinedTemp<int>))]; // expected-error {{implicit instantiation of undefined template 'UndefinedTemp<int>'}}
+ { 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>();
@@ -524,61 +524,61 @@
};
void is_convertible_to() {
- int t01[T(__is_convertible_to(Int, Int))];
- int t02[F(__is_convertible_to(Int, IntAr))];
- int t03[F(__is_convertible_to(IntAr, IntAr))];
- int t04[T(__is_convertible_to(void, void))];
- int t05[T(__is_convertible_to(cvoid, void))];
- int t06[T(__is_convertible_to(void, cvoid))];
- int t07[T(__is_convertible_to(cvoid, cvoid))];
- int t08[T(__is_convertible_to(int, FromInt))];
- int t09[T(__is_convertible_to(long, FromInt))];
- int t10[T(__is_convertible_to(double, FromInt))];
- int t11[T(__is_convertible_to(const int, FromInt))];
- int t12[T(__is_convertible_to(const int&, FromInt))];
- int t13[T(__is_convertible_to(ToInt, int))];
- int t14[T(__is_convertible_to(ToInt, const int&))];
- int t15[T(__is_convertible_to(ToInt, long))];
- int t16[F(__is_convertible_to(ToInt, int&))];
- int t17[F(__is_convertible_to(ToInt, FromInt))];
- int t18[T(__is_convertible_to(IntAr&, IntAr&))];
- int t19[T(__is_convertible_to(IntAr&, const IntAr&))];
- int t20[F(__is_convertible_to(const IntAr&, IntAr&))];
- int t21[F(__is_convertible_to(Function, Function))];
- int t22[F(__is_convertible_to(PrivateCopy, PrivateCopy))];
- int t23[T(__is_convertible_to(X0<int>, X0<float>))];
+ { 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>))]; }
}
void is_trivial()
{
- int t01[T(__is_trivial(int))];
- int t02[T(__is_trivial(Enum))];
- int t03[T(__is_trivial(POD))];
- int t04[T(__is_trivial(Int))];
- int t05[T(__is_trivial(IntAr))];
- int t06[T(__is_trivial(Statics))];
- int t07[T(__is_trivial(Empty))];
- int t08[T(__is_trivial(EmptyUnion))];
- int t09[T(__is_trivial(Union))];
- int t10[T(__is_trivial(HasFunc))];
- int t11[T(__is_trivial(HasOp))];
- int t12[T(__is_trivial(HasConv))];
- int t13[T(__is_trivial(HasAssign))];
- int t15[T(__is_trivial(HasAnonymousUnion))];
- int t16[T(__is_trivial(Derives))];
- int t17[T(__is_trivial(DerivesEmpty))];
- int t18[T(__is_trivial(NonPODAr))];
- int t19[T(__is_trivial(HasPriv))];
- int t20[T(__is_trivial(HasProt))];
-
- int f01[F(__is_trivial(IntArNB))];
- int f02[F(__is_trivial(HasCons))];
- int f03[F(__is_trivial(HasCopyAssign))];
- int f04[F(__is_trivial(HasDest))];
- int f05[F(__is_trivial(HasRef))];
- int f06[F(__is_trivial(HasNonPOD))];
- int f07[F(__is_trivial(HasVirt))];
- int f08[F(__is_trivial(void))];
- int f09[F(__is_trivial(cvoid))];
- int f10[F(__is_trivial(NonPODArNB))];
+ { 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(Statics))]; }
+ { int arr[T(__is_trivial(Empty))]; }
+ { int arr[T(__is_trivial(EmptyUnion))]; }
+ { int arr[T(__is_trivial(Union))]; }
+ { 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(Derives))]; }
+ { int arr[T(__is_trivial(DerivesEmpty))]; }
+ { int arr[T(__is_trivial(NonPODAr))]; }
+ { int arr[T(__is_trivial(HasPriv))]; }
+ { int arr[T(__is_trivial(HasProt))]; }
+
+ { int arr[F(__is_trivial(IntArNB))]; }
+ { int arr[F(__is_trivial(HasCons))]; }
+ { int arr[F(__is_trivial(HasCopyAssign))]; }
+ { 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(void))]; }
+ { int arr[F(__is_trivial(cvoid))]; }
+ { int arr[F(__is_trivial(NonPODArNB))]; }
}
More information about the cfe-commits
mailing list