diff --git a/clang/test/SemaCXX/type-traits.cpp b/clang/test/SemaCXX/type-traits.cpp
index cbb3549c501d..e16ae2ddfa3e 100644
--- a/clang/test/SemaCXX/type-traits.cpp
+++ b/clang/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 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 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[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 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 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[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 arr[T(__is_class(Derives))]; }
+  { int arr[T(__is_class(HasPriv))]; }
+  { int arr[T(__is_class(ClassType))]; }
+  { int arr[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[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 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 @@ struct InheritPolymorph : Polymorph {};
 
 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 @@ 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 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 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(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 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 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(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 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 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[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 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 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[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))]; }
 }