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

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@130072 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/test/SemaCXX/type-traits.cpp b/test/SemaCXX/type-traits.cpp
index cbb3549c501d4a8f27c1d654af7a27eb1053938e..e16ae2ddfa3ef334473ee894ca693a31ea01579a 100644 (file)
--- a/test/SemaCXX/type-traits.cpp
+++ b/test/SemaCXX/type-traits.cpp
@@ -77,37 +77,37 @@ typedef HasVirtDest VirtDestAr[1];
 
 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 @@ struct BitOnly { int x : 3; };
 
 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 @@ typedef Union UnionType;
 
 void is_union()
 {
-  int t01[T(__is_union(Union))];
-  int t02[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[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 t01[T(__is_enum(Enum))];
-  int t02[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[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))]; }
 }
 
 typedef HasVirt Polymorph;
@@ -204,19 +204,19 @@ struct InheritPolymorph : Polymorph {};
 
 void is_polymorphic()
 {
-  int t01[T(__is_polymorphic(Polymorph))];
-  int t02[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[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(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 @@ struct HasTemplateCons {
 };
 
 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 NonderivedTemp {};
 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 @@ struct X0 {
 };
 
 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))]; }
 }