forked from OSchip/llvm-project
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 llvm-svn: 130072
This commit is contained in:
Chandler Carruth
parent
7ffce73fc8
commit
21c6a044ec
|
|
@ -77,37 +77,37 @@ typedef HasVirtDest VirtDestAr[1];
|
||||||
|
|
||||||
void is_pod()
|
void is_pod()
|
||||||
{
|
{
|
||||||
int t01[T(__is_pod(int))];
|
{ int arr[T(__is_pod(int))]; }
|
||||||
int t02[T(__is_pod(Enum))];
|
{ int arr[T(__is_pod(Enum))]; }
|
||||||
int t03[T(__is_pod(POD))];
|
{ int arr[T(__is_pod(POD))]; }
|
||||||
int t04[T(__is_pod(Int))];
|
{ int arr[T(__is_pod(Int))]; }
|
||||||
int t05[T(__is_pod(IntAr))];
|
{ int arr[T(__is_pod(IntAr))]; }
|
||||||
int t06[T(__is_pod(Statics))];
|
{ int arr[T(__is_pod(Statics))]; }
|
||||||
int t07[T(__is_pod(Empty))];
|
{ int arr[T(__is_pod(Empty))]; }
|
||||||
int t08[T(__is_pod(EmptyUnion))];
|
{ int arr[T(__is_pod(EmptyUnion))]; }
|
||||||
int t09[T(__is_pod(Union))];
|
{ int arr[T(__is_pod(Union))]; }
|
||||||
int t10[T(__is_pod(HasFunc))];
|
{ int arr[T(__is_pod(HasFunc))]; }
|
||||||
int t11[T(__is_pod(HasOp))];
|
{ int arr[T(__is_pod(HasOp))]; }
|
||||||
int t12[T(__is_pod(HasConv))];
|
{ int arr[T(__is_pod(HasConv))]; }
|
||||||
int t13[T(__is_pod(HasAssign))];
|
{ int arr[T(__is_pod(HasAssign))]; }
|
||||||
int t14[T(__is_pod(IntArNB))];
|
{ int arr[T(__is_pod(IntArNB))]; }
|
||||||
int t15[T(__is_pod(HasAnonymousUnion))];
|
{ int arr[T(__is_pod(HasAnonymousUnion))]; }
|
||||||
|
|
||||||
int t21[F(__is_pod(Derives))];
|
{ int arr[F(__is_pod(Derives))]; }
|
||||||
int t22[F(__is_pod(HasCons))];
|
{ int arr[F(__is_pod(HasCons))]; }
|
||||||
int t23[F(__is_pod(HasCopyAssign))];
|
{ int arr[F(__is_pod(HasCopyAssign))]; }
|
||||||
int t24[F(__is_pod(HasDest))];
|
{ int arr[F(__is_pod(HasDest))]; }
|
||||||
int t25[F(__is_pod(HasPriv))];
|
{ int arr[F(__is_pod(HasPriv))]; }
|
||||||
int t26[F(__is_pod(HasProt))];
|
{ int arr[F(__is_pod(HasProt))]; }
|
||||||
int t27[F(__is_pod(HasRef))];
|
{ int arr[F(__is_pod(HasRef))]; }
|
||||||
int t28[F(__is_pod(HasNonPOD))];
|
{ int arr[F(__is_pod(HasNonPOD))]; }
|
||||||
int t29[F(__is_pod(HasVirt))];
|
{ int arr[F(__is_pod(HasVirt))]; }
|
||||||
int t30[F(__is_pod(NonPODAr))];
|
{ int arr[F(__is_pod(NonPODAr))]; }
|
||||||
int t31[F(__is_pod(DerivesEmpty))];
|
{ int arr[F(__is_pod(DerivesEmpty))]; }
|
||||||
int t32[F(__is_pod(void))];
|
{ int arr[F(__is_pod(void))]; }
|
||||||
int t33[F(__is_pod(cvoid))];
|
{ int arr[F(__is_pod(cvoid))]; }
|
||||||
int t34[F(__is_pod(NonPODArNB))];
|
{ int arr[F(__is_pod(NonPODArNB))]; }
|
||||||
// int t32[F(__is_pod(NonPODUnion))];
|
// { int arr[F(__is_pod(NonPODUnion))]; }
|
||||||
}
|
}
|
||||||
|
|
||||||
typedef Empty EmptyAr[10];
|
typedef Empty EmptyAr[10];
|
||||||
|
|
@ -118,48 +118,48 @@ struct BitOnly { int x : 3; };
|
||||||
|
|
||||||
void is_empty()
|
void is_empty()
|
||||||
{
|
{
|
||||||
int t01[T(__is_empty(Empty))];
|
{ int arr[T(__is_empty(Empty))]; }
|
||||||
int t02[T(__is_empty(DerivesEmpty))];
|
{ int arr[T(__is_empty(DerivesEmpty))]; }
|
||||||
int t03[T(__is_empty(HasCons))];
|
{ int arr[T(__is_empty(HasCons))]; }
|
||||||
int t04[T(__is_empty(HasCopyAssign))];
|
{ int arr[T(__is_empty(HasCopyAssign))]; }
|
||||||
int t05[T(__is_empty(HasDest))];
|
{ int arr[T(__is_empty(HasDest))]; }
|
||||||
int t06[T(__is_empty(HasFunc))];
|
{ int arr[T(__is_empty(HasFunc))]; }
|
||||||
int t07[T(__is_empty(HasOp))];
|
{ int arr[T(__is_empty(HasOp))]; }
|
||||||
int t08[T(__is_empty(HasConv))];
|
{ int arr[T(__is_empty(HasConv))]; }
|
||||||
int t09[T(__is_empty(HasAssign))];
|
{ int arr[T(__is_empty(HasAssign))]; }
|
||||||
int t10[T(__is_empty(Bit0))];
|
{ int arr[T(__is_empty(Bit0))]; }
|
||||||
int t11[T(__is_empty(Bit0Cons))];
|
{ int arr[T(__is_empty(Bit0Cons))]; }
|
||||||
|
|
||||||
int t21[F(__is_empty(Int))];
|
{ int arr[F(__is_empty(Int))]; }
|
||||||
int t22[F(__is_empty(POD))];
|
{ int arr[F(__is_empty(POD))]; }
|
||||||
int t23[F(__is_empty(EmptyUnion))];
|
{ int arr[F(__is_empty(EmptyUnion))]; }
|
||||||
int t24[F(__is_empty(EmptyAr))];
|
{ int arr[F(__is_empty(EmptyAr))]; }
|
||||||
int t25[F(__is_empty(HasRef))];
|
{ int arr[F(__is_empty(HasRef))]; }
|
||||||
int t26[F(__is_empty(HasVirt))];
|
{ int arr[F(__is_empty(HasVirt))]; }
|
||||||
int t27[F(__is_empty(BitOnly))];
|
{ int arr[F(__is_empty(BitOnly))]; }
|
||||||
int t28[F(__is_empty(void))];
|
{ int arr[F(__is_empty(void))]; }
|
||||||
int t29[F(__is_empty(IntArNB))];
|
{ int arr[F(__is_empty(IntArNB))]; }
|
||||||
int t30[F(__is_empty(HasAnonymousUnion))];
|
{ int arr[F(__is_empty(HasAnonymousUnion))]; }
|
||||||
// int t27[F(__is_empty(DerivesVirt))];
|
// { int arr[F(__is_empty(DerivesVirt))]; }
|
||||||
}
|
}
|
||||||
|
|
||||||
typedef Derives ClassType;
|
typedef Derives ClassType;
|
||||||
|
|
||||||
void is_class()
|
void is_class()
|
||||||
{
|
{
|
||||||
int t01[T(__is_class(Derives))];
|
{ int arr[T(__is_class(Derives))]; }
|
||||||
int t02[T(__is_class(HasPriv))];
|
{ int arr[T(__is_class(HasPriv))]; }
|
||||||
int t03[T(__is_class(ClassType))];
|
{ int arr[T(__is_class(ClassType))]; }
|
||||||
int t04[T(__is_class(HasAnonymousUnion))];
|
{ int arr[T(__is_class(HasAnonymousUnion))]; }
|
||||||
|
|
||||||
int t11[F(__is_class(int))];
|
{ int arr[F(__is_class(int))]; }
|
||||||
int t12[F(__is_class(Enum))];
|
{ int arr[F(__is_class(Enum))]; }
|
||||||
int t13[F(__is_class(Int))];
|
{ int arr[F(__is_class(Int))]; }
|
||||||
int t14[F(__is_class(IntAr))];
|
{ int arr[F(__is_class(IntAr))]; }
|
||||||
int t15[F(__is_class(NonPODAr))];
|
{ int arr[F(__is_class(NonPODAr))]; }
|
||||||
int t16[F(__is_class(Union))];
|
{ int arr[F(__is_class(Union))]; }
|
||||||
int t17[F(__is_class(cvoid))];
|
{ int arr[F(__is_class(cvoid))]; }
|
||||||
int t18[F(__is_class(IntArNB))];
|
{ int arr[F(__is_class(IntArNB))]; }
|
||||||
}
|
}
|
||||||
|
|
||||||
typedef Union UnionAr[10];
|
typedef Union UnionAr[10];
|
||||||
|
|
@ -167,36 +167,36 @@ typedef Union UnionType;
|
||||||
|
|
||||||
void is_union()
|
void is_union()
|
||||||
{
|
{
|
||||||
int t01[T(__is_union(Union))];
|
{ int arr[T(__is_union(Union))]; }
|
||||||
int t02[T(__is_union(UnionType))];
|
{ int arr[T(__is_union(UnionType))]; }
|
||||||
|
|
||||||
int t11[F(__is_union(int))];
|
{ int arr[F(__is_union(int))]; }
|
||||||
int t12[F(__is_union(Enum))];
|
{ int arr[F(__is_union(Enum))]; }
|
||||||
int t13[F(__is_union(Int))];
|
{ int arr[F(__is_union(Int))]; }
|
||||||
int t14[F(__is_union(IntAr))];
|
{ int arr[F(__is_union(IntAr))]; }
|
||||||
int t15[F(__is_union(UnionAr))];
|
{ int arr[F(__is_union(UnionAr))]; }
|
||||||
int t16[F(__is_union(cvoid))];
|
{ int arr[F(__is_union(cvoid))]; }
|
||||||
int t17[F(__is_union(IntArNB))];
|
{ int arr[F(__is_union(IntArNB))]; }
|
||||||
int t18[F(__is_union(HasAnonymousUnion))];
|
{ int arr[F(__is_union(HasAnonymousUnion))]; }
|
||||||
}
|
}
|
||||||
|
|
||||||
typedef Enum EnumType;
|
typedef Enum EnumType;
|
||||||
|
|
||||||
void is_enum()
|
void is_enum()
|
||||||
{
|
{
|
||||||
int t01[T(__is_enum(Enum))];
|
{ int arr[T(__is_enum(Enum))]; }
|
||||||
int t02[T(__is_enum(EnumType))];
|
{ int arr[T(__is_enum(EnumType))]; }
|
||||||
|
|
||||||
int t11[F(__is_enum(int))];
|
{ int arr[F(__is_enum(int))]; }
|
||||||
int t12[F(__is_enum(Union))];
|
{ int arr[F(__is_enum(Union))]; }
|
||||||
int t13[F(__is_enum(Int))];
|
{ int arr[F(__is_enum(Int))]; }
|
||||||
int t14[F(__is_enum(IntAr))];
|
{ int arr[F(__is_enum(IntAr))]; }
|
||||||
int t15[F(__is_enum(UnionAr))];
|
{ int arr[F(__is_enum(UnionAr))]; }
|
||||||
int t16[F(__is_enum(Derives))];
|
{ int arr[F(__is_enum(Derives))]; }
|
||||||
int t17[F(__is_enum(ClassType))];
|
{ int arr[F(__is_enum(ClassType))]; }
|
||||||
int t18[F(__is_enum(cvoid))];
|
{ int arr[F(__is_enum(cvoid))]; }
|
||||||
int t19[F(__is_enum(IntArNB))];
|
{ int arr[F(__is_enum(IntArNB))]; }
|
||||||
int t20[F(__is_enum(HasAnonymousUnion))];
|
{ int arr[F(__is_enum(HasAnonymousUnion))]; }
|
||||||
}
|
}
|
||||||
|
|
||||||
typedef HasVirt Polymorph;
|
typedef HasVirt Polymorph;
|
||||||
|
|
@ -204,19 +204,19 @@ struct InheritPolymorph : Polymorph {};
|
||||||
|
|
||||||
void is_polymorphic()
|
void is_polymorphic()
|
||||||
{
|
{
|
||||||
int t01[T(__is_polymorphic(Polymorph))];
|
{ int arr[T(__is_polymorphic(Polymorph))]; }
|
||||||
int t02[T(__is_polymorphic(InheritPolymorph))];
|
{ int arr[T(__is_polymorphic(InheritPolymorph))]; }
|
||||||
|
|
||||||
int t11[F(__is_polymorphic(int))];
|
{ int arr[F(__is_polymorphic(int))]; }
|
||||||
int t12[F(__is_polymorphic(Union))];
|
{ int arr[F(__is_polymorphic(Union))]; }
|
||||||
int t13[F(__is_polymorphic(Int))];
|
{ int arr[F(__is_polymorphic(Int))]; }
|
||||||
int t14[F(__is_polymorphic(IntAr))];
|
{ int arr[F(__is_polymorphic(IntAr))]; }
|
||||||
int t15[F(__is_polymorphic(UnionAr))];
|
{ int arr[F(__is_polymorphic(UnionAr))]; }
|
||||||
int t16[F(__is_polymorphic(Derives))];
|
{ int arr[F(__is_polymorphic(Derives))]; }
|
||||||
int t17[F(__is_polymorphic(ClassType))];
|
{ int arr[F(__is_polymorphic(ClassType))]; }
|
||||||
int t18[F(__is_polymorphic(Enum))];
|
{ int arr[F(__is_polymorphic(Enum))]; }
|
||||||
int t19[F(__is_polymorphic(cvoid))];
|
{ int arr[F(__is_polymorphic(cvoid))]; }
|
||||||
int t20[F(__is_polymorphic(IntArNB))];
|
{ int arr[F(__is_polymorphic(IntArNB))]; }
|
||||||
}
|
}
|
||||||
|
|
||||||
typedef Int& IntRef;
|
typedef Int& IntRef;
|
||||||
|
|
@ -235,216 +235,216 @@ struct HasTemplateCons {
|
||||||
};
|
};
|
||||||
|
|
||||||
void has_trivial_default_constructor() {
|
void has_trivial_default_constructor() {
|
||||||
int t01[T(__has_trivial_constructor(Int))];
|
{ int arr[T(__has_trivial_constructor(Int))]; }
|
||||||
int t02[T(__has_trivial_constructor(IntAr))];
|
{ int arr[T(__has_trivial_constructor(IntAr))]; }
|
||||||
int t03[T(__has_trivial_constructor(Union))];
|
{ int arr[T(__has_trivial_constructor(Union))]; }
|
||||||
int t04[T(__has_trivial_constructor(UnionAr))];
|
{ int arr[T(__has_trivial_constructor(UnionAr))]; }
|
||||||
int t05[T(__has_trivial_constructor(POD))];
|
{ int arr[T(__has_trivial_constructor(POD))]; }
|
||||||
int t06[T(__has_trivial_constructor(Derives))];
|
{ int arr[T(__has_trivial_constructor(Derives))]; }
|
||||||
int t07[T(__has_trivial_constructor(ConstIntAr))];
|
{ int arr[T(__has_trivial_constructor(ConstIntAr))]; }
|
||||||
int t08[T(__has_trivial_constructor(ConstIntArAr))];
|
{ int arr[T(__has_trivial_constructor(ConstIntArAr))]; }
|
||||||
int t09[T(__has_trivial_constructor(HasDest))];
|
{ int arr[T(__has_trivial_constructor(HasDest))]; }
|
||||||
int t10[T(__has_trivial_constructor(HasPriv))];
|
{ int arr[T(__has_trivial_constructor(HasPriv))]; }
|
||||||
int t11[F(__has_trivial_constructor(HasCons))];
|
{ int arr[F(__has_trivial_constructor(HasCons))]; }
|
||||||
int t12[F(__has_trivial_constructor(HasRef))];
|
{ int arr[F(__has_trivial_constructor(HasRef))]; }
|
||||||
int t13[F(__has_trivial_constructor(HasCopy))];
|
{ int arr[F(__has_trivial_constructor(HasCopy))]; }
|
||||||
int t14[F(__has_trivial_constructor(IntRef))];
|
{ int arr[F(__has_trivial_constructor(IntRef))]; }
|
||||||
int t15[T(__has_trivial_constructor(HasCopyAssign))];
|
{ int arr[T(__has_trivial_constructor(HasCopyAssign))]; }
|
||||||
int t16[T(__has_trivial_constructor(const Int))];
|
{ int arr[T(__has_trivial_constructor(const Int))]; }
|
||||||
int t17[T(__has_trivial_constructor(NonPODAr))];
|
{ int arr[T(__has_trivial_constructor(NonPODAr))]; }
|
||||||
int t18[F(__has_trivial_constructor(VirtAr))];
|
{ int arr[F(__has_trivial_constructor(VirtAr))]; }
|
||||||
int t19[F(__has_trivial_constructor(void))];
|
{ int arr[F(__has_trivial_constructor(void))]; }
|
||||||
int t20[F(__has_trivial_constructor(cvoid))];
|
{ int arr[F(__has_trivial_constructor(cvoid))]; }
|
||||||
int t21[F(__has_trivial_constructor(HasTemplateCons))];
|
{ int arr[F(__has_trivial_constructor(HasTemplateCons))]; }
|
||||||
}
|
}
|
||||||
|
|
||||||
void has_trivial_copy_constructor() {
|
void has_trivial_copy_constructor() {
|
||||||
int t01[T(__has_trivial_copy(Int))];
|
{ int arr[T(__has_trivial_copy(Int))]; }
|
||||||
int t02[T(__has_trivial_copy(IntAr))];
|
{ int arr[T(__has_trivial_copy(IntAr))]; }
|
||||||
int t03[T(__has_trivial_copy(Union))];
|
{ int arr[T(__has_trivial_copy(Union))]; }
|
||||||
int t04[T(__has_trivial_copy(UnionAr))];
|
{ int arr[T(__has_trivial_copy(UnionAr))]; }
|
||||||
int t05[T(__has_trivial_copy(POD))];
|
{ int arr[T(__has_trivial_copy(POD))]; }
|
||||||
int t06[T(__has_trivial_copy(Derives))];
|
{ int arr[T(__has_trivial_copy(Derives))]; }
|
||||||
int t07[T(__has_trivial_copy(ConstIntAr))];
|
{ int arr[T(__has_trivial_copy(ConstIntAr))]; }
|
||||||
int t08[T(__has_trivial_copy(ConstIntArAr))];
|
{ int arr[T(__has_trivial_copy(ConstIntArAr))]; }
|
||||||
int t09[T(__has_trivial_copy(HasDest))];
|
{ int arr[T(__has_trivial_copy(HasDest))]; }
|
||||||
int t10[T(__has_trivial_copy(HasPriv))];
|
{ int arr[T(__has_trivial_copy(HasPriv))]; }
|
||||||
int t11[T(__has_trivial_copy(HasCons))];
|
{ int arr[T(__has_trivial_copy(HasCons))]; }
|
||||||
int t12[T(__has_trivial_copy(HasRef))];
|
{ int arr[T(__has_trivial_copy(HasRef))]; }
|
||||||
int t13[F(__has_trivial_copy(HasCopy))];
|
{ int arr[F(__has_trivial_copy(HasCopy))]; }
|
||||||
int t14[T(__has_trivial_copy(IntRef))];
|
{ int arr[T(__has_trivial_copy(IntRef))]; }
|
||||||
int t15[T(__has_trivial_copy(HasCopyAssign))];
|
{ int arr[T(__has_trivial_copy(HasCopyAssign))]; }
|
||||||
int t16[T(__has_trivial_copy(const Int))];
|
{ int arr[T(__has_trivial_copy(const Int))]; }
|
||||||
int t17[F(__has_trivial_copy(NonPODAr))];
|
{ int arr[F(__has_trivial_copy(NonPODAr))]; }
|
||||||
int t18[F(__has_trivial_copy(VirtAr))];
|
{ int arr[F(__has_trivial_copy(VirtAr))]; }
|
||||||
int t19[F(__has_trivial_copy(void))];
|
{ int arr[F(__has_trivial_copy(void))]; }
|
||||||
int t20[F(__has_trivial_copy(cvoid))];
|
{ int arr[F(__has_trivial_copy(cvoid))]; }
|
||||||
int t21[F(__has_trivial_copy(HasTemplateCons))];
|
{ int arr[F(__has_trivial_copy(HasTemplateCons))]; }
|
||||||
}
|
}
|
||||||
|
|
||||||
void has_trivial_copy_assignment() {
|
void has_trivial_copy_assignment() {
|
||||||
int t01[T(__has_trivial_assign(Int))];
|
{ int arr[T(__has_trivial_assign(Int))]; }
|
||||||
int t02[T(__has_trivial_assign(IntAr))];
|
{ int arr[T(__has_trivial_assign(IntAr))]; }
|
||||||
int t03[T(__has_trivial_assign(Union))];
|
{ int arr[T(__has_trivial_assign(Union))]; }
|
||||||
int t04[T(__has_trivial_assign(UnionAr))];
|
{ int arr[T(__has_trivial_assign(UnionAr))]; }
|
||||||
int t05[T(__has_trivial_assign(POD))];
|
{ int arr[T(__has_trivial_assign(POD))]; }
|
||||||
int t06[T(__has_trivial_assign(Derives))];
|
{ int arr[T(__has_trivial_assign(Derives))]; }
|
||||||
int t07[F(__has_trivial_assign(ConstIntAr))];
|
{ int arr[F(__has_trivial_assign(ConstIntAr))]; }
|
||||||
int t08[F(__has_trivial_assign(ConstIntArAr))];
|
{ int arr[F(__has_trivial_assign(ConstIntArAr))]; }
|
||||||
int t09[T(__has_trivial_assign(HasDest))];
|
{ int arr[T(__has_trivial_assign(HasDest))]; }
|
||||||
int t10[T(__has_trivial_assign(HasPriv))];
|
{ int arr[T(__has_trivial_assign(HasPriv))]; }
|
||||||
int t11[T(__has_trivial_assign(HasCons))];
|
{ int arr[T(__has_trivial_assign(HasCons))]; }
|
||||||
int t12[T(__has_trivial_assign(HasRef))];
|
{ int arr[T(__has_trivial_assign(HasRef))]; }
|
||||||
int t13[T(__has_trivial_assign(HasCopy))];
|
{ int arr[T(__has_trivial_assign(HasCopy))]; }
|
||||||
int t14[F(__has_trivial_assign(IntRef))];
|
{ int arr[F(__has_trivial_assign(IntRef))]; }
|
||||||
int t15[F(__has_trivial_assign(HasCopyAssign))];
|
{ int arr[F(__has_trivial_assign(HasCopyAssign))]; }
|
||||||
int t16[F(__has_trivial_assign(const Int))];
|
{ int arr[F(__has_trivial_assign(const Int))]; }
|
||||||
int t17[F(__has_trivial_assign(NonPODAr))];
|
{ int arr[F(__has_trivial_assign(NonPODAr))]; }
|
||||||
int t18[F(__has_trivial_assign(VirtAr))];
|
{ int arr[F(__has_trivial_assign(VirtAr))]; }
|
||||||
int t19[F(__has_trivial_assign(void))];
|
{ int arr[F(__has_trivial_assign(void))]; }
|
||||||
int t20[F(__has_trivial_assign(cvoid))];
|
{ int arr[F(__has_trivial_assign(cvoid))]; }
|
||||||
}
|
}
|
||||||
|
|
||||||
void has_trivial_destructor() {
|
void has_trivial_destructor() {
|
||||||
int t01[T(__has_trivial_destructor(Int))];
|
{ int arr[T(__has_trivial_destructor(Int))]; }
|
||||||
int t02[T(__has_trivial_destructor(IntAr))];
|
{ int arr[T(__has_trivial_destructor(IntAr))]; }
|
||||||
int t03[T(__has_trivial_destructor(Union))];
|
{ int arr[T(__has_trivial_destructor(Union))]; }
|
||||||
int t04[T(__has_trivial_destructor(UnionAr))];
|
{ int arr[T(__has_trivial_destructor(UnionAr))]; }
|
||||||
int t05[T(__has_trivial_destructor(POD))];
|
{ int arr[T(__has_trivial_destructor(POD))]; }
|
||||||
int t06[T(__has_trivial_destructor(Derives))];
|
{ int arr[T(__has_trivial_destructor(Derives))]; }
|
||||||
int t07[T(__has_trivial_destructor(ConstIntAr))];
|
{ int arr[T(__has_trivial_destructor(ConstIntAr))]; }
|
||||||
int t08[T(__has_trivial_destructor(ConstIntArAr))];
|
{ int arr[T(__has_trivial_destructor(ConstIntArAr))]; }
|
||||||
int t09[F(__has_trivial_destructor(HasDest))];
|
{ int arr[F(__has_trivial_destructor(HasDest))]; }
|
||||||
int t10[T(__has_trivial_destructor(HasPriv))];
|
{ int arr[T(__has_trivial_destructor(HasPriv))]; }
|
||||||
int t11[T(__has_trivial_destructor(HasCons))];
|
{ int arr[T(__has_trivial_destructor(HasCons))]; }
|
||||||
int t12[T(__has_trivial_destructor(HasRef))];
|
{ int arr[T(__has_trivial_destructor(HasRef))]; }
|
||||||
int t13[T(__has_trivial_destructor(HasCopy))];
|
{ int arr[T(__has_trivial_destructor(HasCopy))]; }
|
||||||
int t14[T(__has_trivial_destructor(IntRef))];
|
{ int arr[T(__has_trivial_destructor(IntRef))]; }
|
||||||
int t15[T(__has_trivial_destructor(HasCopyAssign))];
|
{ int arr[T(__has_trivial_destructor(HasCopyAssign))]; }
|
||||||
int t16[T(__has_trivial_destructor(const Int))];
|
{ int arr[T(__has_trivial_destructor(const Int))]; }
|
||||||
int t17[T(__has_trivial_destructor(NonPODAr))];
|
{ int arr[T(__has_trivial_destructor(NonPODAr))]; }
|
||||||
int t18[T(__has_trivial_destructor(VirtAr))];
|
{ int arr[T(__has_trivial_destructor(VirtAr))]; }
|
||||||
int t19[F(__has_trivial_destructor(void))];
|
{ int arr[F(__has_trivial_destructor(void))]; }
|
||||||
int t20[F(__has_trivial_destructor(cvoid))];
|
{ int arr[F(__has_trivial_destructor(cvoid))]; }
|
||||||
}
|
}
|
||||||
|
|
||||||
struct A { ~A() {} };
|
struct A { ~A() {} };
|
||||||
template<typename> struct B : A { };
|
template<typename> struct B : A { };
|
||||||
|
|
||||||
void f() {
|
void f() {
|
||||||
int t01[F(__has_trivial_destructor(A))];
|
{ int arr[F(__has_trivial_destructor(A))]; }
|
||||||
int t02[F(__has_trivial_destructor(B<int>))];
|
{ int arr[F(__has_trivial_destructor(B<int>))]; }
|
||||||
}
|
}
|
||||||
|
|
||||||
void has_nothrow_assign() {
|
void has_nothrow_assign() {
|
||||||
int t01[T(__has_nothrow_assign(Int))];
|
{ int arr[T(__has_nothrow_assign(Int))]; }
|
||||||
int t02[T(__has_nothrow_assign(IntAr))];
|
{ int arr[T(__has_nothrow_assign(IntAr))]; }
|
||||||
int t03[T(__has_nothrow_assign(Union))];
|
{ int arr[T(__has_nothrow_assign(Union))]; }
|
||||||
int t04[T(__has_nothrow_assign(UnionAr))];
|
{ int arr[T(__has_nothrow_assign(UnionAr))]; }
|
||||||
int t05[T(__has_nothrow_assign(POD))];
|
{ int arr[T(__has_nothrow_assign(POD))]; }
|
||||||
int t06[T(__has_nothrow_assign(Derives))];
|
{ int arr[T(__has_nothrow_assign(Derives))]; }
|
||||||
int t07[F(__has_nothrow_assign(ConstIntAr))];
|
{ int arr[F(__has_nothrow_assign(ConstIntAr))]; }
|
||||||
int t08[F(__has_nothrow_assign(ConstIntArAr))];
|
{ int arr[F(__has_nothrow_assign(ConstIntArAr))]; }
|
||||||
int t09[T(__has_nothrow_assign(HasDest))];
|
{ int arr[T(__has_nothrow_assign(HasDest))]; }
|
||||||
int t10[T(__has_nothrow_assign(HasPriv))];
|
{ int arr[T(__has_nothrow_assign(HasPriv))]; }
|
||||||
int t11[T(__has_nothrow_assign(HasCons))];
|
{ int arr[T(__has_nothrow_assign(HasCons))]; }
|
||||||
int t12[T(__has_nothrow_assign(HasRef))];
|
{ int arr[T(__has_nothrow_assign(HasRef))]; }
|
||||||
int t13[T(__has_nothrow_assign(HasCopy))];
|
{ int arr[T(__has_nothrow_assign(HasCopy))]; }
|
||||||
int t14[F(__has_nothrow_assign(IntRef))];
|
{ int arr[F(__has_nothrow_assign(IntRef))]; }
|
||||||
int t15[F(__has_nothrow_assign(HasCopyAssign))];
|
{ int arr[F(__has_nothrow_assign(HasCopyAssign))]; }
|
||||||
int t16[F(__has_nothrow_assign(const Int))];
|
{ int arr[F(__has_nothrow_assign(const Int))]; }
|
||||||
int t17[F(__has_nothrow_assign(NonPODAr))];
|
{ int arr[F(__has_nothrow_assign(NonPODAr))]; }
|
||||||
int t18[F(__has_nothrow_assign(VirtAr))];
|
{ int arr[F(__has_nothrow_assign(VirtAr))]; }
|
||||||
int t19[T(__has_nothrow_assign(HasNoThrowCopyAssign))];
|
{ int arr[T(__has_nothrow_assign(HasNoThrowCopyAssign))]; }
|
||||||
int t20[F(__has_nothrow_assign(HasMultipleCopyAssign))];
|
{ int arr[F(__has_nothrow_assign(HasMultipleCopyAssign))]; }
|
||||||
int t21[T(__has_nothrow_assign(HasMultipleNoThrowCopyAssign))];
|
{ int arr[T(__has_nothrow_assign(HasMultipleNoThrowCopyAssign))]; }
|
||||||
int t22[F(__has_nothrow_assign(void))];
|
{ int arr[F(__has_nothrow_assign(void))]; }
|
||||||
int t23[F(__has_nothrow_assign(cvoid))];
|
{ int arr[F(__has_nothrow_assign(cvoid))]; }
|
||||||
int t24[T(__has_nothrow_assign(HasVirtDest))];
|
{ int arr[T(__has_nothrow_assign(HasVirtDest))]; }
|
||||||
}
|
}
|
||||||
|
|
||||||
void has_nothrow_copy() {
|
void has_nothrow_copy() {
|
||||||
int t01[T(__has_nothrow_copy(Int))];
|
{ int arr[T(__has_nothrow_copy(Int))]; }
|
||||||
int t02[T(__has_nothrow_copy(IntAr))];
|
{ int arr[T(__has_nothrow_copy(IntAr))]; }
|
||||||
int t03[T(__has_nothrow_copy(Union))];
|
{ int arr[T(__has_nothrow_copy(Union))]; }
|
||||||
int t04[T(__has_nothrow_copy(UnionAr))];
|
{ int arr[T(__has_nothrow_copy(UnionAr))]; }
|
||||||
int t05[T(__has_nothrow_copy(POD))];
|
{ int arr[T(__has_nothrow_copy(POD))]; }
|
||||||
int t06[T(__has_nothrow_copy(Derives))];
|
{ int arr[T(__has_nothrow_copy(Derives))]; }
|
||||||
int t07[T(__has_nothrow_copy(ConstIntAr))];
|
{ int arr[T(__has_nothrow_copy(ConstIntAr))]; }
|
||||||
int t08[T(__has_nothrow_copy(ConstIntArAr))];
|
{ int arr[T(__has_nothrow_copy(ConstIntArAr))]; }
|
||||||
int t09[T(__has_nothrow_copy(HasDest))];
|
{ int arr[T(__has_nothrow_copy(HasDest))]; }
|
||||||
int t10[T(__has_nothrow_copy(HasPriv))];
|
{ int arr[T(__has_nothrow_copy(HasPriv))]; }
|
||||||
int t11[T(__has_nothrow_copy(HasCons))];
|
{ int arr[T(__has_nothrow_copy(HasCons))]; }
|
||||||
int t12[T(__has_nothrow_copy(HasRef))];
|
{ int arr[T(__has_nothrow_copy(HasRef))]; }
|
||||||
int t13[F(__has_nothrow_copy(HasCopy))];
|
{ int arr[F(__has_nothrow_copy(HasCopy))]; }
|
||||||
int t14[T(__has_nothrow_copy(IntRef))];
|
{ int arr[T(__has_nothrow_copy(IntRef))]; }
|
||||||
int t15[T(__has_nothrow_copy(HasCopyAssign))];
|
{ int arr[T(__has_nothrow_copy(HasCopyAssign))]; }
|
||||||
int t16[T(__has_nothrow_copy(const Int))];
|
{ int arr[T(__has_nothrow_copy(const Int))]; }
|
||||||
int t17[F(__has_nothrow_copy(NonPODAr))];
|
{ int arr[F(__has_nothrow_copy(NonPODAr))]; }
|
||||||
int t18[F(__has_nothrow_copy(VirtAr))];
|
{ int arr[F(__has_nothrow_copy(VirtAr))]; }
|
||||||
|
|
||||||
int t19[T(__has_nothrow_copy(HasNoThrowCopy))];
|
{ int arr[T(__has_nothrow_copy(HasNoThrowCopy))]; }
|
||||||
int t20[F(__has_nothrow_copy(HasMultipleCopy))];
|
{ int arr[F(__has_nothrow_copy(HasMultipleCopy))]; }
|
||||||
int t21[T(__has_nothrow_copy(HasMultipleNoThrowCopy))];
|
{ int arr[T(__has_nothrow_copy(HasMultipleNoThrowCopy))]; }
|
||||||
int t22[F(__has_nothrow_copy(void))];
|
{ int arr[F(__has_nothrow_copy(void))]; }
|
||||||
int t23[F(__has_nothrow_copy(cvoid))];
|
{ int arr[F(__has_nothrow_copy(cvoid))]; }
|
||||||
int t24[T(__has_nothrow_copy(HasVirtDest))];
|
{ int arr[T(__has_nothrow_copy(HasVirtDest))]; }
|
||||||
int t25[T(__has_nothrow_copy(HasTemplateCons))];
|
{ int arr[T(__has_nothrow_copy(HasTemplateCons))]; }
|
||||||
}
|
}
|
||||||
|
|
||||||
void has_nothrow_constructor() {
|
void has_nothrow_constructor() {
|
||||||
int t01[T(__has_nothrow_constructor(Int))];
|
{ int arr[T(__has_nothrow_constructor(Int))]; }
|
||||||
int t02[T(__has_nothrow_constructor(IntAr))];
|
{ int arr[T(__has_nothrow_constructor(IntAr))]; }
|
||||||
int t03[T(__has_nothrow_constructor(Union))];
|
{ int arr[T(__has_nothrow_constructor(Union))]; }
|
||||||
int t04[T(__has_nothrow_constructor(UnionAr))];
|
{ int arr[T(__has_nothrow_constructor(UnionAr))]; }
|
||||||
int t05[T(__has_nothrow_constructor(POD))];
|
{ int arr[T(__has_nothrow_constructor(POD))]; }
|
||||||
int t06[T(__has_nothrow_constructor(Derives))];
|
{ int arr[T(__has_nothrow_constructor(Derives))]; }
|
||||||
int t07[T(__has_nothrow_constructor(ConstIntAr))];
|
{ int arr[T(__has_nothrow_constructor(ConstIntAr))]; }
|
||||||
int t08[T(__has_nothrow_constructor(ConstIntArAr))];
|
{ int arr[T(__has_nothrow_constructor(ConstIntArAr))]; }
|
||||||
int t09[T(__has_nothrow_constructor(HasDest))];
|
{ int arr[T(__has_nothrow_constructor(HasDest))]; }
|
||||||
int t10[T(__has_nothrow_constructor(HasPriv))];
|
{ int arr[T(__has_nothrow_constructor(HasPriv))]; }
|
||||||
int t11[F(__has_nothrow_constructor(HasCons))];
|
{ int arr[F(__has_nothrow_constructor(HasCons))]; }
|
||||||
int t12[F(__has_nothrow_constructor(HasRef))];
|
{ int arr[F(__has_nothrow_constructor(HasRef))]; }
|
||||||
int t13[F(__has_nothrow_constructor(HasCopy))];
|
{ int arr[F(__has_nothrow_constructor(HasCopy))]; }
|
||||||
int t14[F(__has_nothrow_constructor(IntRef))];
|
{ int arr[F(__has_nothrow_constructor(IntRef))]; }
|
||||||
int t15[T(__has_nothrow_constructor(HasCopyAssign))];
|
{ int arr[T(__has_nothrow_constructor(HasCopyAssign))]; }
|
||||||
int t16[T(__has_nothrow_constructor(const Int))];
|
{ int arr[T(__has_nothrow_constructor(const Int))]; }
|
||||||
int t17[T(__has_nothrow_constructor(NonPODAr))];
|
{ int arr[T(__has_nothrow_constructor(NonPODAr))]; }
|
||||||
// int t18[T(__has_nothrow_constructor(VirtAr))]; // not implemented
|
// { int arr[T(__has_nothrow_constructor(VirtAr))]; } // not implemented
|
||||||
|
|
||||||
int t19[T(__has_nothrow_constructor(HasNoThrowConstructor))];
|
{ int arr[T(__has_nothrow_constructor(HasNoThrowConstructor))]; }
|
||||||
int t20[F(__has_nothrow_constructor(HasNoThrowConstructorWithArgs))];
|
{ int arr[F(__has_nothrow_constructor(HasNoThrowConstructorWithArgs))]; }
|
||||||
int t21[F(__has_nothrow_constructor(void))];
|
{ int arr[F(__has_nothrow_constructor(void))]; }
|
||||||
int t22[F(__has_nothrow_constructor(cvoid))];
|
{ int arr[F(__has_nothrow_constructor(cvoid))]; }
|
||||||
int t23[T(__has_nothrow_constructor(HasVirtDest))];
|
{ int arr[T(__has_nothrow_constructor(HasVirtDest))]; }
|
||||||
int t24[F(__has_nothrow_constructor(HasTemplateCons))];
|
{ int arr[F(__has_nothrow_constructor(HasTemplateCons))]; }
|
||||||
}
|
}
|
||||||
|
|
||||||
void has_virtual_destructor() {
|
void has_virtual_destructor() {
|
||||||
int t01[F(__has_virtual_destructor(Int))];
|
{ int arr[F(__has_virtual_destructor(Int))]; }
|
||||||
int t02[F(__has_virtual_destructor(IntAr))];
|
{ int arr[F(__has_virtual_destructor(IntAr))]; }
|
||||||
int t03[F(__has_virtual_destructor(Union))];
|
{ int arr[F(__has_virtual_destructor(Union))]; }
|
||||||
int t04[F(__has_virtual_destructor(UnionAr))];
|
{ int arr[F(__has_virtual_destructor(UnionAr))]; }
|
||||||
int t05[F(__has_virtual_destructor(POD))];
|
{ int arr[F(__has_virtual_destructor(POD))]; }
|
||||||
int t06[F(__has_virtual_destructor(Derives))];
|
{ int arr[F(__has_virtual_destructor(Derives))]; }
|
||||||
int t07[F(__has_virtual_destructor(ConstIntAr))];
|
{ int arr[F(__has_virtual_destructor(ConstIntAr))]; }
|
||||||
int t08[F(__has_virtual_destructor(ConstIntArAr))];
|
{ int arr[F(__has_virtual_destructor(ConstIntArAr))]; }
|
||||||
int t09[F(__has_virtual_destructor(HasDest))];
|
{ int arr[F(__has_virtual_destructor(HasDest))]; }
|
||||||
int t10[F(__has_virtual_destructor(HasPriv))];
|
{ int arr[F(__has_virtual_destructor(HasPriv))]; }
|
||||||
int t11[F(__has_virtual_destructor(HasCons))];
|
{ int arr[F(__has_virtual_destructor(HasCons))]; }
|
||||||
int t12[F(__has_virtual_destructor(HasRef))];
|
{ int arr[F(__has_virtual_destructor(HasRef))]; }
|
||||||
int t13[F(__has_virtual_destructor(HasCopy))];
|
{ int arr[F(__has_virtual_destructor(HasCopy))]; }
|
||||||
int t14[F(__has_virtual_destructor(IntRef))];
|
{ int arr[F(__has_virtual_destructor(IntRef))]; }
|
||||||
int t15[F(__has_virtual_destructor(HasCopyAssign))];
|
{ int arr[F(__has_virtual_destructor(HasCopyAssign))]; }
|
||||||
int t16[F(__has_virtual_destructor(const Int))];
|
{ int arr[F(__has_virtual_destructor(const Int))]; }
|
||||||
int t17[F(__has_virtual_destructor(NonPODAr))];
|
{ int arr[F(__has_virtual_destructor(NonPODAr))]; }
|
||||||
int t18[F(__has_virtual_destructor(VirtAr))];
|
{ int arr[F(__has_virtual_destructor(VirtAr))]; }
|
||||||
|
|
||||||
int t19[T(__has_virtual_destructor(HasVirtDest))];
|
{ int arr[T(__has_virtual_destructor(HasVirtDest))]; }
|
||||||
int t20[T(__has_virtual_destructor(DerivedVirtDest))];
|
{ int arr[T(__has_virtual_destructor(DerivedVirtDest))]; }
|
||||||
int t21[F(__has_virtual_destructor(VirtDestAr))];
|
{ int arr[F(__has_virtual_destructor(VirtDestAr))]; }
|
||||||
int t22[F(__has_virtual_destructor(void))];
|
{ int arr[F(__has_virtual_destructor(void))]; }
|
||||||
int t23[F(__has_virtual_destructor(cvoid))];
|
{ int arr[F(__has_virtual_destructor(cvoid))]; }
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -474,29 +474,29 @@ template <class T> class NonderivedTemp {};
|
||||||
template <class T> class UndefinedTemp; // expected-note {{declared here}}
|
template <class T> class UndefinedTemp; // expected-note {{declared here}}
|
||||||
|
|
||||||
void is_base_of() {
|
void is_base_of() {
|
||||||
int t01[T(__is_base_of(Base, Derived))];
|
{ int arr[T(__is_base_of(Base, Derived))]; }
|
||||||
int t02[T(__is_base_of(const Base, Derived))];
|
{ int arr[T(__is_base_of(const Base, Derived))]; }
|
||||||
int t03[F(__is_base_of(Derived, Base))];
|
{ int arr[F(__is_base_of(Derived, Base))]; }
|
||||||
int t04[F(__is_base_of(Derived, int))];
|
{ int arr[F(__is_base_of(Derived, int))]; }
|
||||||
int t05[T(__is_base_of(Base, Base))];
|
{ int arr[T(__is_base_of(Base, Base))]; }
|
||||||
int t06[T(__is_base_of(Base, Derived3))];
|
{ int arr[T(__is_base_of(Base, Derived3))]; }
|
||||||
int t07[T(__is_base_of(Derived, Derived3))];
|
{ int arr[T(__is_base_of(Derived, Derived3))]; }
|
||||||
int t08[T(__is_base_of(Derived2b, Derived3))];
|
{ int arr[T(__is_base_of(Derived2b, Derived3))]; }
|
||||||
int t09[T(__is_base_of(Derived2a, Derived3))];
|
{ int arr[T(__is_base_of(Derived2a, Derived3))]; }
|
||||||
int t10[T(__is_base_of(BaseA<int>, DerivedB<int>))];
|
{ int arr[T(__is_base_of(BaseA<int>, DerivedB<int>))]; }
|
||||||
int t11[F(__is_base_of(DerivedB<int>, BaseA<int>))];
|
{ int arr[F(__is_base_of(DerivedB<int>, BaseA<int>))]; }
|
||||||
int t12[T(__is_base_of(Base, CrazyDerived<Base>))];
|
{ int arr[T(__is_base_of(Base, CrazyDerived<Base>))]; }
|
||||||
int t13[F(__is_base_of(Union, Union))];
|
{ int arr[F(__is_base_of(Union, Union))]; }
|
||||||
int t14[T(__is_base_of(Empty, Empty))];
|
{ int arr[T(__is_base_of(Empty, Empty))]; }
|
||||||
int t15[T(__is_base_of(class_forward, class_forward))];
|
{ int arr[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 arr[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[F(__is_base_of(Base&, Derived&))]; }
|
||||||
int t18[F(__is_base_of(Base[10], Derived[10]))];
|
int t18[F(__is_base_of(Base[10], Derived[10]))];
|
||||||
int t19[F(__is_base_of(int, int))];
|
{ int arr[F(__is_base_of(int, int))]; }
|
||||||
int t20[F(__is_base_of(long, int))];
|
{ int arr[F(__is_base_of(long, int))]; }
|
||||||
int t21[T(__is_base_of(Base, DerivedTemp<int>))];
|
{ int arr[T(__is_base_of(Base, DerivedTemp<int>))]; }
|
||||||
int t22[F(__is_base_of(Base, NonderivedTemp<int>))];
|
{ int arr[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(Base, UndefinedTemp<int>))]; } // expected-error {{implicit instantiation of undefined template 'UndefinedTemp<int>'}}
|
||||||
|
|
||||||
isBaseOfT<Base, Derived>();
|
isBaseOfT<Base, Derived>();
|
||||||
isBaseOfF<Derived, Base>();
|
isBaseOfF<Derived, Base>();
|
||||||
|
|
@ -524,61 +524,61 @@ struct X0 {
|
||||||
};
|
};
|
||||||
|
|
||||||
void is_convertible_to() {
|
void is_convertible_to() {
|
||||||
int t01[T(__is_convertible_to(Int, Int))];
|
{ int arr[T(__is_convertible_to(Int, Int))]; }
|
||||||
int t02[F(__is_convertible_to(Int, IntAr))];
|
{ int arr[F(__is_convertible_to(Int, IntAr))]; }
|
||||||
int t03[F(__is_convertible_to(IntAr, IntAr))];
|
{ int arr[F(__is_convertible_to(IntAr, IntAr))]; }
|
||||||
int t04[T(__is_convertible_to(void, void))];
|
{ int arr[T(__is_convertible_to(void, void))]; }
|
||||||
int t05[T(__is_convertible_to(cvoid, void))];
|
{ int arr[T(__is_convertible_to(cvoid, void))]; }
|
||||||
int t06[T(__is_convertible_to(void, cvoid))];
|
{ int arr[T(__is_convertible_to(void, cvoid))]; }
|
||||||
int t07[T(__is_convertible_to(cvoid, cvoid))];
|
{ int arr[T(__is_convertible_to(cvoid, cvoid))]; }
|
||||||
int t08[T(__is_convertible_to(int, FromInt))];
|
{ int arr[T(__is_convertible_to(int, FromInt))]; }
|
||||||
int t09[T(__is_convertible_to(long, FromInt))];
|
{ int arr[T(__is_convertible_to(long, FromInt))]; }
|
||||||
int t10[T(__is_convertible_to(double, FromInt))];
|
{ int arr[T(__is_convertible_to(double, FromInt))]; }
|
||||||
int t11[T(__is_convertible_to(const int, FromInt))];
|
{ int arr[T(__is_convertible_to(const int, FromInt))]; }
|
||||||
int t12[T(__is_convertible_to(const int&, FromInt))];
|
{ int arr[T(__is_convertible_to(const int&, FromInt))]; }
|
||||||
int t13[T(__is_convertible_to(ToInt, int))];
|
{ int arr[T(__is_convertible_to(ToInt, int))]; }
|
||||||
int t14[T(__is_convertible_to(ToInt, const int&))];
|
{ int arr[T(__is_convertible_to(ToInt, const int&))]; }
|
||||||
int t15[T(__is_convertible_to(ToInt, long))];
|
{ int arr[T(__is_convertible_to(ToInt, long))]; }
|
||||||
int t16[F(__is_convertible_to(ToInt, int&))];
|
{ int arr[F(__is_convertible_to(ToInt, int&))]; }
|
||||||
int t17[F(__is_convertible_to(ToInt, FromInt))];
|
{ int arr[F(__is_convertible_to(ToInt, FromInt))]; }
|
||||||
int t18[T(__is_convertible_to(IntAr&, IntAr&))];
|
{ int arr[T(__is_convertible_to(IntAr&, IntAr&))]; }
|
||||||
int t19[T(__is_convertible_to(IntAr&, const IntAr&))];
|
{ int arr[T(__is_convertible_to(IntAr&, const IntAr&))]; }
|
||||||
int t20[F(__is_convertible_to(const IntAr&, IntAr&))];
|
{ int arr[F(__is_convertible_to(const IntAr&, IntAr&))]; }
|
||||||
int t21[F(__is_convertible_to(Function, Function))];
|
{ int arr[F(__is_convertible_to(Function, Function))]; }
|
||||||
int t22[F(__is_convertible_to(PrivateCopy, PrivateCopy))];
|
{ int arr[F(__is_convertible_to(PrivateCopy, PrivateCopy))]; }
|
||||||
int t23[T(__is_convertible_to(X0<int>, X0<float>))];
|
{ int arr[T(__is_convertible_to(X0<int>, X0<float>))]; }
|
||||||
}
|
}
|
||||||
|
|
||||||
void is_trivial()
|
void is_trivial()
|
||||||
{
|
{
|
||||||
int t01[T(__is_trivial(int))];
|
{ int arr[T(__is_trivial(int))]; }
|
||||||
int t02[T(__is_trivial(Enum))];
|
{ int arr[T(__is_trivial(Enum))]; }
|
||||||
int t03[T(__is_trivial(POD))];
|
{ int arr[T(__is_trivial(POD))]; }
|
||||||
int t04[T(__is_trivial(Int))];
|
{ int arr[T(__is_trivial(Int))]; }
|
||||||
int t05[T(__is_trivial(IntAr))];
|
{ int arr[T(__is_trivial(IntAr))]; }
|
||||||
int t06[T(__is_trivial(Statics))];
|
{ int arr[T(__is_trivial(Statics))]; }
|
||||||
int t07[T(__is_trivial(Empty))];
|
{ int arr[T(__is_trivial(Empty))]; }
|
||||||
int t08[T(__is_trivial(EmptyUnion))];
|
{ int arr[T(__is_trivial(EmptyUnion))]; }
|
||||||
int t09[T(__is_trivial(Union))];
|
{ int arr[T(__is_trivial(Union))]; }
|
||||||
int t10[T(__is_trivial(HasFunc))];
|
{ int arr[T(__is_trivial(HasFunc))]; }
|
||||||
int t11[T(__is_trivial(HasOp))];
|
{ int arr[T(__is_trivial(HasOp))]; }
|
||||||
int t12[T(__is_trivial(HasConv))];
|
{ int arr[T(__is_trivial(HasConv))]; }
|
||||||
int t13[T(__is_trivial(HasAssign))];
|
{ int arr[T(__is_trivial(HasAssign))]; }
|
||||||
int t15[T(__is_trivial(HasAnonymousUnion))];
|
{ int arr[T(__is_trivial(HasAnonymousUnion))]; }
|
||||||
int t16[T(__is_trivial(Derives))];
|
{ int arr[T(__is_trivial(Derives))]; }
|
||||||
int t17[T(__is_trivial(DerivesEmpty))];
|
{ int arr[T(__is_trivial(DerivesEmpty))]; }
|
||||||
int t18[T(__is_trivial(NonPODAr))];
|
{ int arr[T(__is_trivial(NonPODAr))]; }
|
||||||
int t19[T(__is_trivial(HasPriv))];
|
{ int arr[T(__is_trivial(HasPriv))]; }
|
||||||
int t20[T(__is_trivial(HasProt))];
|
{ int arr[T(__is_trivial(HasProt))]; }
|
||||||
|
|
||||||
int f01[F(__is_trivial(IntArNB))];
|
{ int arr[F(__is_trivial(IntArNB))]; }
|
||||||
int f02[F(__is_trivial(HasCons))];
|
{ int arr[F(__is_trivial(HasCons))]; }
|
||||||
int f03[F(__is_trivial(HasCopyAssign))];
|
{ int arr[F(__is_trivial(HasCopyAssign))]; }
|
||||||
int f04[F(__is_trivial(HasDest))];
|
{ int arr[F(__is_trivial(HasDest))]; }
|
||||||
int f05[F(__is_trivial(HasRef))];
|
{ int arr[F(__is_trivial(HasRef))]; }
|
||||||
int f06[F(__is_trivial(HasNonPOD))];
|
{ int arr[F(__is_trivial(HasNonPOD))]; }
|
||||||
int f07[F(__is_trivial(HasVirt))];
|
{ int arr[F(__is_trivial(HasVirt))]; }
|
||||||
int f08[F(__is_trivial(void))];
|
{ int arr[F(__is_trivial(void))]; }
|
||||||
int f09[F(__is_trivial(cvoid))];
|
{ int arr[F(__is_trivial(cvoid))]; }
|
||||||
int f10[F(__is_trivial(NonPODArNB))];
|
{ int arr[F(__is_trivial(NonPODArNB))]; }
|
||||||
}
|
}
|
||||||
|
|
|
||||||
Loading…
Reference in New Issue