[clang] [clang][NFC] Refactor `clang/test/SemaCXX/type-traits.cpp` to use modern `static_assert` (PR #77584)
Amirreza Ashouri via cfe-commits
cfe-commits at lists.llvm.org
Wed Jan 10 03:38:38 PST 2024
https://github.com/AMP999 updated https://github.com/llvm/llvm-project/pull/77584
>From 9a3626d32ef7690bf4172d5c41ccd4e18237d8f9 Mon Sep 17 00:00:00 2001
From: Amirreza Ashouri <ar.ashouri999 at gmail.com>
Date: Tue, 9 Jan 2024 02:01:02 +0330
Subject: [PATCH 1/3] [clang][NFC] Refactor old-style `int[__trait(T) ? 1 :
-1]` with `static_assert`
---
clang/test/SemaCXX/type-traits.cpp | 3112 ++++++++++++++--------------
1 file changed, 1555 insertions(+), 1557 deletions(-)
diff --git a/clang/test/SemaCXX/type-traits.cpp b/clang/test/SemaCXX/type-traits.cpp
index c5d196a2590f8d..c0d5fba5c356f0 100644
--- a/clang/test/SemaCXX/type-traits.cpp
+++ b/clang/test/SemaCXX/type-traits.cpp
@@ -3,8 +3,6 @@
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++17 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted %s
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++20 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted %s
-#define T(b) (b) ? 1 : -1
-#define F(b) (b) ? -1 : 1
struct NonPOD { NonPOD(int); };
typedef NonPOD NonPODAr[10];
@@ -214,56 +212,56 @@ struct HasVirtBase : virtual ACompleteType {};
void is_pod()
{
- { 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[T(__is_pod(Vector))]; }
- { int arr[T(__is_pod(VectorExt))]; }
- { int arr[T(__is_pod(Derives))]; }
- { int arr[T(__is_pod(DerivesAr))]; }
- { int arr[T(__is_pod(DerivesArNB))]; }
- { int arr[T(__is_pod(DerivesEmpty))]; }
- { int arr[T(__is_pod(HasPriv))]; }
- { int arr[T(__is_pod(HasProt))]; }
- { int arr[T(__is_pod(DerivesHasPriv))]; }
- { int arr[T(__is_pod(DerivesHasProt))]; }
-
- { int arr[F(__is_pod(HasCons))]; }
- { int arr[F(__is_pod(HasCopyAssign))]; }
- { int arr[F(__is_pod(HasMoveAssign))]; }
- { int arr[F(__is_pod(HasDest))]; }
- { int arr[F(__is_pod(HasRef))]; }
- { int arr[F(__is_pod(HasVirt))]; }
- { int arr[F(__is_pod(DerivesHasCons))]; }
- { int arr[F(__is_pod(DerivesHasCopyAssign))]; }
- { int arr[F(__is_pod(DerivesHasMoveAssign))]; }
- { int arr[F(__is_pod(DerivesHasDest))]; }
- { int arr[F(__is_pod(DerivesHasRef))]; }
- { int arr[F(__is_pod(DerivesHasVirt))]; }
- { int arr[F(__is_pod(NonPOD))]; }
- { int arr[F(__is_pod(HasNonPOD))]; }
- { int arr[F(__is_pod(NonPODAr))]; }
- { int arr[F(__is_pod(NonPODArNB))]; }
- { int arr[F(__is_pod(void))]; }
- { int arr[F(__is_pod(cvoid))]; }
-// { int arr[F(__is_pod(NonPODUnion))]; }
-
- { int arr[T(__is_pod(ACompleteType))]; }
- { int arr[F(__is_pod(AnIncompleteType))]; } // expected-error {{incomplete type}}
- { int arr[F(__is_pod(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
- { int arr[F(__is_pod(AnIncompleteType[1]))]; } // expected-error {{incomplete type}}
+ static_assert(__is_pod(int), "");
+ static_assert(__is_pod(Enum), "");
+ static_assert(__is_pod(POD), "");
+ static_assert(__is_pod(Int), "");
+ static_assert(__is_pod(IntAr), "");
+ static_assert(__is_pod(Statics), "");
+ static_assert(__is_pod(Empty), "");
+ static_assert(__is_pod(EmptyUnion), "");
+ static_assert(__is_pod(Union), "");
+ static_assert(__is_pod(HasFunc), "");
+ static_assert(__is_pod(HasOp), "");
+ static_assert(__is_pod(HasConv), "");
+ static_assert(__is_pod(HasAssign), "");
+ static_assert(__is_pod(IntArNB), "");
+ static_assert(__is_pod(HasAnonymousUnion), "");
+ static_assert(__is_pod(Vector), "");
+ static_assert(__is_pod(VectorExt), "");
+ static_assert(__is_pod(Derives), "");
+ static_assert(__is_pod(DerivesAr), "");
+ static_assert(__is_pod(DerivesArNB), "");
+ static_assert(__is_pod(DerivesEmpty), "");
+ static_assert(__is_pod(HasPriv), "");
+ static_assert(__is_pod(HasProt), "");
+ static_assert(__is_pod(DerivesHasPriv), "");
+ static_assert(__is_pod(DerivesHasProt), "");
+
+ static_assert(!__is_pod(HasCons), "");
+ static_assert(!__is_pod(HasCopyAssign), "");
+ static_assert(!__is_pod(HasMoveAssign), "");
+ static_assert(!__is_pod(HasDest), "");
+ static_assert(!__is_pod(HasRef), "");
+ static_assert(!__is_pod(HasVirt), "");
+ static_assert(!__is_pod(DerivesHasCons), "");
+ static_assert(!__is_pod(DerivesHasCopyAssign), "");
+ static_assert(!__is_pod(DerivesHasMoveAssign), "");
+ static_assert(!__is_pod(DerivesHasDest), "");
+ static_assert(!__is_pod(DerivesHasRef), "");
+ static_assert(!__is_pod(DerivesHasVirt), "");
+ static_assert(!__is_pod(NonPOD), "");
+ static_assert(!__is_pod(HasNonPOD), "");
+ static_assert(!__is_pod(NonPODAr), "");
+ static_assert(!__is_pod(NonPODArNB), "");
+ static_assert(!__is_pod(void), "");
+ static_assert(!__is_pod(cvoid), "");
+// static_assert(!__is_pod(NonPODUnion), "");
+
+ static_assert(__is_pod(ACompleteType), "");
+ static_assert(!__is_pod(AnIncompleteType), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_pod(AnIncompleteType[]), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_pod(AnIncompleteType[1]), ""); // expected-error {{incomplete type}}
}
typedef Empty EmptyAr[10];
@@ -275,56 +273,56 @@ struct DerivesVirt : virtual POD {};
void is_empty()
{
- { 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(HasMoveAssign))]; }
- { 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(IncompleteUnion))]; }
- { int arr[F(__is_empty(EmptyAr))]; }
- { int arr[F(__is_empty(HasRef))]; }
- { int arr[F(__is_empty(HasVirt))]; }
- { int arr[F(__is_empty(AnonBitOnly))]; }
- { 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))]; }
-
- { int arr[T(__is_empty(ACompleteType))]; }
- { int arr[F(__is_empty(AnIncompleteType))]; } // expected-error {{incomplete type}}
- { int arr[F(__is_empty(AnIncompleteType[]))]; }
- { int arr[F(__is_empty(AnIncompleteType[1]))]; }
+ static_assert(__is_empty(Empty), "");
+ static_assert(__is_empty(DerivesEmpty), "");
+ static_assert(__is_empty(HasCons), "");
+ static_assert(__is_empty(HasCopyAssign), "");
+ static_assert(__is_empty(HasMoveAssign), "");
+ static_assert(__is_empty(HasDest), "");
+ static_assert(__is_empty(HasFunc), "");
+ static_assert(__is_empty(HasOp), "");
+ static_assert(__is_empty(HasConv), "");
+ static_assert(__is_empty(HasAssign), "");
+ static_assert(__is_empty(Bit0), "");
+ static_assert(__is_empty(Bit0Cons), "");
+
+ static_assert(!__is_empty(Int), "");
+ static_assert(!__is_empty(POD), "");
+ static_assert(!__is_empty(EmptyUnion), "");
+ static_assert(!__is_empty(IncompleteUnion), "");
+ static_assert(!__is_empty(EmptyAr), "");
+ static_assert(!__is_empty(HasRef), "");
+ static_assert(!__is_empty(HasVirt), "");
+ static_assert(!__is_empty(AnonBitOnly), "");
+ static_assert(!__is_empty(BitOnly), "");
+ static_assert(!__is_empty(void), "");
+ static_assert(!__is_empty(IntArNB), "");
+ static_assert(!__is_empty(HasAnonymousUnion), "");
+// static_assert(!__is_empty(DerivesVirt), "");
+
+ static_assert(__is_empty(ACompleteType), "");
+ static_assert(!__is_empty(AnIncompleteType), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_empty(AnIncompleteType[]), "");
+ static_assert(!__is_empty(AnIncompleteType[1]), "");
}
typedef Derives ClassType;
void is_class()
{
- { 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(DerivesAr))]; }
- { int arr[F(__is_class(Union))]; }
- { int arr[F(__is_class(cvoid))]; }
- { int arr[F(__is_class(IntArNB))]; }
+ static_assert(__is_class(Derives), "");
+ static_assert(__is_class(HasPriv), "");
+ static_assert(__is_class(ClassType), "");
+ static_assert(__is_class(HasAnonymousUnion), "");
+
+ static_assert(!__is_class(int), "");
+ static_assert(!__is_class(Enum), "");
+ static_assert(!__is_class(Int), "");
+ static_assert(!__is_class(IntAr), "");
+ static_assert(!__is_class(DerivesAr), "");
+ static_assert(!__is_class(Union), "");
+ static_assert(!__is_class(cvoid), "");
+ static_assert(!__is_class(IntArNB), "");
}
typedef Union UnionAr[10];
@@ -332,17 +330,17 @@ typedef Union UnionType;
void is_union()
{
- { 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))]; }
+ static_assert(__is_union(Union), "");
+ static_assert(__is_union(UnionType), "");
+
+ static_assert(!__is_union(int), "");
+ static_assert(!__is_union(Enum), "");
+ static_assert(!__is_union(Int), "");
+ static_assert(!__is_union(IntAr), "");
+ static_assert(!__is_union(UnionAr), "");
+ static_assert(!__is_union(cvoid), "");
+ static_assert(!__is_union(IntArNB), "");
+ static_assert(!__is_union(HasAnonymousUnion), "");
}
typedef Enum EnumType;
@@ -350,30 +348,30 @@ typedef EnumClass EnumClassType;
void is_enum()
{
- { int arr[T(__is_enum(Enum))]; }
- { int arr[T(__is_enum(EnumType))]; }
- { int arr[T(__is_enum(SignedEnum))]; }
- { int arr[T(__is_enum(UnsignedEnum))]; }
-
- { int arr[T(__is_enum(EnumClass))]; }
- { int arr[T(__is_enum(EnumClassType))]; }
- { int arr[T(__is_enum(SignedEnumClass))]; }
- { int arr[T(__is_enum(UnsignedEnumClass))]; }
-
- { 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))]; }
- { int arr[F(__is_enum(AnIncompleteType))]; }
- { int arr[F(__is_enum(AnIncompleteTypeAr))]; }
- { int arr[F(__is_enum(AnIncompleteTypeArMB))]; }
- { int arr[F(__is_enum(AnIncompleteTypeArNB))]; }
+ static_assert(__is_enum(Enum), "");
+ static_assert(__is_enum(EnumType), "");
+ static_assert(__is_enum(SignedEnum), "");
+ static_assert(__is_enum(UnsignedEnum), "");
+
+ static_assert(__is_enum(EnumClass), "");
+ static_assert(__is_enum(EnumClassType), "");
+ static_assert(__is_enum(SignedEnumClass), "");
+ static_assert(__is_enum(UnsignedEnumClass), "");
+
+ static_assert(!__is_enum(int), "");
+ static_assert(!__is_enum(Union), "");
+ static_assert(!__is_enum(Int), "");
+ static_assert(!__is_enum(IntAr), "");
+ static_assert(!__is_enum(UnionAr), "");
+ static_assert(!__is_enum(Derives), "");
+ static_assert(!__is_enum(ClassType), "");
+ static_assert(!__is_enum(cvoid), "");
+ static_assert(!__is_enum(IntArNB), "");
+ static_assert(!__is_enum(HasAnonymousUnion), "");
+ static_assert(!__is_enum(AnIncompleteType), "");
+ static_assert(!__is_enum(AnIncompleteTypeAr), "");
+ static_assert(!__is_enum(AnIncompleteTypeArMB), "");
+ static_assert(!__is_enum(AnIncompleteTypeArNB), "");
}
void is_scoped_enum() {
@@ -421,20 +419,20 @@ struct PotentiallyFinal<int> final { };
void is_final()
{
- { int arr[T(__is_final(FinalClass))]; }
- { int arr[T(__is_final(PotentiallyFinal<float*>))]; }
- { int arr[T(__is_final(PotentiallyFinal<int>))]; }
-
- { int arr[F(__is_final(int))]; }
- { int arr[F(__is_final(Union))]; }
- { int arr[F(__is_final(Int))]; }
- { int arr[F(__is_final(IntAr))]; }
- { int arr[F(__is_final(UnionAr))]; }
- { int arr[F(__is_final(Derives))]; }
- { int arr[F(__is_final(ClassType))]; }
- { int arr[F(__is_final(cvoid))]; }
- { int arr[F(__is_final(IntArNB))]; }
- { int arr[F(__is_final(HasAnonymousUnion))]; }
+ static_assert(__is_final(FinalClass), "");
+ static_assert(__is_final(PotentiallyFinal<float*>), "");
+ static_assert(__is_final(PotentiallyFinal<int>), "");
+
+ static_assert(!__is_final(int), "");
+ static_assert(!__is_final(Union), "");
+ static_assert(!__is_final(Int), "");
+ static_assert(!__is_final(IntAr), "");
+ static_assert(!__is_final(UnionAr), "");
+ static_assert(!__is_final(Derives), "");
+ static_assert(!__is_final(ClassType), "");
+ static_assert(!__is_final(cvoid), "");
+ static_assert(!__is_final(IntArNB), "");
+ static_assert(!__is_final(HasAnonymousUnion), "");
}
@@ -443,78 +441,78 @@ struct InheritPolymorph : Polymorph {};
void is_polymorphic()
{
- { 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(IncompleteUnion))]; }
- { 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))]; }
+ static_assert(__is_polymorphic(Polymorph), "");
+ static_assert(__is_polymorphic(InheritPolymorph), "");
+
+ static_assert(!__is_polymorphic(int), "");
+ static_assert(!__is_polymorphic(Union), "");
+ static_assert(!__is_polymorphic(IncompleteUnion), "");
+ static_assert(!__is_polymorphic(Int), "");
+ static_assert(!__is_polymorphic(IntAr), "");
+ static_assert(!__is_polymorphic(UnionAr), "");
+ static_assert(!__is_polymorphic(Derives), "");
+ static_assert(!__is_polymorphic(ClassType), "");
+ static_assert(!__is_polymorphic(Enum), "");
+ static_assert(!__is_polymorphic(cvoid), "");
+ static_assert(!__is_polymorphic(IntArNB), "");
}
void is_integral()
{
- int t01[T(__is_integral(bool))];
- int t02[T(__is_integral(char))];
- int t03[T(__is_integral(signed char))];
- int t04[T(__is_integral(unsigned char))];
- //int t05[T(__is_integral(char16_t))];
- //int t06[T(__is_integral(char32_t))];
- int t07[T(__is_integral(wchar_t))];
- int t08[T(__is_integral(short))];
- int t09[T(__is_integral(unsigned short))];
- int t10[T(__is_integral(int))];
- int t11[T(__is_integral(unsigned int))];
- int t12[T(__is_integral(long))];
- int t13[T(__is_integral(unsigned long))];
-
- int t21[F(__is_integral(float))];
- int t22[F(__is_integral(double))];
- int t23[F(__is_integral(long double))];
- int t24[F(__is_integral(Union))];
- int t25[F(__is_integral(UnionAr))];
- int t26[F(__is_integral(Derives))];
- int t27[F(__is_integral(ClassType))];
- int t28[F(__is_integral(Enum))];
- int t29[F(__is_integral(void))];
- int t30[F(__is_integral(cvoid))];
- int t31[F(__is_integral(IntArNB))];
+ static_assert(__is_integral(bool), "");
+ static_assert(__is_integral(char), "");
+ static_assert(__is_integral(signed char), "");
+ static_assert(__is_integral(unsigned char), "");
+ //static_assert(__is_integral(char16_t), "");
+ //static_assert(__is_integral(char32_t), "");
+ static_assert(__is_integral(wchar_t), "");
+ static_assert(__is_integral(short), "");
+ static_assert(__is_integral(unsigned short), "");
+ static_assert(__is_integral(int), "");
+ static_assert(__is_integral(unsigned int), "");
+ static_assert(__is_integral(long), "");
+ static_assert(__is_integral(unsigned long), "");
+
+ static_assert(!__is_integral(float), "");
+ static_assert(!__is_integral(double), "");
+ static_assert(!__is_integral(long double), "");
+ static_assert(!__is_integral(Union), "");
+ static_assert(!__is_integral(UnionAr), "");
+ static_assert(!__is_integral(Derives), "");
+ static_assert(!__is_integral(ClassType), "");
+ static_assert(!__is_integral(Enum), "");
+ static_assert(!__is_integral(void), "");
+ static_assert(!__is_integral(cvoid), "");
+ static_assert(!__is_integral(IntArNB), "");
}
void is_floating_point()
{
- int t01[T(__is_floating_point(float))];
- int t02[T(__is_floating_point(double))];
- int t03[T(__is_floating_point(long double))];
-
- int t11[F(__is_floating_point(bool))];
- int t12[F(__is_floating_point(char))];
- int t13[F(__is_floating_point(signed char))];
- int t14[F(__is_floating_point(unsigned char))];
- //int t15[F(__is_floating_point(char16_t))];
- //int t16[F(__is_floating_point(char32_t))];
- int t17[F(__is_floating_point(wchar_t))];
- int t18[F(__is_floating_point(short))];
- int t19[F(__is_floating_point(unsigned short))];
- int t20[F(__is_floating_point(int))];
- int t21[F(__is_floating_point(unsigned int))];
- int t22[F(__is_floating_point(long))];
- int t23[F(__is_floating_point(unsigned long))];
- int t24[F(__is_floating_point(Union))];
- int t25[F(__is_floating_point(UnionAr))];
- int t26[F(__is_floating_point(Derives))];
- int t27[F(__is_floating_point(ClassType))];
- int t28[F(__is_floating_point(Enum))];
- int t29[F(__is_floating_point(void))];
- int t30[F(__is_floating_point(cvoid))];
- int t31[F(__is_floating_point(IntArNB))];
+ static_assert(__is_floating_point(float), "");
+ static_assert(__is_floating_point(double), "");
+ static_assert(__is_floating_point(long double), "");
+
+ static_assert(!__is_floating_point(bool), "");
+ static_assert(!__is_floating_point(char), "");
+ static_assert(!__is_floating_point(signed char), "");
+ static_assert(!__is_floating_point(unsigned char), "");
+ //static_assert(!__is_floating_point(char16_t), "");
+ //static_assert(!__is_floating_point(char32_t), "");
+ static_assert(!__is_floating_point(wchar_t), "");
+ static_assert(!__is_floating_point(short), "");
+ static_assert(!__is_floating_point(unsigned short), "");
+ static_assert(!__is_floating_point(int), "");
+ static_assert(!__is_floating_point(unsigned int), "");
+ static_assert(!__is_floating_point(long), "");
+ static_assert(!__is_floating_point(unsigned long), "");
+ static_assert(!__is_floating_point(Union), "");
+ static_assert(!__is_floating_point(UnionAr), "");
+ static_assert(!__is_floating_point(Derives), "");
+ static_assert(!__is_floating_point(ClassType), "");
+ static_assert(!__is_floating_point(Enum), "");
+ static_assert(!__is_floating_point(void), "");
+ static_assert(!__is_floating_point(cvoid), "");
+ static_assert(!__is_floating_point(IntArNB), "");
}
template <class T>
@@ -604,113 +602,113 @@ void is_aggregate()
void is_arithmetic()
{
- int t01[T(__is_arithmetic(float))];
- int t02[T(__is_arithmetic(double))];
- int t03[T(__is_arithmetic(long double))];
- int t11[T(__is_arithmetic(bool))];
- int t12[T(__is_arithmetic(char))];
- int t13[T(__is_arithmetic(signed char))];
- int t14[T(__is_arithmetic(unsigned char))];
- //int t15[T(__is_arithmetic(char16_t))];
- //int t16[T(__is_arithmetic(char32_t))];
- int t17[T(__is_arithmetic(wchar_t))];
- int t18[T(__is_arithmetic(short))];
- int t19[T(__is_arithmetic(unsigned short))];
- int t20[T(__is_arithmetic(int))];
- int t21[T(__is_arithmetic(unsigned int))];
- int t22[T(__is_arithmetic(long))];
- int t23[T(__is_arithmetic(unsigned long))];
-
- int t24[F(__is_arithmetic(Union))];
- int t25[F(__is_arithmetic(UnionAr))];
- int t26[F(__is_arithmetic(Derives))];
- int t27[F(__is_arithmetic(ClassType))];
- int t28[F(__is_arithmetic(Enum))];
- int t29[F(__is_arithmetic(void))];
- int t30[F(__is_arithmetic(cvoid))];
- int t31[F(__is_arithmetic(IntArNB))];
+ static_assert(__is_arithmetic(float), "");
+ static_assert(__is_arithmetic(double), "");
+ static_assert(__is_arithmetic(long double), "");
+ static_assert(__is_arithmetic(bool), "");
+ static_assert(__is_arithmetic(char), "");
+ static_assert(__is_arithmetic(signed char), "");
+ static_assert(__is_arithmetic(unsigned char), "");
+ //static_assert(__is_arithmetic(char16_t), "");
+ //static_assert(__is_arithmetic(char32_t), "");
+ static_assert(__is_arithmetic(wchar_t), "");
+ static_assert(__is_arithmetic(short), "");
+ static_assert(__is_arithmetic(unsigned short), "");
+ static_assert(__is_arithmetic(int), "");
+ static_assert(__is_arithmetic(unsigned int), "");
+ static_assert(__is_arithmetic(long), "");
+ static_assert(__is_arithmetic(unsigned long), "");
+
+ static_assert(!__is_arithmetic(Union), "");
+ static_assert(!__is_arithmetic(UnionAr), "");
+ static_assert(!__is_arithmetic(Derives), "");
+ static_assert(!__is_arithmetic(ClassType), "");
+ static_assert(!__is_arithmetic(Enum), "");
+ static_assert(!__is_arithmetic(void), "");
+ static_assert(!__is_arithmetic(cvoid), "");
+ static_assert(!__is_arithmetic(IntArNB), "");
}
void is_complete_type()
{
- int t01[T(__is_complete_type(float))];
- int t02[T(__is_complete_type(double))];
- int t03[T(__is_complete_type(long double))];
- int t11[T(__is_complete_type(bool))];
- int t12[T(__is_complete_type(char))];
- int t13[T(__is_complete_type(signed char))];
- int t14[T(__is_complete_type(unsigned char))];
- //int t15[T(__is_complete_type(char16_t))];
- //int t16[T(__is_complete_type(char32_t))];
- int t17[T(__is_complete_type(wchar_t))];
- int t18[T(__is_complete_type(short))];
- int t19[T(__is_complete_type(unsigned short))];
- int t20[T(__is_complete_type(int))];
- int t21[T(__is_complete_type(unsigned int))];
- int t22[T(__is_complete_type(long))];
- int t23[T(__is_complete_type(unsigned long))];
- int t24[T(__is_complete_type(ACompleteType))];
-
- int t30[F(__is_complete_type(AnIncompleteType))];
+ static_assert(__is_complete_type(float), "");
+ static_assert(__is_complete_type(double), "");
+ static_assert(__is_complete_type(long double), "");
+ static_assert(__is_complete_type(bool), "");
+ static_assert(__is_complete_type(char), "");
+ static_assert(__is_complete_type(signed char), "");
+ static_assert(__is_complete_type(unsigned char), "");
+ //static_assert(__is_complete_type(char16_t), "");
+ //static_assert(__is_complete_type(char32_t), "");
+ static_assert(__is_complete_type(wchar_t), "");
+ static_assert(__is_complete_type(short), "");
+ static_assert(__is_complete_type(unsigned short), "");
+ static_assert(__is_complete_type(int), "");
+ static_assert(__is_complete_type(unsigned int), "");
+ static_assert(__is_complete_type(long), "");
+ static_assert(__is_complete_type(unsigned long), "");
+ static_assert(__is_complete_type(ACompleteType), "");
+
+ static_assert(!__is_complete_type(AnIncompleteType), "");
}
void is_void()
{
- int t01[T(__is_void(void))];
- int t02[T(__is_void(cvoid))];
-
- int t10[F(__is_void(float))];
- int t11[F(__is_void(double))];
- int t12[F(__is_void(long double))];
- int t13[F(__is_void(bool))];
- int t14[F(__is_void(char))];
- int t15[F(__is_void(signed char))];
- int t16[F(__is_void(unsigned char))];
- int t17[F(__is_void(wchar_t))];
- int t18[F(__is_void(short))];
- int t19[F(__is_void(unsigned short))];
- int t20[F(__is_void(int))];
- int t21[F(__is_void(unsigned int))];
- int t22[F(__is_void(long))];
- int t23[F(__is_void(unsigned long))];
- int t24[F(__is_void(Union))];
- int t25[F(__is_void(UnionAr))];
- int t26[F(__is_void(Derives))];
- int t27[F(__is_void(ClassType))];
- int t28[F(__is_void(Enum))];
- int t29[F(__is_void(IntArNB))];
- int t30[F(__is_void(void*))];
- int t31[F(__is_void(cvoid*))];
+ static_assert(__is_void(void), "");
+ static_assert(__is_void(cvoid), "");
+
+ static_assert(!__is_void(float), "");
+ static_assert(!__is_void(double), "");
+ static_assert(!__is_void(long double), "");
+ static_assert(!__is_void(bool), "");
+ static_assert(!__is_void(char), "");
+ static_assert(!__is_void(signed char), "");
+ static_assert(!__is_void(unsigned char), "");
+ static_assert(!__is_void(wchar_t), "");
+ static_assert(!__is_void(short), "");
+ static_assert(!__is_void(unsigned short), "");
+ static_assert(!__is_void(int), "");
+ static_assert(!__is_void(unsigned int), "");
+ static_assert(!__is_void(long), "");
+ static_assert(!__is_void(unsigned long), "");
+ static_assert(!__is_void(Union), "");
+ static_assert(!__is_void(UnionAr), "");
+ static_assert(!__is_void(Derives), "");
+ static_assert(!__is_void(ClassType), "");
+ static_assert(!__is_void(Enum), "");
+ static_assert(!__is_void(IntArNB), "");
+ static_assert(!__is_void(void*), "");
+ static_assert(!__is_void(cvoid*), "");
}
void is_array()
{
- int t01[T(__is_array(IntAr))];
- int t02[T(__is_array(IntArNB))];
- int t03[T(__is_array(UnionAr))];
-
- int t10[F(__is_array(void))];
- int t11[F(__is_array(cvoid))];
- int t12[F(__is_array(float))];
- int t13[F(__is_array(double))];
- int t14[F(__is_array(long double))];
- int t15[F(__is_array(bool))];
- int t16[F(__is_array(char))];
- int t17[F(__is_array(signed char))];
- int t18[F(__is_array(unsigned char))];
- int t19[F(__is_array(wchar_t))];
- int t20[F(__is_array(short))];
- int t21[F(__is_array(unsigned short))];
- int t22[F(__is_array(int))];
- int t23[F(__is_array(unsigned int))];
- int t24[F(__is_array(long))];
- int t25[F(__is_array(unsigned long))];
- int t26[F(__is_array(Union))];
- int t27[F(__is_array(Derives))];
- int t28[F(__is_array(ClassType))];
- int t29[F(__is_array(Enum))];
- int t30[F(__is_array(void*))];
- int t31[F(__is_array(cvoid*))];
+ static_assert(__is_array(IntAr), "");
+ static_assert(__is_array(IntArNB), "");
+ static_assert(__is_array(UnionAr), "");
+
+ static_assert(!__is_array(void), "");
+ static_assert(!__is_array(cvoid), "");
+ static_assert(!__is_array(float), "");
+ static_assert(!__is_array(double), "");
+ static_assert(!__is_array(long double), "");
+ static_assert(!__is_array(bool), "");
+ static_assert(!__is_array(char), "");
+ static_assert(!__is_array(signed char), "");
+ static_assert(!__is_array(unsigned char), "");
+ static_assert(!__is_array(wchar_t), "");
+ static_assert(!__is_array(short), "");
+ static_assert(!__is_array(unsigned short), "");
+ static_assert(!__is_array(int), "");
+ static_assert(!__is_array(unsigned int), "");
+ static_assert(!__is_array(long), "");
+ static_assert(!__is_array(unsigned long), "");
+ static_assert(!__is_array(Union), "");
+ static_assert(!__is_array(Derives), "");
+ static_assert(!__is_array(ClassType), "");
+ static_assert(!__is_array(Enum), "");
+ static_assert(!__is_array(void*), "");
+ static_assert(!__is_array(cvoid*), "");
}
void is_bounded_array(int n) {
@@ -817,152 +815,152 @@ template <typename T> struct type_wrapper {
void is_function()
{
- int t01[T(__is_function(type_wrapper<void(void)>::type))];
- int t02[T(__is_function(typeof(tmpl_func<int>)))];
+ static_assert(__is_function(type_wrapper<void(void)>::type), "");
+ static_assert(__is_function(typeof(tmpl_func<int>)), "");
typedef void (*ptr_to_func_type)(void);
- int t10[F(__is_function(void))];
- int t11[F(__is_function(cvoid))];
- int t12[F(__is_function(float))];
- int t13[F(__is_function(double))];
- int t14[F(__is_function(long double))];
- int t15[F(__is_function(bool))];
- int t16[F(__is_function(char))];
- int t17[F(__is_function(signed char))];
- int t18[F(__is_function(unsigned char))];
- int t19[F(__is_function(wchar_t))];
- int t20[F(__is_function(short))];
- int t21[F(__is_function(unsigned short))];
- int t22[F(__is_function(int))];
- int t23[F(__is_function(unsigned int))];
- int t24[F(__is_function(long))];
- int t25[F(__is_function(unsigned long))];
- int t26[F(__is_function(Union))];
- int t27[F(__is_function(Derives))];
- int t28[F(__is_function(ClassType))];
- int t29[F(__is_function(Enum))];
- int t30[F(__is_function(void*))];
- int t31[F(__is_function(cvoid*))];
- int t32[F(__is_function(void(*)()))];
- int t33[F(__is_function(ptr_to_func_type))];
- int t34[F(__is_function(type_wrapper<void(void)>::ptrtype))];
- int t35[F(__is_function(type_wrapper<void(void)>::reftype))];
+ static_assert(!__is_function(void), "");
+ static_assert(!__is_function(cvoid), "");
+ static_assert(!__is_function(float), "");
+ static_assert(!__is_function(double), "");
+ static_assert(!__is_function(long double), "");
+ static_assert(!__is_function(bool), "");
+ static_assert(!__is_function(char), "");
+ static_assert(!__is_function(signed char), "");
+ static_assert(!__is_function(unsigned char), "");
+ static_assert(!__is_function(wchar_t), "");
+ static_assert(!__is_function(short), "");
+ static_assert(!__is_function(unsigned short), "");
+ static_assert(!__is_function(int), "");
+ static_assert(!__is_function(unsigned int), "");
+ static_assert(!__is_function(long), "");
+ static_assert(!__is_function(unsigned long), "");
+ static_assert(!__is_function(Union), "");
+ static_assert(!__is_function(Derives), "");
+ static_assert(!__is_function(ClassType), "");
+ static_assert(!__is_function(Enum), "");
+ static_assert(!__is_function(void*), "");
+ static_assert(!__is_function(cvoid*), "");
+ static_assert(!__is_function(void(*)()), "");
+ static_assert(!__is_function(ptr_to_func_type), "");
+ static_assert(!__is_function(type_wrapper<void(void)>::ptrtype), "");
+ static_assert(!__is_function(type_wrapper<void(void)>::reftype), "");
}
void is_reference()
{
- int t01[T(__is_reference(int&))];
- int t02[T(__is_reference(const int&))];
- int t03[T(__is_reference(void *&))];
+ static_assert(__is_reference(int&), "");
+ static_assert(__is_reference(const int&), "");
+ static_assert(__is_reference(void *&), "");
- int t10[F(__is_reference(int))];
- int t11[F(__is_reference(const int))];
- int t12[F(__is_reference(void *))];
+ static_assert(!__is_reference(int), "");
+ static_assert(!__is_reference(const int), "");
+ static_assert(!__is_reference(void *), "");
}
void is_lvalue_reference()
{
- int t01[T(__is_lvalue_reference(int&))];
- int t02[T(__is_lvalue_reference(void *&))];
- int t03[T(__is_lvalue_reference(const int&))];
- int t04[T(__is_lvalue_reference(void * const &))];
-
- int t10[F(__is_lvalue_reference(int))];
- int t11[F(__is_lvalue_reference(const int))];
- int t12[F(__is_lvalue_reference(void *))];
+ static_assert(__is_lvalue_reference(int&), "");
+ static_assert(__is_lvalue_reference(void *&), "");
+ static_assert(__is_lvalue_reference(const int&), "");
+ static_assert(__is_lvalue_reference(void * const &), "");
+
+ static_assert(!__is_lvalue_reference(int), "");
+ static_assert(!__is_lvalue_reference(const int), "");
+ static_assert(!__is_lvalue_reference(void *), "");
}
#if __has_feature(cxx_rvalue_references)
void is_rvalue_reference()
{
- int t01[T(__is_rvalue_reference(const int&&))];
- int t02[T(__is_rvalue_reference(void * const &&))];
-
- int t10[F(__is_rvalue_reference(int&))];
- int t11[F(__is_rvalue_reference(void *&))];
- int t12[F(__is_rvalue_reference(const int&))];
- int t13[F(__is_rvalue_reference(void * const &))];
- int t14[F(__is_rvalue_reference(int))];
- int t15[F(__is_rvalue_reference(const int))];
- int t16[F(__is_rvalue_reference(void *))];
+ static_assert(__is_rvalue_reference(const int&&), "");
+ static_assert(__is_rvalue_reference(void * const &&), "");
+
+ static_assert(!__is_rvalue_reference(int&), "");
+ static_assert(!__is_rvalue_reference(void *&), "");
+ static_assert(!__is_rvalue_reference(const int&), "");
+ static_assert(!__is_rvalue_reference(void * const &), "");
+ static_assert(!__is_rvalue_reference(int), "");
+ static_assert(!__is_rvalue_reference(const int), "");
+ static_assert(!__is_rvalue_reference(void *), "");
}
#endif
void is_fundamental()
{
- int t01[T(__is_fundamental(float))];
- int t02[T(__is_fundamental(double))];
- int t03[T(__is_fundamental(long double))];
- int t11[T(__is_fundamental(bool))];
- int t12[T(__is_fundamental(char))];
- int t13[T(__is_fundamental(signed char))];
- int t14[T(__is_fundamental(unsigned char))];
- //int t15[T(__is_fundamental(char16_t))];
- //int t16[T(__is_fundamental(char32_t))];
- int t17[T(__is_fundamental(wchar_t))];
- int t18[T(__is_fundamental(short))];
- int t19[T(__is_fundamental(unsigned short))];
- int t20[T(__is_fundamental(int))];
- int t21[T(__is_fundamental(unsigned int))];
- int t22[T(__is_fundamental(long))];
- int t23[T(__is_fundamental(unsigned long))];
- int t24[T(__is_fundamental(void))];
- int t25[T(__is_fundamental(cvoid))];
- int t26[T(__is_fundamental(decltype(nullptr)))];
-
- int t30[F(__is_fundamental(Union))];
- int t31[F(__is_fundamental(UnionAr))];
- int t32[F(__is_fundamental(Derives))];
- int t33[F(__is_fundamental(ClassType))];
- int t34[F(__is_fundamental(Enum))];
- int t35[F(__is_fundamental(IntArNB))];
+ static_assert(__is_fundamental(float), "");
+ static_assert(__is_fundamental(double), "");
+ static_assert(__is_fundamental(long double), "");
+ static_assert(__is_fundamental(bool), "");
+ static_assert(__is_fundamental(char), "");
+ static_assert(__is_fundamental(signed char), "");
+ static_assert(__is_fundamental(unsigned char), "");
+ //static_assert(__is_fundamental(char16_t), "");
+ //static_assert(__is_fundamental(char32_t), "");
+ static_assert(__is_fundamental(wchar_t), "");
+ static_assert(__is_fundamental(short), "");
+ static_assert(__is_fundamental(unsigned short), "");
+ static_assert(__is_fundamental(int), "");
+ static_assert(__is_fundamental(unsigned int), "");
+ static_assert(__is_fundamental(long), "");
+ static_assert(__is_fundamental(unsigned long), "");
+ static_assert(__is_fundamental(void), "");
+ static_assert(__is_fundamental(cvoid), "");
+ static_assert(__is_fundamental(decltype(nullptr)), "");
+
+ static_assert(!__is_fundamental(Union), "");
+ static_assert(!__is_fundamental(UnionAr), "");
+ static_assert(!__is_fundamental(Derives), "");
+ static_assert(!__is_fundamental(ClassType), "");
+ static_assert(!__is_fundamental(Enum), "");
+ static_assert(!__is_fundamental(IntArNB), "");
}
void is_object()
{
- int t01[T(__is_object(int))];
- int t02[T(__is_object(int *))];
- int t03[T(__is_object(void *))];
- int t04[T(__is_object(Union))];
- int t05[T(__is_object(UnionAr))];
- int t06[T(__is_object(ClassType))];
- int t07[T(__is_object(Enum))];
-
- int t10[F(__is_object(type_wrapper<void(void)>::type))];
- int t11[F(__is_object(int&))];
- int t12[F(__is_object(void))];
+ static_assert(__is_object(int), "");
+ static_assert(__is_object(int *), "");
+ static_assert(__is_object(void *), "");
+ static_assert(__is_object(Union), "");
+ static_assert(__is_object(UnionAr), "");
+ static_assert(__is_object(ClassType), "");
+ static_assert(__is_object(Enum), "");
+
+ static_assert(!__is_object(type_wrapper<void(void)>::type), "");
+ static_assert(!__is_object(int&), "");
+ static_assert(!__is_object(void), "");
}
void is_scalar()
{
- int t01[T(__is_scalar(float))];
- int t02[T(__is_scalar(double))];
- int t03[T(__is_scalar(long double))];
- int t04[T(__is_scalar(bool))];
- int t05[T(__is_scalar(char))];
- int t06[T(__is_scalar(signed char))];
- int t07[T(__is_scalar(unsigned char))];
- int t08[T(__is_scalar(wchar_t))];
- int t09[T(__is_scalar(short))];
- int t10[T(__is_scalar(unsigned short))];
- int t11[T(__is_scalar(int))];
- int t12[T(__is_scalar(unsigned int))];
- int t13[T(__is_scalar(long))];
- int t14[T(__is_scalar(unsigned long))];
- int t15[T(__is_scalar(Enum))];
- int t16[T(__is_scalar(void*))];
- int t17[T(__is_scalar(cvoid*))];
-
- int t20[F(__is_scalar(void))];
- int t21[F(__is_scalar(cvoid))];
- int t22[F(__is_scalar(Union))];
- int t23[F(__is_scalar(UnionAr))];
- int t24[F(__is_scalar(Derives))];
- int t25[F(__is_scalar(ClassType))];
- int t26[F(__is_scalar(IntArNB))];
+ static_assert(__is_scalar(float), "");
+ static_assert(__is_scalar(double), "");
+ static_assert(__is_scalar(long double), "");
+ static_assert(__is_scalar(bool), "");
+ static_assert(__is_scalar(char), "");
+ static_assert(__is_scalar(signed char), "");
+ static_assert(__is_scalar(unsigned char), "");
+ static_assert(__is_scalar(wchar_t), "");
+ static_assert(__is_scalar(short), "");
+ static_assert(__is_scalar(unsigned short), "");
+ static_assert(__is_scalar(int), "");
+ static_assert(__is_scalar(unsigned int), "");
+ static_assert(__is_scalar(long), "");
+ static_assert(__is_scalar(unsigned long), "");
+ static_assert(__is_scalar(Enum), "");
+ static_assert(__is_scalar(void*), "");
+ static_assert(__is_scalar(cvoid*), "");
+
+ static_assert(!__is_scalar(void), "");
+ static_assert(!__is_scalar(cvoid), "");
+ static_assert(!__is_scalar(Union), "");
+ static_assert(!__is_scalar(UnionAr), "");
+ static_assert(!__is_scalar(Derives), "");
+ static_assert(!__is_scalar(ClassType), "");
+ static_assert(!__is_scalar(IntArNB), "");
}
struct StructWithMembers {
@@ -972,71 +970,71 @@ struct StructWithMembers {
void is_compound()
{
- int t01[T(__is_compound(void*))];
- int t02[T(__is_compound(cvoid*))];
- int t03[T(__is_compound(void (*)()))];
- int t04[T(__is_compound(int StructWithMembers::*))];
- int t05[T(__is_compound(void (StructWithMembers::*)()))];
- int t06[T(__is_compound(int&))];
- int t07[T(__is_compound(Union))];
- int t08[T(__is_compound(UnionAr))];
- int t09[T(__is_compound(Derives))];
- int t10[T(__is_compound(ClassType))];
- int t11[T(__is_compound(IntArNB))];
- int t12[T(__is_compound(Enum))];
-
- int t20[F(__is_compound(float))];
- int t21[F(__is_compound(double))];
- int t22[F(__is_compound(long double))];
- int t23[F(__is_compound(bool))];
- int t24[F(__is_compound(char))];
- int t25[F(__is_compound(signed char))];
- int t26[F(__is_compound(unsigned char))];
- int t27[F(__is_compound(wchar_t))];
- int t28[F(__is_compound(short))];
- int t29[F(__is_compound(unsigned short))];
- int t30[F(__is_compound(int))];
- int t31[F(__is_compound(unsigned int))];
- int t32[F(__is_compound(long))];
- int t33[F(__is_compound(unsigned long))];
- int t34[F(__is_compound(void))];
- int t35[F(__is_compound(cvoid))];
+ static_assert(__is_compound(void*), "");
+ static_assert(__is_compound(cvoid*), "");
+ static_assert(__is_compound(void (*)()), "");
+ static_assert(__is_compound(int StructWithMembers::*), "");
+ static_assert(__is_compound(void (StructWithMembers::*)()), "");
+ static_assert(__is_compound(int&), "");
+ static_assert(__is_compound(Union), "");
+ static_assert(__is_compound(UnionAr), "");
+ static_assert(__is_compound(Derives), "");
+ static_assert(__is_compound(ClassType), "");
+ static_assert(__is_compound(IntArNB), "");
+ static_assert(__is_compound(Enum), "");
+
+ static_assert(!__is_compound(float), "");
+ static_assert(!__is_compound(double), "");
+ static_assert(!__is_compound(long double), "");
+ static_assert(!__is_compound(bool), "");
+ static_assert(!__is_compound(char), "");
+ static_assert(!__is_compound(signed char), "");
+ static_assert(!__is_compound(unsigned char), "");
+ static_assert(!__is_compound(wchar_t), "");
+ static_assert(!__is_compound(short), "");
+ static_assert(!__is_compound(unsigned short), "");
+ static_assert(!__is_compound(int), "");
+ static_assert(!__is_compound(unsigned int), "");
+ static_assert(!__is_compound(long), "");
+ static_assert(!__is_compound(unsigned long), "");
+ static_assert(!__is_compound(void), "");
+ static_assert(!__is_compound(cvoid), "");
}
void is_pointer()
{
StructWithMembers x;
- int t01[T(__is_pointer(void*))];
- int t02[T(__is_pointer(cvoid*))];
- int t03[T(__is_pointer(cvoid*))];
- int t04[T(__is_pointer(char*))];
- int t05[T(__is_pointer(int*))];
- int t06[T(__is_pointer(int**))];
- int t07[T(__is_pointer(ClassType*))];
- int t08[T(__is_pointer(Derives*))];
- int t09[T(__is_pointer(Enum*))];
- int t10[T(__is_pointer(IntArNB*))];
- int t11[T(__is_pointer(Union*))];
- int t12[T(__is_pointer(UnionAr*))];
- int t13[T(__is_pointer(StructWithMembers*))];
- int t14[T(__is_pointer(void (*)()))];
-
- int t20[F(__is_pointer(void))];
- int t21[F(__is_pointer(cvoid))];
- int t22[F(__is_pointer(cvoid))];
- int t23[F(__is_pointer(char))];
- int t24[F(__is_pointer(int))];
- int t25[F(__is_pointer(int))];
- int t26[F(__is_pointer(ClassType))];
- int t27[F(__is_pointer(Derives))];
- int t28[F(__is_pointer(Enum))];
- int t29[F(__is_pointer(IntArNB))];
- int t30[F(__is_pointer(Union))];
- int t31[F(__is_pointer(UnionAr))];
- int t32[F(__is_pointer(StructWithMembers))];
- int t33[F(__is_pointer(int StructWithMembers::*))];
- int t34[F(__is_pointer(void (StructWithMembers::*) ()))];
+ static_assert(__is_pointer(void*), "");
+ static_assert(__is_pointer(cvoid*), "");
+ static_assert(__is_pointer(cvoid*), "");
+ static_assert(__is_pointer(char*), "");
+ static_assert(__is_pointer(int*), "");
+ static_assert(__is_pointer(int**), "");
+ static_assert(__is_pointer(ClassType*), "");
+ static_assert(__is_pointer(Derives*), "");
+ static_assert(__is_pointer(Enum*), "");
+ static_assert(__is_pointer(IntArNB*), "");
+ static_assert(__is_pointer(Union*), "");
+ static_assert(__is_pointer(UnionAr*), "");
+ static_assert(__is_pointer(StructWithMembers*), "");
+ static_assert(__is_pointer(void (*)()), "");
+
+ static_assert(!__is_pointer(void), "");
+ static_assert(!__is_pointer(cvoid), "");
+ static_assert(!__is_pointer(cvoid), "");
+ static_assert(!__is_pointer(char), "");
+ static_assert(!__is_pointer(int), "");
+ static_assert(!__is_pointer(int), "");
+ static_assert(!__is_pointer(ClassType), "");
+ static_assert(!__is_pointer(Derives), "");
+ static_assert(!__is_pointer(Enum), "");
+ static_assert(!__is_pointer(IntArNB), "");
+ static_assert(!__is_pointer(Union), "");
+ static_assert(!__is_pointer(UnionAr), "");
+ static_assert(!__is_pointer(StructWithMembers), "");
+ static_assert(!__is_pointer(int StructWithMembers::*), "");
+ static_assert(!__is_pointer(void (StructWithMembers::*) ()), "");
}
void is_null_pointer() {
@@ -1079,207 +1077,207 @@ void is_member_object_pointer()
{
StructWithMembers x;
- int t01[T(__is_member_object_pointer(int StructWithMembers::*))];
-
- int t10[F(__is_member_object_pointer(void (StructWithMembers::*) ()))];
- int t11[F(__is_member_object_pointer(void*))];
- int t12[F(__is_member_object_pointer(cvoid*))];
- int t13[F(__is_member_object_pointer(cvoid*))];
- int t14[F(__is_member_object_pointer(char*))];
- int t15[F(__is_member_object_pointer(int*))];
- int t16[F(__is_member_object_pointer(int**))];
- int t17[F(__is_member_object_pointer(ClassType*))];
- int t18[F(__is_member_object_pointer(Derives*))];
- int t19[F(__is_member_object_pointer(Enum*))];
- int t20[F(__is_member_object_pointer(IntArNB*))];
- int t21[F(__is_member_object_pointer(Union*))];
- int t22[F(__is_member_object_pointer(UnionAr*))];
- int t23[F(__is_member_object_pointer(StructWithMembers*))];
- int t24[F(__is_member_object_pointer(void))];
- int t25[F(__is_member_object_pointer(cvoid))];
- int t26[F(__is_member_object_pointer(cvoid))];
- int t27[F(__is_member_object_pointer(char))];
- int t28[F(__is_member_object_pointer(int))];
- int t29[F(__is_member_object_pointer(int))];
- int t30[F(__is_member_object_pointer(ClassType))];
- int t31[F(__is_member_object_pointer(Derives))];
- int t32[F(__is_member_object_pointer(Enum))];
- int t33[F(__is_member_object_pointer(IntArNB))];
- int t34[F(__is_member_object_pointer(Union))];
- int t35[F(__is_member_object_pointer(UnionAr))];
- int t36[F(__is_member_object_pointer(StructWithMembers))];
- int t37[F(__is_member_object_pointer(void (*)()))];
+ static_assert(__is_member_object_pointer(int StructWithMembers::*), "");
+
+ static_assert(!__is_member_object_pointer(void (StructWithMembers::*) ()), "");
+ static_assert(!__is_member_object_pointer(void*), "");
+ static_assert(!__is_member_object_pointer(cvoid*), "");
+ static_assert(!__is_member_object_pointer(cvoid*), "");
+ static_assert(!__is_member_object_pointer(char*), "");
+ static_assert(!__is_member_object_pointer(int*), "");
+ static_assert(!__is_member_object_pointer(int**), "");
+ static_assert(!__is_member_object_pointer(ClassType*), "");
+ static_assert(!__is_member_object_pointer(Derives*), "");
+ static_assert(!__is_member_object_pointer(Enum*), "");
+ static_assert(!__is_member_object_pointer(IntArNB*), "");
+ static_assert(!__is_member_object_pointer(Union*), "");
+ static_assert(!__is_member_object_pointer(UnionAr*), "");
+ static_assert(!__is_member_object_pointer(StructWithMembers*), "");
+ static_assert(!__is_member_object_pointer(void), "");
+ static_assert(!__is_member_object_pointer(cvoid), "");
+ static_assert(!__is_member_object_pointer(cvoid), "");
+ static_assert(!__is_member_object_pointer(char), "");
+ static_assert(!__is_member_object_pointer(int), "");
+ static_assert(!__is_member_object_pointer(int), "");
+ static_assert(!__is_member_object_pointer(ClassType), "");
+ static_assert(!__is_member_object_pointer(Derives), "");
+ static_assert(!__is_member_object_pointer(Enum), "");
+ static_assert(!__is_member_object_pointer(IntArNB), "");
+ static_assert(!__is_member_object_pointer(Union), "");
+ static_assert(!__is_member_object_pointer(UnionAr), "");
+ static_assert(!__is_member_object_pointer(StructWithMembers), "");
+ static_assert(!__is_member_object_pointer(void (*)()), "");
}
void is_member_function_pointer()
{
StructWithMembers x;
- int t01[T(__is_member_function_pointer(void (StructWithMembers::*) ()))];
-
- int t10[F(__is_member_function_pointer(int StructWithMembers::*))];
- int t11[F(__is_member_function_pointer(void*))];
- int t12[F(__is_member_function_pointer(cvoid*))];
- int t13[F(__is_member_function_pointer(cvoid*))];
- int t14[F(__is_member_function_pointer(char*))];
- int t15[F(__is_member_function_pointer(int*))];
- int t16[F(__is_member_function_pointer(int**))];
- int t17[F(__is_member_function_pointer(ClassType*))];
- int t18[F(__is_member_function_pointer(Derives*))];
- int t19[F(__is_member_function_pointer(Enum*))];
- int t20[F(__is_member_function_pointer(IntArNB*))];
- int t21[F(__is_member_function_pointer(Union*))];
- int t22[F(__is_member_function_pointer(UnionAr*))];
- int t23[F(__is_member_function_pointer(StructWithMembers*))];
- int t24[F(__is_member_function_pointer(void))];
- int t25[F(__is_member_function_pointer(cvoid))];
- int t26[F(__is_member_function_pointer(cvoid))];
- int t27[F(__is_member_function_pointer(char))];
- int t28[F(__is_member_function_pointer(int))];
- int t29[F(__is_member_function_pointer(int))];
- int t30[F(__is_member_function_pointer(ClassType))];
- int t31[F(__is_member_function_pointer(Derives))];
- int t32[F(__is_member_function_pointer(Enum))];
- int t33[F(__is_member_function_pointer(IntArNB))];
- int t34[F(__is_member_function_pointer(Union))];
- int t35[F(__is_member_function_pointer(UnionAr))];
- int t36[F(__is_member_function_pointer(StructWithMembers))];
- int t37[F(__is_member_function_pointer(void (*)()))];
+ static_assert(__is_member_function_pointer(void (StructWithMembers::*) ()), "");
+
+ static_assert(!__is_member_function_pointer(int StructWithMembers::*), "");
+ static_assert(!__is_member_function_pointer(void*), "");
+ static_assert(!__is_member_function_pointer(cvoid*), "");
+ static_assert(!__is_member_function_pointer(cvoid*), "");
+ static_assert(!__is_member_function_pointer(char*), "");
+ static_assert(!__is_member_function_pointer(int*), "");
+ static_assert(!__is_member_function_pointer(int**), "");
+ static_assert(!__is_member_function_pointer(ClassType*), "");
+ static_assert(!__is_member_function_pointer(Derives*), "");
+ static_assert(!__is_member_function_pointer(Enum*), "");
+ static_assert(!__is_member_function_pointer(IntArNB*), "");
+ static_assert(!__is_member_function_pointer(Union*), "");
+ static_assert(!__is_member_function_pointer(UnionAr*), "");
+ static_assert(!__is_member_function_pointer(StructWithMembers*), "");
+ static_assert(!__is_member_function_pointer(void), "");
+ static_assert(!__is_member_function_pointer(cvoid), "");
+ static_assert(!__is_member_function_pointer(cvoid), "");
+ static_assert(!__is_member_function_pointer(char), "");
+ static_assert(!__is_member_function_pointer(int), "");
+ static_assert(!__is_member_function_pointer(int), "");
+ static_assert(!__is_member_function_pointer(ClassType), "");
+ static_assert(!__is_member_function_pointer(Derives), "");
+ static_assert(!__is_member_function_pointer(Enum), "");
+ static_assert(!__is_member_function_pointer(IntArNB), "");
+ static_assert(!__is_member_function_pointer(Union), "");
+ static_assert(!__is_member_function_pointer(UnionAr), "");
+ static_assert(!__is_member_function_pointer(StructWithMembers), "");
+ static_assert(!__is_member_function_pointer(void (*)()), "");
}
void is_member_pointer()
{
StructWithMembers x;
- int t01[T(__is_member_pointer(int StructWithMembers::*))];
- int t02[T(__is_member_pointer(void (StructWithMembers::*) ()))];
-
- int t10[F(__is_member_pointer(void*))];
- int t11[F(__is_member_pointer(cvoid*))];
- int t12[F(__is_member_pointer(cvoid*))];
- int t13[F(__is_member_pointer(char*))];
- int t14[F(__is_member_pointer(int*))];
- int t15[F(__is_member_pointer(int**))];
- int t16[F(__is_member_pointer(ClassType*))];
- int t17[F(__is_member_pointer(Derives*))];
- int t18[F(__is_member_pointer(Enum*))];
- int t19[F(__is_member_pointer(IntArNB*))];
- int t20[F(__is_member_pointer(Union*))];
- int t21[F(__is_member_pointer(UnionAr*))];
- int t22[F(__is_member_pointer(StructWithMembers*))];
- int t23[F(__is_member_pointer(void))];
- int t24[F(__is_member_pointer(cvoid))];
- int t25[F(__is_member_pointer(cvoid))];
- int t26[F(__is_member_pointer(char))];
- int t27[F(__is_member_pointer(int))];
- int t28[F(__is_member_pointer(int))];
- int t29[F(__is_member_pointer(ClassType))];
- int t30[F(__is_member_pointer(Derives))];
- int t31[F(__is_member_pointer(Enum))];
- int t32[F(__is_member_pointer(IntArNB))];
- int t33[F(__is_member_pointer(Union))];
- int t34[F(__is_member_pointer(UnionAr))];
- int t35[F(__is_member_pointer(StructWithMembers))];
- int t36[F(__is_member_pointer(void (*)()))];
+ static_assert(__is_member_pointer(int StructWithMembers::*), "");
+ static_assert(__is_member_pointer(void (StructWithMembers::*) ()), "");
+
+ static_assert(!__is_member_pointer(void*), "");
+ static_assert(!__is_member_pointer(cvoid*), "");
+ static_assert(!__is_member_pointer(cvoid*), "");
+ static_assert(!__is_member_pointer(char*), "");
+ static_assert(!__is_member_pointer(int*), "");
+ static_assert(!__is_member_pointer(int**), "");
+ static_assert(!__is_member_pointer(ClassType*), "");
+ static_assert(!__is_member_pointer(Derives*), "");
+ static_assert(!__is_member_pointer(Enum*), "");
+ static_assert(!__is_member_pointer(IntArNB*), "");
+ static_assert(!__is_member_pointer(Union*), "");
+ static_assert(!__is_member_pointer(UnionAr*), "");
+ static_assert(!__is_member_pointer(StructWithMembers*), "");
+ static_assert(!__is_member_pointer(void), "");
+ static_assert(!__is_member_pointer(cvoid), "");
+ static_assert(!__is_member_pointer(cvoid), "");
+ static_assert(!__is_member_pointer(char), "");
+ static_assert(!__is_member_pointer(int), "");
+ static_assert(!__is_member_pointer(int), "");
+ static_assert(!__is_member_pointer(ClassType), "");
+ static_assert(!__is_member_pointer(Derives), "");
+ static_assert(!__is_member_pointer(Enum), "");
+ static_assert(!__is_member_pointer(IntArNB), "");
+ static_assert(!__is_member_pointer(Union), "");
+ static_assert(!__is_member_pointer(UnionAr), "");
+ static_assert(!__is_member_pointer(StructWithMembers), "");
+ static_assert(!__is_member_pointer(void (*)()), "");
}
void is_const()
{
- int t01[T(__is_const(cvoid))];
- int t02[T(__is_const(const char))];
- int t03[T(__is_const(const int))];
- int t04[T(__is_const(const long))];
- int t05[T(__is_const(const short))];
- int t06[T(__is_const(const signed char))];
- int t07[T(__is_const(const wchar_t))];
- int t08[T(__is_const(const bool))];
- int t09[T(__is_const(const float))];
- int t10[T(__is_const(const double))];
- int t11[T(__is_const(const long double))];
- int t12[T(__is_const(const unsigned char))];
- int t13[T(__is_const(const unsigned int))];
- int t14[T(__is_const(const unsigned long long))];
- int t15[T(__is_const(const unsigned long))];
- int t16[T(__is_const(const unsigned short))];
- int t17[T(__is_const(const void))];
- int t18[T(__is_const(const ClassType))];
- int t19[T(__is_const(const Derives))];
- int t20[T(__is_const(const Enum))];
- int t21[T(__is_const(const IntArNB))];
- int t22[T(__is_const(const Union))];
- int t23[T(__is_const(const UnionAr))];
-
- int t30[F(__is_const(char))];
- int t31[F(__is_const(int))];
- int t32[F(__is_const(long))];
- int t33[F(__is_const(short))];
- int t34[F(__is_const(signed char))];
- int t35[F(__is_const(wchar_t))];
- int t36[F(__is_const(bool))];
- int t37[F(__is_const(float))];
- int t38[F(__is_const(double))];
- int t39[F(__is_const(long double))];
- int t40[F(__is_const(unsigned char))];
- int t41[F(__is_const(unsigned int))];
- int t42[F(__is_const(unsigned long long))];
- int t43[F(__is_const(unsigned long))];
- int t44[F(__is_const(unsigned short))];
- int t45[F(__is_const(void))];
- int t46[F(__is_const(ClassType))];
- int t47[F(__is_const(Derives))];
- int t48[F(__is_const(Enum))];
- int t49[F(__is_const(IntArNB))];
- int t50[F(__is_const(Union))];
- int t51[F(__is_const(UnionAr))];
+ static_assert(__is_const(cvoid), "");
+ static_assert(__is_const(const char), "");
+ static_assert(__is_const(const int), "");
+ static_assert(__is_const(const long), "");
+ static_assert(__is_const(const short), "");
+ static_assert(__is_const(const signed char), "");
+ static_assert(__is_const(const wchar_t), "");
+ static_assert(__is_const(const bool), "");
+ static_assert(__is_const(const float), "");
+ static_assert(__is_const(const double), "");
+ static_assert(__is_const(const long double), "");
+ static_assert(__is_const(const unsigned char), "");
+ static_assert(__is_const(const unsigned int), "");
+ static_assert(__is_const(const unsigned long long), "");
+ static_assert(__is_const(const unsigned long), "");
+ static_assert(__is_const(const unsigned short), "");
+ static_assert(__is_const(const void), "");
+ static_assert(__is_const(const ClassType), "");
+ static_assert(__is_const(const Derives), "");
+ static_assert(__is_const(const Enum), "");
+ static_assert(__is_const(const IntArNB), "");
+ static_assert(__is_const(const Union), "");
+ static_assert(__is_const(const UnionAr), "");
+
+ static_assert(!__is_const(char), "");
+ static_assert(!__is_const(int), "");
+ static_assert(!__is_const(long), "");
+ static_assert(!__is_const(short), "");
+ static_assert(!__is_const(signed char), "");
+ static_assert(!__is_const(wchar_t), "");
+ static_assert(!__is_const(bool), "");
+ static_assert(!__is_const(float), "");
+ static_assert(!__is_const(double), "");
+ static_assert(!__is_const(long double), "");
+ static_assert(!__is_const(unsigned char), "");
+ static_assert(!__is_const(unsigned int), "");
+ static_assert(!__is_const(unsigned long long), "");
+ static_assert(!__is_const(unsigned long), "");
+ static_assert(!__is_const(unsigned short), "");
+ static_assert(!__is_const(void), "");
+ static_assert(!__is_const(ClassType), "");
+ static_assert(!__is_const(Derives), "");
+ static_assert(!__is_const(Enum), "");
+ static_assert(!__is_const(IntArNB), "");
+ static_assert(!__is_const(Union), "");
+ static_assert(!__is_const(UnionAr), "");
}
void is_volatile()
{
- int t02[T(__is_volatile(volatile char))];
- int t03[T(__is_volatile(volatile int))];
- int t04[T(__is_volatile(volatile long))];
- int t05[T(__is_volatile(volatile short))];
- int t06[T(__is_volatile(volatile signed char))];
- int t07[T(__is_volatile(volatile wchar_t))];
- int t08[T(__is_volatile(volatile bool))];
- int t09[T(__is_volatile(volatile float))];
- int t10[T(__is_volatile(volatile double))];
- int t11[T(__is_volatile(volatile long double))];
- int t12[T(__is_volatile(volatile unsigned char))];
- int t13[T(__is_volatile(volatile unsigned int))];
- int t14[T(__is_volatile(volatile unsigned long long))];
- int t15[T(__is_volatile(volatile unsigned long))];
- int t16[T(__is_volatile(volatile unsigned short))];
- int t17[T(__is_volatile(volatile void))];
- int t18[T(__is_volatile(volatile ClassType))];
- int t19[T(__is_volatile(volatile Derives))];
- int t20[T(__is_volatile(volatile Enum))];
- int t21[T(__is_volatile(volatile IntArNB))];
- int t22[T(__is_volatile(volatile Union))];
- int t23[T(__is_volatile(volatile UnionAr))];
-
- int t30[F(__is_volatile(char))];
- int t31[F(__is_volatile(int))];
- int t32[F(__is_volatile(long))];
- int t33[F(__is_volatile(short))];
- int t34[F(__is_volatile(signed char))];
- int t35[F(__is_volatile(wchar_t))];
- int t36[F(__is_volatile(bool))];
- int t37[F(__is_volatile(float))];
- int t38[F(__is_volatile(double))];
- int t39[F(__is_volatile(long double))];
- int t40[F(__is_volatile(unsigned char))];
- int t41[F(__is_volatile(unsigned int))];
- int t42[F(__is_volatile(unsigned long long))];
- int t43[F(__is_volatile(unsigned long))];
- int t44[F(__is_volatile(unsigned short))];
- int t45[F(__is_volatile(void))];
- int t46[F(__is_volatile(ClassType))];
- int t47[F(__is_volatile(Derives))];
- int t48[F(__is_volatile(Enum))];
- int t49[F(__is_volatile(IntArNB))];
- int t50[F(__is_volatile(Union))];
- int t51[F(__is_volatile(UnionAr))];
+ static_assert(__is_volatile(volatile char), "");
+ static_assert(__is_volatile(volatile int), "");
+ static_assert(__is_volatile(volatile long), "");
+ static_assert(__is_volatile(volatile short), "");
+ static_assert(__is_volatile(volatile signed char), "");
+ static_assert(__is_volatile(volatile wchar_t), "");
+ static_assert(__is_volatile(volatile bool), "");
+ static_assert(__is_volatile(volatile float), "");
+ static_assert(__is_volatile(volatile double), "");
+ static_assert(__is_volatile(volatile long double), "");
+ static_assert(__is_volatile(volatile unsigned char), "");
+ static_assert(__is_volatile(volatile unsigned int), "");
+ static_assert(__is_volatile(volatile unsigned long long), "");
+ static_assert(__is_volatile(volatile unsigned long), "");
+ static_assert(__is_volatile(volatile unsigned short), "");
+ static_assert(__is_volatile(volatile void), "");
+ static_assert(__is_volatile(volatile ClassType), "");
+ static_assert(__is_volatile(volatile Derives), "");
+ static_assert(__is_volatile(volatile Enum), "");
+ static_assert(__is_volatile(volatile IntArNB), "");
+ static_assert(__is_volatile(volatile Union), "");
+ static_assert(__is_volatile(volatile UnionAr), "");
+
+ static_assert(!__is_volatile(char), "");
+ static_assert(!__is_volatile(int), "");
+ static_assert(!__is_volatile(long), "");
+ static_assert(!__is_volatile(short), "");
+ static_assert(!__is_volatile(signed char), "");
+ static_assert(!__is_volatile(wchar_t), "");
+ static_assert(!__is_volatile(bool), "");
+ static_assert(!__is_volatile(float), "");
+ static_assert(!__is_volatile(double), "");
+ static_assert(!__is_volatile(long double), "");
+ static_assert(!__is_volatile(unsigned char), "");
+ static_assert(!__is_volatile(unsigned int), "");
+ static_assert(!__is_volatile(unsigned long long), "");
+ static_assert(!__is_volatile(unsigned long), "");
+ static_assert(!__is_volatile(unsigned short), "");
+ static_assert(!__is_volatile(void), "");
+ static_assert(!__is_volatile(ClassType), "");
+ static_assert(!__is_volatile(Derives), "");
+ static_assert(!__is_volatile(Enum), "");
+ static_assert(!__is_volatile(IntArNB), "");
+ static_assert(!__is_volatile(Union), "");
+ static_assert(!__is_volatile(UnionAr), "");
}
struct TrivialStruct {
@@ -1352,87 +1350,87 @@ ExtDefaulted::~ExtDefaulted() = default;
void is_trivial2()
{
- int t01[T(__is_trivial(char))];
- int t02[T(__is_trivial(int))];
- int t03[T(__is_trivial(long))];
- int t04[T(__is_trivial(short))];
- int t05[T(__is_trivial(signed char))];
- int t06[T(__is_trivial(wchar_t))];
- int t07[T(__is_trivial(bool))];
- int t08[T(__is_trivial(float))];
- int t09[T(__is_trivial(double))];
- int t10[T(__is_trivial(long double))];
- int t11[T(__is_trivial(unsigned char))];
- int t12[T(__is_trivial(unsigned int))];
- int t13[T(__is_trivial(unsigned long long))];
- int t14[T(__is_trivial(unsigned long))];
- int t15[T(__is_trivial(unsigned short))];
- int t16[T(__is_trivial(ClassType))];
- int t17[T(__is_trivial(Derives))];
- int t18[T(__is_trivial(Enum))];
- int t19[T(__is_trivial(IntAr))];
- int t20[T(__is_trivial(Union))];
- int t21[T(__is_trivial(UnionAr))];
- int t22[T(__is_trivial(TrivialStruct))];
- int t23[T(__is_trivial(AllDefaulted))];
- int t24[T(__is_trivial(AllDeleted))];
-
- int t30[F(__is_trivial(void))];
- int t31[F(__is_trivial(NonTrivialStruct))];
- int t32[F(__is_trivial(SuperNonTrivialStruct))];
- int t33[F(__is_trivial(NonTCStruct))];
- int t34[F(__is_trivial(ExtDefaulted))];
-
- int t40[T(__is_trivial(ACompleteType))];
- int t41[F(__is_trivial(AnIncompleteType))]; // expected-error {{incomplete type}}
- int t42[F(__is_trivial(AnIncompleteType[]))]; // expected-error {{incomplete type}}
- int t43[F(__is_trivial(AnIncompleteType[1]))]; // expected-error {{incomplete type}}
- int t44[F(__is_trivial(void))];
- int t45[F(__is_trivial(const volatile void))];
+ static_assert(__is_trivial(char), "");
+ static_assert(__is_trivial(int), "");
+ static_assert(__is_trivial(long), "");
+ static_assert(__is_trivial(short), "");
+ static_assert(__is_trivial(signed char), "");
+ static_assert(__is_trivial(wchar_t), "");
+ static_assert(__is_trivial(bool), "");
+ static_assert(__is_trivial(float), "");
+ static_assert(__is_trivial(double), "");
+ static_assert(__is_trivial(long double), "");
+ static_assert(__is_trivial(unsigned char), "");
+ static_assert(__is_trivial(unsigned int), "");
+ static_assert(__is_trivial(unsigned long long), "");
+ static_assert(__is_trivial(unsigned long), "");
+ static_assert(__is_trivial(unsigned short), "");
+ static_assert(__is_trivial(ClassType), "");
+ static_assert(__is_trivial(Derives), "");
+ static_assert(__is_trivial(Enum), "");
+ static_assert(__is_trivial(IntAr), "");
+ static_assert(__is_trivial(Union), "");
+ static_assert(__is_trivial(UnionAr), "");
+ static_assert(__is_trivial(TrivialStruct), "");
+ static_assert(__is_trivial(AllDefaulted), "");
+ static_assert(__is_trivial(AllDeleted), "");
+
+ static_assert(!__is_trivial(void), "");
+ static_assert(!__is_trivial(NonTrivialStruct), "");
+ static_assert(!__is_trivial(SuperNonTrivialStruct), "");
+ static_assert(!__is_trivial(NonTCStruct), "");
+ static_assert(!__is_trivial(ExtDefaulted), "");
+
+ static_assert(__is_trivial(ACompleteType), "");
+ static_assert(!__is_trivial(AnIncompleteType), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_trivial(AnIncompleteType[]), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_trivial(AnIncompleteType[1]), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_trivial(void), "");
+ static_assert(!__is_trivial(const volatile void), "");
}
void is_trivially_copyable2()
{
- int t01[T(__is_trivially_copyable(char))];
- int t02[T(__is_trivially_copyable(int))];
- int t03[T(__is_trivially_copyable(long))];
- int t04[T(__is_trivially_copyable(short))];
- int t05[T(__is_trivially_copyable(signed char))];
- int t06[T(__is_trivially_copyable(wchar_t))];
- int t07[T(__is_trivially_copyable(bool))];
- int t08[T(__is_trivially_copyable(float))];
- int t09[T(__is_trivially_copyable(double))];
- int t10[T(__is_trivially_copyable(long double))];
- int t11[T(__is_trivially_copyable(unsigned char))];
- int t12[T(__is_trivially_copyable(unsigned int))];
- int t13[T(__is_trivially_copyable(unsigned long long))];
- int t14[T(__is_trivially_copyable(unsigned long))];
- int t15[T(__is_trivially_copyable(unsigned short))];
- int t16[T(__is_trivially_copyable(ClassType))];
- int t17[T(__is_trivially_copyable(Derives))];
- int t18[T(__is_trivially_copyable(Enum))];
- int t19[T(__is_trivially_copyable(IntAr))];
- int t20[T(__is_trivially_copyable(Union))];
- int t21[T(__is_trivially_copyable(UnionAr))];
- int t22[T(__is_trivially_copyable(TrivialStruct))];
- int t23[T(__is_trivially_copyable(NonTrivialStruct))];
- int t24[T(__is_trivially_copyable(AllDefaulted))];
- int t25[T(__is_trivially_copyable(AllDeleted))];
-
- int t30[F(__is_trivially_copyable(void))];
- int t31[F(__is_trivially_copyable(SuperNonTrivialStruct))];
- int t32[F(__is_trivially_copyable(NonTCStruct))];
- int t33[F(__is_trivially_copyable(ExtDefaulted))];
-
- int t34[T(__is_trivially_copyable(const int))];
- int t35[T(__is_trivially_copyable(volatile int))];
-
- int t40[T(__is_trivially_copyable(ACompleteType))];
- int t41[F(__is_trivially_copyable(AnIncompleteType))]; // expected-error {{incomplete type}}
- int t42[F(__is_trivially_copyable(AnIncompleteType[]))]; // expected-error {{incomplete type}}
- int t43[F(__is_trivially_copyable(AnIncompleteType[1]))]; // expected-error {{incomplete type}}
- int t44[F(__is_trivially_copyable(void))];
- int t45[F(__is_trivially_copyable(const volatile void))];
+ static_assert(__is_trivially_copyable(char), "");
+ static_assert(__is_trivially_copyable(int), "");
+ static_assert(__is_trivially_copyable(long), "");
+ static_assert(__is_trivially_copyable(short), "");
+ static_assert(__is_trivially_copyable(signed char), "");
+ static_assert(__is_trivially_copyable(wchar_t), "");
+ static_assert(__is_trivially_copyable(bool), "");
+ static_assert(__is_trivially_copyable(float), "");
+ static_assert(__is_trivially_copyable(double), "");
+ static_assert(__is_trivially_copyable(long double), "");
+ static_assert(__is_trivially_copyable(unsigned char), "");
+ static_assert(__is_trivially_copyable(unsigned int), "");
+ static_assert(__is_trivially_copyable(unsigned long long), "");
+ static_assert(__is_trivially_copyable(unsigned long), "");
+ static_assert(__is_trivially_copyable(unsigned short), "");
+ static_assert(__is_trivially_copyable(ClassType), "");
+ static_assert(__is_trivially_copyable(Derives), "");
+ static_assert(__is_trivially_copyable(Enum), "");
+ static_assert(__is_trivially_copyable(IntAr), "");
+ static_assert(__is_trivially_copyable(Union), "");
+ static_assert(__is_trivially_copyable(UnionAr), "");
+ static_assert(__is_trivially_copyable(TrivialStruct), "");
+ static_assert(__is_trivially_copyable(NonTrivialStruct), "");
+ static_assert(__is_trivially_copyable(AllDefaulted), "");
+ static_assert(__is_trivially_copyable(AllDeleted), "");
+
+ static_assert(!__is_trivially_copyable(void), "");
+ static_assert(!__is_trivially_copyable(SuperNonTrivialStruct), "");
+ static_assert(!__is_trivially_copyable(NonTCStruct), "");
+ static_assert(!__is_trivially_copyable(ExtDefaulted), "");
+
+ static_assert(__is_trivially_copyable(const int), "");
+ static_assert(__is_trivially_copyable(volatile int), "");
+
+ static_assert(__is_trivially_copyable(ACompleteType), "");
+ static_assert(!__is_trivially_copyable(AnIncompleteType), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_trivially_copyable(AnIncompleteType[]), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_trivially_copyable(AnIncompleteType[1]), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_trivially_copyable(void), "");
+ static_assert(!__is_trivially_copyable(const volatile void), "");
}
struct CStruct {
@@ -1477,32 +1475,32 @@ void is_standard_layout()
typedef ConstInt ConstIntAr[4];
typedef CppStructStandard CppStructStandardAr[4];
- int t01[T(__is_standard_layout(int))];
- int t02[T(__is_standard_layout(ConstInt))];
- int t03[T(__is_standard_layout(ConstIntAr))];
- int t04[T(__is_standard_layout(CStruct))];
- int t05[T(__is_standard_layout(CppStructStandard))];
- int t06[T(__is_standard_layout(CppStructStandardAr))];
- int t07[T(__is_standard_layout(Vector))];
- int t08[T(__is_standard_layout(VectorExt))];
+ static_assert(__is_standard_layout(int), "");
+ static_assert(__is_standard_layout(ConstInt), "");
+ static_assert(__is_standard_layout(ConstIntAr), "");
+ static_assert(__is_standard_layout(CStruct), "");
+ static_assert(__is_standard_layout(CppStructStandard), "");
+ static_assert(__is_standard_layout(CppStructStandardAr), "");
+ static_assert(__is_standard_layout(Vector), "");
+ static_assert(__is_standard_layout(VectorExt), "");
typedef CppStructNonStandardByBase CppStructNonStandardByBaseAr[4];
- int t10[F(__is_standard_layout(CppStructNonStandardByVirt))];
- int t11[F(__is_standard_layout(CppStructNonStandardByMemb))];
- int t12[F(__is_standard_layout(CppStructNonStandardByProt))];
- int t13[F(__is_standard_layout(CppStructNonStandardByVirtBase))];
- int t14[F(__is_standard_layout(CppStructNonStandardByBase))];
- int t15[F(__is_standard_layout(CppStructNonStandardByBaseAr))];
- int t16[F(__is_standard_layout(CppStructNonStandardBySameBase))];
- int t17[F(__is_standard_layout(CppStructNonStandardBy2ndVirtBase))];
-
- int t40[T(__is_standard_layout(ACompleteType))];
- int t41[F(__is_standard_layout(AnIncompleteType))]; // expected-error {{incomplete type}}
- int t42[F(__is_standard_layout(AnIncompleteType[]))]; // expected-error {{incomplete type}}
- int t43[F(__is_standard_layout(AnIncompleteType[1]))]; // expected-error {{incomplete type}}
- int t44[F(__is_standard_layout(void))];
- int t45[F(__is_standard_layout(const volatile void))];
+ static_assert(!__is_standard_layout(CppStructNonStandardByVirt), "");
+ static_assert(!__is_standard_layout(CppStructNonStandardByMemb), "");
+ static_assert(!__is_standard_layout(CppStructNonStandardByProt), "");
+ static_assert(!__is_standard_layout(CppStructNonStandardByVirtBase), "");
+ static_assert(!__is_standard_layout(CppStructNonStandardByBase), "");
+ static_assert(!__is_standard_layout(CppStructNonStandardByBaseAr), "");
+ static_assert(!__is_standard_layout(CppStructNonStandardBySameBase), "");
+ static_assert(!__is_standard_layout(CppStructNonStandardBy2ndVirtBase), "");
+
+ static_assert(__is_standard_layout(ACompleteType), "");
+ static_assert(!__is_standard_layout(AnIncompleteType), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_standard_layout(AnIncompleteType[]), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_standard_layout(AnIncompleteType[1]), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_standard_layout(void), "");
+ static_assert(!__is_standard_layout(const volatile void), "");
struct HasAnonEmptyBitfield { int : 0; };
struct HasAnonBitfield { int : 4; };
@@ -1510,11 +1508,11 @@ void is_standard_layout()
struct DerivesFromBitfieldWithBitfield : HasAnonBitfield { int : 5; };
struct DerivesFromBitfieldTwice : DerivesFromBitfield, HasAnonEmptyBitfield {};
- int t50[T(__is_standard_layout(HasAnonEmptyBitfield))];
- int t51[T(__is_standard_layout(HasAnonBitfield))];
- int t52[T(__is_standard_layout(DerivesFromBitfield))];
- int t53[F(__is_standard_layout(DerivesFromBitfieldWithBitfield))];
- int t54[F(__is_standard_layout(DerivesFromBitfieldTwice))];
+ static_assert(__is_standard_layout(HasAnonEmptyBitfield), "");
+ static_assert(__is_standard_layout(HasAnonBitfield), "");
+ static_assert(__is_standard_layout(DerivesFromBitfield), "");
+ static_assert(!__is_standard_layout(DerivesFromBitfieldWithBitfield), "");
+ static_assert(!__is_standard_layout(DerivesFromBitfieldTwice), "");
struct Empty {};
struct HasEmptyBase : Empty {};
@@ -1528,16 +1526,16 @@ void is_standard_layout()
struct HasEmptyIndirectBaseAsSecondMember : HasEmptyBase { int n; Empty e; };
struct HasEmptyIndirectBaseAfterBitfield : HasEmptyBase { int : 4; Empty e; };
- int t60[T(__is_standard_layout(Empty))];
- int t61[T(__is_standard_layout(HasEmptyBase))];
- int t62[F(__is_standard_layout(HasRepeatedEmptyBase))];
- int t63[F(__is_standard_layout(HasEmptyBaseAsMember))];
- int t64[F(__is_standard_layout(HasEmptyBaseAsSubobjectOfMember1))];
- int t65[T(__is_standard_layout(HasEmptyBaseAsSubobjectOfMember2))]; // FIXME: standard bug?
- int t66[F(__is_standard_layout(HasEmptyBaseAsSubobjectOfMember3))];
- int t67[F(__is_standard_layout(HasEmptyIndirectBaseAsMember))];
- int t68[T(__is_standard_layout(HasEmptyIndirectBaseAsSecondMember))];
- int t69[F(__is_standard_layout(HasEmptyIndirectBaseAfterBitfield))]; // FIXME: standard bug?
+ static_assert(__is_standard_layout(Empty), "");
+ static_assert(__is_standard_layout(HasEmptyBase), "");
+ static_assert(!__is_standard_layout(HasRepeatedEmptyBase), "");
+ static_assert(!__is_standard_layout(HasEmptyBaseAsMember), "");
+ static_assert(!__is_standard_layout(HasEmptyBaseAsSubobjectOfMember1), "");
+ static_assert(__is_standard_layout(HasEmptyBaseAsSubobjectOfMember2), ""); // FIXME: standard bug?
+ static_assert(!__is_standard_layout(HasEmptyBaseAsSubobjectOfMember3), "");
+ static_assert(!__is_standard_layout(HasEmptyIndirectBaseAsMember), "");
+ static_assert(__is_standard_layout(HasEmptyIndirectBaseAsSecondMember), "");
+ static_assert(!__is_standard_layout(HasEmptyIndirectBaseAfterBitfield), ""); // FIXME: standard bug?
struct StructWithEmptyFields {
int n;
@@ -1554,68 +1552,68 @@ void is_standard_layout()
UnionWithEmptyFields u;
};
- int t70[T(__is_standard_layout(HasEmptyIndirectBaseAsSecondStructMember))];
- int t71[F(__is_standard_layout(HasEmptyIndirectBaseAsSecondUnionMember))];
+ static_assert(__is_standard_layout(HasEmptyIndirectBaseAsSecondStructMember), "");
+ static_assert(!__is_standard_layout(HasEmptyIndirectBaseAsSecondUnionMember), "");
}
void is_signed()
{
- //int t01[T(__is_signed(char))];
- int t02[T(__is_signed(int))];
- int t03[T(__is_signed(long))];
- int t04[T(__is_signed(short))];
- int t05[T(__is_signed(signed char))];
- int t06[T(__is_signed(wchar_t))];
- int t07[T(__is_signed(float))];
- int t08[T(__is_signed(double))];
- int t09[T(__is_signed(long double))];
-
- int t13[F(__is_signed(bool))];
- int t14[F(__is_signed(cvoid))];
- int t15[F(__is_signed(unsigned char))];
- int t16[F(__is_signed(unsigned int))];
- int t17[F(__is_signed(unsigned long long))];
- int t18[F(__is_signed(unsigned long))];
- int t19[F(__is_signed(unsigned short))];
- int t20[F(__is_signed(void))];
- int t21[F(__is_signed(ClassType))];
- int t22[F(__is_signed(Derives))];
- int t23[F(__is_signed(Enum))];
- int t24[F(__is_signed(SignedEnum))];
- int t25[F(__is_signed(IntArNB))];
- int t26[F(__is_signed(Union))];
- int t27[F(__is_signed(UnionAr))];
- int t28[F(__is_signed(UnsignedEnum))];
+ //static_assert(__is_signed(char), "");
+ static_assert(__is_signed(int), "");
+ static_assert(__is_signed(long), "");
+ static_assert(__is_signed(short), "");
+ static_assert(__is_signed(signed char), "");
+ static_assert(__is_signed(wchar_t), "");
+ static_assert(__is_signed(float), "");
+ static_assert(__is_signed(double), "");
+ static_assert(__is_signed(long double), "");
+
+ static_assert(!__is_signed(bool), "");
+ static_assert(!__is_signed(cvoid), "");
+ static_assert(!__is_signed(unsigned char), "");
+ static_assert(!__is_signed(unsigned int), "");
+ static_assert(!__is_signed(unsigned long long), "");
+ static_assert(!__is_signed(unsigned long), "");
+ static_assert(!__is_signed(unsigned short), "");
+ static_assert(!__is_signed(void), "");
+ static_assert(!__is_signed(ClassType), "");
+ static_assert(!__is_signed(Derives), "");
+ static_assert(!__is_signed(Enum), "");
+ static_assert(!__is_signed(SignedEnum), "");
+ static_assert(!__is_signed(IntArNB), "");
+ static_assert(!__is_signed(Union), "");
+ static_assert(!__is_signed(UnionAr), "");
+ static_assert(!__is_signed(UnsignedEnum), "");
}
void is_unsigned()
{
- int t01[T(__is_unsigned(bool))];
- int t02[T(__is_unsigned(unsigned char))];
- int t03[T(__is_unsigned(unsigned short))];
- int t04[T(__is_unsigned(unsigned int))];
- int t05[T(__is_unsigned(unsigned long))];
- int t06[T(__is_unsigned(unsigned long long))];
-
- int t10[F(__is_unsigned(void))];
- int t11[F(__is_unsigned(cvoid))];
- int t12[F(__is_unsigned(float))];
- int t13[F(__is_unsigned(double))];
- int t14[F(__is_unsigned(long double))];
- int t16[F(__is_unsigned(char))];
- int t17[F(__is_unsigned(signed char))];
- int t18[F(__is_unsigned(wchar_t))];
- int t19[F(__is_unsigned(short))];
- int t20[F(__is_unsigned(int))];
- int t21[F(__is_unsigned(long))];
- int t22[F(__is_unsigned(Union))];
- int t23[F(__is_unsigned(UnionAr))];
- int t24[F(__is_unsigned(Derives))];
- int t25[F(__is_unsigned(ClassType))];
- int t26[F(__is_unsigned(IntArNB))];
- int t27[F(__is_unsigned(Enum))];
- int t28[F(__is_unsigned(UnsignedEnum))];
- int t29[F(__is_unsigned(SignedEnum))];
+ static_assert(__is_unsigned(bool), "");
+ static_assert(__is_unsigned(unsigned char), "");
+ static_assert(__is_unsigned(unsigned short), "");
+ static_assert(__is_unsigned(unsigned int), "");
+ static_assert(__is_unsigned(unsigned long), "");
+ static_assert(__is_unsigned(unsigned long long), "");
+
+ static_assert(!__is_unsigned(void), "");
+ static_assert(!__is_unsigned(cvoid), "");
+ static_assert(!__is_unsigned(float), "");
+ static_assert(!__is_unsigned(double), "");
+ static_assert(!__is_unsigned(long double), "");
+ static_assert(!__is_unsigned(char), "");
+ static_assert(!__is_unsigned(signed char), "");
+ static_assert(!__is_unsigned(wchar_t), "");
+ static_assert(!__is_unsigned(short), "");
+ static_assert(!__is_unsigned(int), "");
+ static_assert(!__is_unsigned(long), "");
+ static_assert(!__is_unsigned(Union), "");
+ static_assert(!__is_unsigned(UnionAr), "");
+ static_assert(!__is_unsigned(Derives), "");
+ static_assert(!__is_unsigned(ClassType), "");
+ static_assert(!__is_unsigned(IntArNB), "");
+ static_assert(!__is_unsigned(Enum), "");
+ static_assert(!__is_unsigned(UnsignedEnum), "");
+ static_assert(!__is_unsigned(SignedEnum), "");
}
typedef Int& IntRef;
@@ -1638,35 +1636,35 @@ struct HasTemplateCons {
};
void has_trivial_default_constructor() {
- { 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(DerivesAr))]; }
- { 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[T(__has_trivial_constructor(HasCopyAssign))]; }
- { int arr[T(__has_trivial_constructor(HasMoveAssign))]; }
- { int arr[T(__has_trivial_constructor(const Int))]; }
- { int arr[T(__has_trivial_constructor(AllDefaulted))]; }
- { int arr[T(__has_trivial_constructor(AllDeleted))]; }
- { int arr[T(__has_trivial_constructor(ACompleteType[]))]; }
-
- { int arr[F(__has_trivial_constructor(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
- { 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[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))]; }
- { int arr[F(__has_trivial_constructor(AllPrivate))]; }
- { int arr[F(__has_trivial_constructor(ExtDefaulted))]; }
+ static_assert(__has_trivial_constructor(Int), "");
+ static_assert(__has_trivial_constructor(IntAr), "");
+ static_assert(__has_trivial_constructor(Union), "");
+ static_assert(__has_trivial_constructor(UnionAr), "");
+ static_assert(__has_trivial_constructor(POD), "");
+ static_assert(__has_trivial_constructor(Derives), "");
+ static_assert(__has_trivial_constructor(DerivesAr), "");
+ static_assert(__has_trivial_constructor(ConstIntAr), "");
+ static_assert(__has_trivial_constructor(ConstIntArAr), "");
+ static_assert(__has_trivial_constructor(HasDest), "");
+ static_assert(__has_trivial_constructor(HasPriv), "");
+ static_assert(__has_trivial_constructor(HasCopyAssign), "");
+ static_assert(__has_trivial_constructor(HasMoveAssign), "");
+ static_assert(__has_trivial_constructor(const Int), "");
+ static_assert(__has_trivial_constructor(AllDefaulted), "");
+ static_assert(__has_trivial_constructor(AllDeleted), "");
+ static_assert(__has_trivial_constructor(ACompleteType[]), "");
+
+ static_assert(!__has_trivial_constructor(AnIncompleteType[]), ""); // expected-error {{incomplete type}}
+ static_assert(!__has_trivial_constructor(HasCons), "");
+ static_assert(!__has_trivial_constructor(HasRef), "");
+ static_assert(!__has_trivial_constructor(HasCopy), "");
+ static_assert(!__has_trivial_constructor(IntRef), "");
+ static_assert(!__has_trivial_constructor(VirtAr), "");
+ static_assert(!__has_trivial_constructor(void), "");
+ static_assert(!__has_trivial_constructor(cvoid), "");
+ static_assert(!__has_trivial_constructor(HasTemplateCons), "");
+ static_assert(!__has_trivial_constructor(AllPrivate), "");
+ static_assert(!__has_trivial_constructor(ExtDefaulted), "");
}
void has_trivial_move_constructor() {
@@ -1682,127 +1680,127 @@ void has_trivial_move_constructor() {
// type (or array thereof), the constructor selected
// to copy/move that member is trivial;
// otherwise the copy/move constructor is non-trivial.
- { int arr[T(__has_trivial_move_constructor(POD))]; }
- { int arr[T(__has_trivial_move_constructor(Union))]; }
- { int arr[T(__has_trivial_move_constructor(HasCons))]; }
- { int arr[T(__has_trivial_move_constructor(HasStaticMemberMoveCtor))]; }
- { int arr[T(__has_trivial_move_constructor(AllDeleted))]; }
- { int arr[T(__has_trivial_move_constructor(ACompleteType[]))]; }
-
- { int arr[F(__has_trivial_move_constructor(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
- { int arr[F(__has_trivial_move_constructor(HasVirt))]; }
- { int arr[F(__has_trivial_move_constructor(DerivesVirt))]; }
- { int arr[F(__has_trivial_move_constructor(HasMoveCtor))]; }
- { int arr[F(__has_trivial_move_constructor(DerivesHasMoveCtor))]; }
- { int arr[F(__has_trivial_move_constructor(HasMemberMoveCtor))]; }
+ static_assert(__has_trivial_move_constructor(POD), "");
+ static_assert(__has_trivial_move_constructor(Union), "");
+ static_assert(__has_trivial_move_constructor(HasCons), "");
+ static_assert(__has_trivial_move_constructor(HasStaticMemberMoveCtor), "");
+ static_assert(__has_trivial_move_constructor(AllDeleted), "");
+ static_assert(__has_trivial_move_constructor(ACompleteType[]), "");
+
+ static_assert(!__has_trivial_move_constructor(AnIncompleteType[]), ""); // expected-error {{incomplete type}}
+ static_assert(!__has_trivial_move_constructor(HasVirt), "");
+ static_assert(!__has_trivial_move_constructor(DerivesVirt), "");
+ static_assert(!__has_trivial_move_constructor(HasMoveCtor), "");
+ static_assert(!__has_trivial_move_constructor(DerivesHasMoveCtor), "");
+ static_assert(!__has_trivial_move_constructor(HasMemberMoveCtor), "");
}
void has_trivial_copy_constructor() {
- { 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[T(__has_trivial_copy(HasMove))]; }
- { int arr[T(__has_trivial_copy(IntRef))]; }
- { int arr[T(__has_trivial_copy(HasCopyAssign))]; }
- { int arr[T(__has_trivial_copy(HasMoveAssign))]; }
- { int arr[T(__has_trivial_copy(const Int))]; }
- { int arr[T(__has_trivial_copy(AllDefaulted))]; }
- { int arr[T(__has_trivial_copy(AllDeleted))]; }
- { int arr[T(__has_trivial_copy(DerivesAr))]; }
- { int arr[T(__has_trivial_copy(DerivesHasRef))]; }
- { int arr[T(__has_trivial_copy(ACompleteType[]))]; }
-
- { int arr[F(__has_trivial_copy(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
- { int arr[F(__has_trivial_copy(HasCopy))]; }
- { int arr[F(__has_trivial_copy(HasTemplateCons))]; }
- { 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(AllPrivate))]; }
- { int arr[F(__has_trivial_copy(ExtDefaulted))]; }
+ static_assert(__has_trivial_copy(Int), "");
+ static_assert(__has_trivial_copy(IntAr), "");
+ static_assert(__has_trivial_copy(Union), "");
+ static_assert(__has_trivial_copy(UnionAr), "");
+ static_assert(__has_trivial_copy(POD), "");
+ static_assert(__has_trivial_copy(Derives), "");
+ static_assert(__has_trivial_copy(ConstIntAr), "");
+ static_assert(__has_trivial_copy(ConstIntArAr), "");
+ static_assert(__has_trivial_copy(HasDest), "");
+ static_assert(__has_trivial_copy(HasPriv), "");
+ static_assert(__has_trivial_copy(HasCons), "");
+ static_assert(__has_trivial_copy(HasRef), "");
+ static_assert(__has_trivial_copy(HasMove), "");
+ static_assert(__has_trivial_copy(IntRef), "");
+ static_assert(__has_trivial_copy(HasCopyAssign), "");
+ static_assert(__has_trivial_copy(HasMoveAssign), "");
+ static_assert(__has_trivial_copy(const Int), "");
+ static_assert(__has_trivial_copy(AllDefaulted), "");
+ static_assert(__has_trivial_copy(AllDeleted), "");
+ static_assert(__has_trivial_copy(DerivesAr), "");
+ static_assert(__has_trivial_copy(DerivesHasRef), "");
+ static_assert(__has_trivial_copy(ACompleteType[]), "");
+
+ static_assert(!__has_trivial_copy(AnIncompleteType[]), ""); // expected-error {{incomplete type}}
+ static_assert(!__has_trivial_copy(HasCopy), "");
+ static_assert(!__has_trivial_copy(HasTemplateCons), "");
+ static_assert(!__has_trivial_copy(VirtAr), "");
+ static_assert(!__has_trivial_copy(void), "");
+ static_assert(!__has_trivial_copy(cvoid), "");
+ static_assert(!__has_trivial_copy(AllPrivate), "");
+ static_assert(!__has_trivial_copy(ExtDefaulted), "");
}
void has_trivial_copy_assignment() {
- { 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[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[T(__has_trivial_assign(HasMove))]; }
- { int arr[T(__has_trivial_assign(HasMoveAssign))]; }
- { int arr[T(__has_trivial_assign(AllDefaulted))]; }
- { int arr[T(__has_trivial_assign(AllDeleted))]; }
- { int arr[T(__has_trivial_assign(DerivesAr))]; }
- { int arr[T(__has_trivial_assign(DerivesHasRef))]; }
- { int arr[T(__has_trivial_assign(ACompleteType[]))]; }
-
- { int arr[F(__has_trivial_assign(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
- { 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(ConstIntAr))]; }
- { int arr[F(__has_trivial_assign(ConstIntArAr))]; }
- { int arr[F(__has_trivial_assign(VirtAr))]; }
- { int arr[F(__has_trivial_assign(void))]; }
- { int arr[F(__has_trivial_assign(cvoid))]; }
- { int arr[F(__has_trivial_assign(AllPrivate))]; }
- { int arr[F(__has_trivial_assign(ExtDefaulted))]; }
+ static_assert(__has_trivial_assign(Int), "");
+ static_assert(__has_trivial_assign(IntAr), "");
+ static_assert(__has_trivial_assign(Union), "");
+ static_assert(__has_trivial_assign(UnionAr), "");
+ static_assert(__has_trivial_assign(POD), "");
+ static_assert(__has_trivial_assign(Derives), "");
+ static_assert(__has_trivial_assign(HasDest), "");
+ static_assert(__has_trivial_assign(HasPriv), "");
+ static_assert(__has_trivial_assign(HasCons), "");
+ static_assert(__has_trivial_assign(HasRef), "");
+ static_assert(__has_trivial_assign(HasCopy), "");
+ static_assert(__has_trivial_assign(HasMove), "");
+ static_assert(__has_trivial_assign(HasMoveAssign), "");
+ static_assert(__has_trivial_assign(AllDefaulted), "");
+ static_assert(__has_trivial_assign(AllDeleted), "");
+ static_assert(__has_trivial_assign(DerivesAr), "");
+ static_assert(__has_trivial_assign(DerivesHasRef), "");
+ static_assert(__has_trivial_assign(ACompleteType[]), "");
+
+ static_assert(!__has_trivial_assign(AnIncompleteType[]), ""); // expected-error {{incomplete type}}
+ static_assert(!__has_trivial_assign(IntRef), "");
+ static_assert(!__has_trivial_assign(HasCopyAssign), "");
+ static_assert(!__has_trivial_assign(const Int), "");
+ static_assert(!__has_trivial_assign(ConstIntAr), "");
+ static_assert(!__has_trivial_assign(ConstIntArAr), "");
+ static_assert(!__has_trivial_assign(VirtAr), "");
+ static_assert(!__has_trivial_assign(void), "");
+ static_assert(!__has_trivial_assign(cvoid), "");
+ static_assert(!__has_trivial_assign(AllPrivate), "");
+ static_assert(!__has_trivial_assign(ExtDefaulted), "");
}
void has_trivial_destructor() {
- { 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[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(HasMove))]; }
- { int arr[T(__has_trivial_destructor(IntRef))]; }
- { int arr[T(__has_trivial_destructor(HasCopyAssign))]; }
- { int arr[T(__has_trivial_destructor(HasMoveAssign))]; }
- { int arr[T(__has_trivial_destructor(const Int))]; }
- { int arr[T(__has_trivial_destructor(DerivesAr))]; }
- { int arr[T(__has_trivial_destructor(VirtAr))]; }
- { int arr[T(__has_trivial_destructor(AllDefaulted))]; }
- { int arr[T(__has_trivial_destructor(AllDeleted))]; }
- { int arr[T(__has_trivial_destructor(DerivesHasRef))]; }
- { int arr[T(__has_trivial_destructor(ACompleteType[]))]; }
-
- { int arr[F(__has_trivial_destructor(HasDest))]; }
- { int arr[F(__has_trivial_destructor(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
- { int arr[F(__has_trivial_destructor(void))]; }
- { int arr[F(__has_trivial_destructor(cvoid))]; }
- { int arr[F(__has_trivial_destructor(AllPrivate))]; }
- { int arr[F(__has_trivial_destructor(ExtDefaulted))]; }
+ static_assert(__has_trivial_destructor(Int), "");
+ static_assert(__has_trivial_destructor(IntAr), "");
+ static_assert(__has_trivial_destructor(Union), "");
+ static_assert(__has_trivial_destructor(UnionAr), "");
+ static_assert(__has_trivial_destructor(POD), "");
+ static_assert(__has_trivial_destructor(Derives), "");
+ static_assert(__has_trivial_destructor(ConstIntAr), "");
+ static_assert(__has_trivial_destructor(ConstIntArAr), "");
+ static_assert(__has_trivial_destructor(HasPriv), "");
+ static_assert(__has_trivial_destructor(HasCons), "");
+ static_assert(__has_trivial_destructor(HasRef), "");
+ static_assert(__has_trivial_destructor(HasCopy), "");
+ static_assert(__has_trivial_destructor(HasMove), "");
+ static_assert(__has_trivial_destructor(IntRef), "");
+ static_assert(__has_trivial_destructor(HasCopyAssign), "");
+ static_assert(__has_trivial_destructor(HasMoveAssign), "");
+ static_assert(__has_trivial_destructor(const Int), "");
+ static_assert(__has_trivial_destructor(DerivesAr), "");
+ static_assert(__has_trivial_destructor(VirtAr), "");
+ static_assert(__has_trivial_destructor(AllDefaulted), "");
+ static_assert(__has_trivial_destructor(AllDeleted), "");
+ static_assert(__has_trivial_destructor(DerivesHasRef), "");
+ static_assert(__has_trivial_destructor(ACompleteType[]), "");
+
+ static_assert(!__has_trivial_destructor(HasDest), "");
+ static_assert(!__has_trivial_destructor(AnIncompleteType[]), ""); // expected-error {{incomplete type}}
+ static_assert(!__has_trivial_destructor(void), "");
+ static_assert(!__has_trivial_destructor(cvoid), "");
+ static_assert(!__has_trivial_destructor(AllPrivate), "");
+ static_assert(!__has_trivial_destructor(ExtDefaulted), "");
}
struct A { ~A() {} };
template<typename> struct B : A { };
void f() {
- { int arr[F(__has_trivial_destructor(A))]; }
- { int arr[F(__has_trivial_destructor(B<int>))]; }
+ static_assert(!__has_trivial_destructor(A), "");
+ static_assert(!__has_trivial_destructor(B<int>), "");
}
class PR11110 {
@@ -1823,69 +1821,69 @@ class UsingAssign : public UsingAssignBase {
};
void has_nothrow_assign() {
- { 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[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[T(__has_nothrow_assign(HasMove))]; }
- { int arr[T(__has_nothrow_assign(HasMoveAssign))]; }
- { int arr[T(__has_nothrow_assign(HasNoThrowCopyAssign))]; }
- { int arr[T(__has_nothrow_assign(HasMultipleNoThrowCopyAssign))]; }
- { int arr[T(__has_nothrow_assign(HasVirtDest))]; }
- { int arr[T(__has_nothrow_assign(AllPrivate))]; }
- { int arr[T(__has_nothrow_assign(UsingAssign))]; }
- { int arr[T(__has_nothrow_assign(DerivesAr))]; }
- { int arr[T(__has_nothrow_assign(ACompleteType[]))]; }
-
- { int arr[F(__has_nothrow_assign(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
- { int arr[F(__has_nothrow_assign(IntRef))]; }
- { int arr[F(__has_nothrow_assign(HasCopyAssign))]; }
- { int arr[F(__has_nothrow_assign(HasMultipleCopyAssign))]; }
- { int arr[F(__has_nothrow_assign(const Int))]; }
- { int arr[F(__has_nothrow_assign(ConstIntAr))]; }
- { int arr[F(__has_nothrow_assign(ConstIntArAr))]; }
- { int arr[F(__has_nothrow_assign(VirtAr))]; }
- { int arr[F(__has_nothrow_assign(void))]; }
- { int arr[F(__has_nothrow_assign(cvoid))]; }
- { int arr[F(__has_nothrow_assign(PR11110))]; }
+ static_assert(__has_nothrow_assign(Int), "");
+ static_assert(__has_nothrow_assign(IntAr), "");
+ static_assert(__has_nothrow_assign(Union), "");
+ static_assert(__has_nothrow_assign(UnionAr), "");
+ static_assert(__has_nothrow_assign(POD), "");
+ static_assert(__has_nothrow_assign(Derives), "");
+ static_assert(__has_nothrow_assign(HasDest), "");
+ static_assert(__has_nothrow_assign(HasPriv), "");
+ static_assert(__has_nothrow_assign(HasCons), "");
+ static_assert(__has_nothrow_assign(HasRef), "");
+ static_assert(__has_nothrow_assign(HasCopy), "");
+ static_assert(__has_nothrow_assign(HasMove), "");
+ static_assert(__has_nothrow_assign(HasMoveAssign), "");
+ static_assert(__has_nothrow_assign(HasNoThrowCopyAssign), "");
+ static_assert(__has_nothrow_assign(HasMultipleNoThrowCopyAssign), "");
+ static_assert(__has_nothrow_assign(HasVirtDest), "");
+ static_assert(__has_nothrow_assign(AllPrivate), "");
+ static_assert(__has_nothrow_assign(UsingAssign), "");
+ static_assert(__has_nothrow_assign(DerivesAr), "");
+ static_assert(__has_nothrow_assign(ACompleteType[]), "");
+
+ static_assert(!__has_nothrow_assign(AnIncompleteType[]), ""); // expected-error {{incomplete type}}
+ static_assert(!__has_nothrow_assign(IntRef), "");
+ static_assert(!__has_nothrow_assign(HasCopyAssign), "");
+ static_assert(!__has_nothrow_assign(HasMultipleCopyAssign), "");
+ static_assert(!__has_nothrow_assign(const Int), "");
+ static_assert(!__has_nothrow_assign(ConstIntAr), "");
+ static_assert(!__has_nothrow_assign(ConstIntArAr), "");
+ static_assert(!__has_nothrow_assign(VirtAr), "");
+ static_assert(!__has_nothrow_assign(void), "");
+ static_assert(!__has_nothrow_assign(cvoid), "");
+ static_assert(!__has_nothrow_assign(PR11110), "");
}
void has_nothrow_move_assign() {
- { int arr[T(__has_nothrow_move_assign(Int))]; }
- { int arr[T(__has_nothrow_move_assign(Enum))]; }
- { int arr[T(__has_nothrow_move_assign(Int*))]; }
- { int arr[T(__has_nothrow_move_assign(Enum POD::*))]; }
- { int arr[T(__has_nothrow_move_assign(POD))]; }
- { int arr[T(__has_nothrow_move_assign(HasPriv))]; }
- { int arr[T(__has_nothrow_move_assign(HasNoThrowMoveAssign))]; }
- { int arr[T(__has_nothrow_move_assign(HasNoExceptNoThrowMoveAssign))]; }
- { int arr[T(__has_nothrow_move_assign(HasMemberNoThrowMoveAssign))]; }
- { int arr[T(__has_nothrow_move_assign(HasMemberNoExceptNoThrowMoveAssign))]; }
- { int arr[T(__has_nothrow_move_assign(AllDeleted))]; }
- { int arr[T(__has_nothrow_move_assign(ACompleteType[]))]; }
-
- { int arr[F(__has_nothrow_move_assign(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
- { int arr[F(__has_nothrow_move_assign(HasThrowMoveAssign))]; }
- { int arr[F(__has_nothrow_move_assign(HasNoExceptFalseMoveAssign))]; }
- { int arr[F(__has_nothrow_move_assign(HasMemberThrowMoveAssign))]; }
- { int arr[F(__has_nothrow_move_assign(HasMemberNoExceptFalseMoveAssign))]; }
- { int arr[F(__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyCtor))]; }
- { int arr[F(__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyAssign))]; }
- { int arr[F(__has_nothrow_move_assign(NoDefaultMoveAssignDueToDtor))]; }
-
-
- { int arr[T(__is_nothrow_assignable(HasNoThrowMoveAssign, HasNoThrowMoveAssign))]; }
- { int arr[F(__is_nothrow_assignable(HasThrowMoveAssign, HasThrowMoveAssign))]; }
-
- { int arr[T(__is_assignable(HasNoThrowMoveAssign, HasNoThrowMoveAssign))]; }
- { int arr[T(__is_assignable(HasThrowMoveAssign, HasThrowMoveAssign))]; }
+ static_assert(__has_nothrow_move_assign(Int), "");
+ static_assert(__has_nothrow_move_assign(Enum), "");
+ static_assert(__has_nothrow_move_assign(Int*), "");
+ static_assert(__has_nothrow_move_assign(Enum POD::*), "");
+ static_assert(__has_nothrow_move_assign(POD), "");
+ static_assert(__has_nothrow_move_assign(HasPriv), "");
+ static_assert(__has_nothrow_move_assign(HasNoThrowMoveAssign), "");
+ static_assert(__has_nothrow_move_assign(HasNoExceptNoThrowMoveAssign), "");
+ static_assert(__has_nothrow_move_assign(HasMemberNoThrowMoveAssign), "");
+ static_assert(__has_nothrow_move_assign(HasMemberNoExceptNoThrowMoveAssign), "");
+ static_assert(__has_nothrow_move_assign(AllDeleted), "");
+ static_assert(__has_nothrow_move_assign(ACompleteType[]), "");
+
+ static_assert(!__has_nothrow_move_assign(AnIncompleteType[]), ""); // expected-error {{incomplete type}}
+ static_assert(!__has_nothrow_move_assign(HasThrowMoveAssign), "");
+ static_assert(!__has_nothrow_move_assign(HasNoExceptFalseMoveAssign), "");
+ static_assert(!__has_nothrow_move_assign(HasMemberThrowMoveAssign), "");
+ static_assert(!__has_nothrow_move_assign(HasMemberNoExceptFalseMoveAssign), "");
+ static_assert(!__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyCtor), "");
+ static_assert(!__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyAssign), "");
+ static_assert(!__has_nothrow_move_assign(NoDefaultMoveAssignDueToDtor), "");
+
+
+ static_assert(__is_nothrow_assignable(HasNoThrowMoveAssign, HasNoThrowMoveAssign), "");
+ static_assert(!__is_nothrow_assignable(HasThrowMoveAssign, HasThrowMoveAssign), "");
+
+ static_assert(__is_assignable(HasNoThrowMoveAssign, HasNoThrowMoveAssign), "");
+ static_assert(__is_assignable(HasThrowMoveAssign, HasThrowMoveAssign), "");
}
void has_trivial_move_assign() {
@@ -1900,120 +1898,120 @@ void has_trivial_move_assign() {
// - for each non-static data member of X that is of class type
// (or array thereof), the assignment operator
// selected to copy/move that member is trivial;
- { int arr[T(__has_trivial_move_assign(Int))]; }
- { int arr[T(__has_trivial_move_assign(HasStaticMemberMoveAssign))]; }
- { int arr[T(__has_trivial_move_assign(AllDeleted))]; }
- { int arr[T(__has_trivial_move_assign(ACompleteType[]))]; }
-
- { int arr[F(__has_trivial_move_assign(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
- { int arr[F(__has_trivial_move_assign(HasVirt))]; }
- { int arr[F(__has_trivial_move_assign(DerivesVirt))]; }
- { int arr[F(__has_trivial_move_assign(HasMoveAssign))]; }
- { int arr[F(__has_trivial_move_assign(DerivesHasMoveAssign))]; }
- { int arr[F(__has_trivial_move_assign(HasMemberMoveAssign))]; }
- { int arr[F(__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyCtor))]; }
- { int arr[F(__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyAssign))]; }
+ static_assert(__has_trivial_move_assign(Int), "");
+ static_assert(__has_trivial_move_assign(HasStaticMemberMoveAssign), "");
+ static_assert(__has_trivial_move_assign(AllDeleted), "");
+ static_assert(__has_trivial_move_assign(ACompleteType[]), "");
+
+ static_assert(!__has_trivial_move_assign(AnIncompleteType[]), ""); // expected-error {{incomplete type}}
+ static_assert(!__has_trivial_move_assign(HasVirt), "");
+ static_assert(!__has_trivial_move_assign(DerivesVirt), "");
+ static_assert(!__has_trivial_move_assign(HasMoveAssign), "");
+ static_assert(!__has_trivial_move_assign(DerivesHasMoveAssign), "");
+ static_assert(!__has_trivial_move_assign(HasMemberMoveAssign), "");
+ static_assert(!__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyCtor), "");
+ static_assert(!__has_nothrow_move_assign(NoDefaultMoveAssignDueToUDCopyAssign), "");
}
void has_nothrow_copy() {
- { 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(const Int))]; }
- { int arr[T(__has_nothrow_copy(ConstIntAr))]; }
- { int arr[T(__has_nothrow_copy(ConstIntArAr))]; }
- { int arr[T(__has_nothrow_copy(Derives))]; }
- { int arr[T(__has_nothrow_copy(IntRef))]; }
- { 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[T(__has_nothrow_copy(HasMove))]; }
- { int arr[T(__has_nothrow_copy(HasCopyAssign))]; }
- { int arr[T(__has_nothrow_copy(HasMoveAssign))]; }
- { int arr[T(__has_nothrow_copy(HasNoThrowCopy))]; }
- { int arr[T(__has_nothrow_copy(HasMultipleNoThrowCopy))]; }
- { int arr[T(__has_nothrow_copy(HasVirtDest))]; }
- { int arr[T(__has_nothrow_copy(HasTemplateCons))]; }
- { int arr[T(__has_nothrow_copy(AllPrivate))]; }
- { int arr[T(__has_nothrow_copy(DerivesAr))]; }
- { int arr[T(__has_nothrow_copy(ACompleteType[]))]; }
-
- { int arr[F(__has_nothrow_copy(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
- { int arr[F(__has_nothrow_copy(HasCopy))]; }
- { int arr[F(__has_nothrow_copy(HasMultipleCopy))]; }
- { int arr[F(__has_nothrow_copy(VirtAr))]; }
- { int arr[F(__has_nothrow_copy(void))]; }
- { int arr[F(__has_nothrow_copy(cvoid))]; }
+ static_assert(__has_nothrow_copy(Int), "");
+ static_assert(__has_nothrow_copy(IntAr), "");
+ static_assert(__has_nothrow_copy(Union), "");
+ static_assert(__has_nothrow_copy(UnionAr), "");
+ static_assert(__has_nothrow_copy(POD), "");
+ static_assert(__has_nothrow_copy(const Int), "");
+ static_assert(__has_nothrow_copy(ConstIntAr), "");
+ static_assert(__has_nothrow_copy(ConstIntArAr), "");
+ static_assert(__has_nothrow_copy(Derives), "");
+ static_assert(__has_nothrow_copy(IntRef), "");
+ static_assert(__has_nothrow_copy(HasDest), "");
+ static_assert(__has_nothrow_copy(HasPriv), "");
+ static_assert(__has_nothrow_copy(HasCons), "");
+ static_assert(__has_nothrow_copy(HasRef), "");
+ static_assert(__has_nothrow_copy(HasMove), "");
+ static_assert(__has_nothrow_copy(HasCopyAssign), "");
+ static_assert(__has_nothrow_copy(HasMoveAssign), "");
+ static_assert(__has_nothrow_copy(HasNoThrowCopy), "");
+ static_assert(__has_nothrow_copy(HasMultipleNoThrowCopy), "");
+ static_assert(__has_nothrow_copy(HasVirtDest), "");
+ static_assert(__has_nothrow_copy(HasTemplateCons), "");
+ static_assert(__has_nothrow_copy(AllPrivate), "");
+ static_assert(__has_nothrow_copy(DerivesAr), "");
+ static_assert(__has_nothrow_copy(ACompleteType[]), "");
+
+ static_assert(!__has_nothrow_copy(AnIncompleteType[]), ""); // expected-error {{incomplete type}}
+ static_assert(!__has_nothrow_copy(HasCopy), "");
+ static_assert(!__has_nothrow_copy(HasMultipleCopy), "");
+ static_assert(!__has_nothrow_copy(VirtAr), "");
+ static_assert(!__has_nothrow_copy(void), "");
+ static_assert(!__has_nothrow_copy(cvoid), "");
}
void has_nothrow_constructor() {
- { 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(DerivesAr))]; }
- { 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[T(__has_nothrow_constructor(HasCopyAssign))]; }
- { int arr[T(__has_nothrow_constructor(const Int))]; }
- { int arr[T(__has_nothrow_constructor(HasNoThrowConstructor))]; }
- { int arr[T(__has_nothrow_constructor(HasVirtDest))]; }
- // { int arr[T(__has_nothrow_constructor(VirtAr))]; } // not implemented
- { int arr[T(__has_nothrow_constructor(AllPrivate))]; }
- { int arr[T(__has_nothrow_constructor(ACompleteType[]))]; }
-
- { int arr[F(__has_nothrow_constructor(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
- { 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(HasMove))]; }
- { int arr[F(__has_nothrow_constructor(HasNoThrowConstructorWithArgs))]; }
- { int arr[F(__has_nothrow_constructor(IntRef))]; }
- { int arr[F(__has_nothrow_constructor(void))]; }
- { int arr[F(__has_nothrow_constructor(cvoid))]; }
- { int arr[F(__has_nothrow_constructor(HasTemplateCons))]; }
-
- { int arr[F(__has_nothrow_constructor(HasMultipleDefaultConstructor1))]; }
- { int arr[F(__has_nothrow_constructor(HasMultipleDefaultConstructor2))]; }
+ static_assert(__has_nothrow_constructor(Int), "");
+ static_assert(__has_nothrow_constructor(IntAr), "");
+ static_assert(__has_nothrow_constructor(Union), "");
+ static_assert(__has_nothrow_constructor(UnionAr), "");
+ static_assert(__has_nothrow_constructor(POD), "");
+ static_assert(__has_nothrow_constructor(Derives), "");
+ static_assert(__has_nothrow_constructor(DerivesAr), "");
+ static_assert(__has_nothrow_constructor(ConstIntAr), "");
+ static_assert(__has_nothrow_constructor(ConstIntArAr), "");
+ static_assert(__has_nothrow_constructor(HasDest), "");
+ static_assert(__has_nothrow_constructor(HasPriv), "");
+ static_assert(__has_nothrow_constructor(HasCopyAssign), "");
+ static_assert(__has_nothrow_constructor(const Int), "");
+ static_assert(__has_nothrow_constructor(HasNoThrowConstructor), "");
+ static_assert(__has_nothrow_constructor(HasVirtDest), "");
+ // static_assert(__has_nothrow_constructor(VirtAr), ""); // not implemented
+ static_assert(__has_nothrow_constructor(AllPrivate), "");
+ static_assert(__has_nothrow_constructor(ACompleteType[]), "");
+
+ static_assert(!__has_nothrow_constructor(AnIncompleteType[]), ""); // expected-error {{incomplete type}}
+ static_assert(!__has_nothrow_constructor(HasCons), "");
+ static_assert(!__has_nothrow_constructor(HasRef), "");
+ static_assert(!__has_nothrow_constructor(HasCopy), "");
+ static_assert(!__has_nothrow_constructor(HasMove), "");
+ static_assert(!__has_nothrow_constructor(HasNoThrowConstructorWithArgs), "");
+ static_assert(!__has_nothrow_constructor(IntRef), "");
+ static_assert(!__has_nothrow_constructor(void), "");
+ static_assert(!__has_nothrow_constructor(cvoid), "");
+ static_assert(!__has_nothrow_constructor(HasTemplateCons), "");
+
+ static_assert(!__has_nothrow_constructor(HasMultipleDefaultConstructor1), "");
+ static_assert(!__has_nothrow_constructor(HasMultipleDefaultConstructor2), "");
}
void has_virtual_destructor() {
- { 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(DerivesAr))]; }
- { int arr[F(__has_virtual_destructor(const Int))]; }
- { 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(HasMove))]; }
- { int arr[F(__has_virtual_destructor(HasCopyAssign))]; }
- { int arr[F(__has_virtual_destructor(HasMoveAssign))]; }
- { int arr[F(__has_virtual_destructor(IntRef))]; }
- { int arr[F(__has_virtual_destructor(VirtAr))]; }
- { int arr[F(__has_virtual_destructor(ACompleteType[]))]; }
-
- { int arr[F(__has_virtual_destructor(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
- { 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))]; }
- { int arr[F(__has_virtual_destructor(AllPrivate))]; }
+ static_assert(!__has_virtual_destructor(Int), "");
+ static_assert(!__has_virtual_destructor(IntAr), "");
+ static_assert(!__has_virtual_destructor(Union), "");
+ static_assert(!__has_virtual_destructor(UnionAr), "");
+ static_assert(!__has_virtual_destructor(POD), "");
+ static_assert(!__has_virtual_destructor(Derives), "");
+ static_assert(!__has_virtual_destructor(DerivesAr), "");
+ static_assert(!__has_virtual_destructor(const Int), "");
+ static_assert(!__has_virtual_destructor(ConstIntAr), "");
+ static_assert(!__has_virtual_destructor(ConstIntArAr), "");
+ static_assert(!__has_virtual_destructor(HasDest), "");
+ static_assert(!__has_virtual_destructor(HasPriv), "");
+ static_assert(!__has_virtual_destructor(HasCons), "");
+ static_assert(!__has_virtual_destructor(HasRef), "");
+ static_assert(!__has_virtual_destructor(HasCopy), "");
+ static_assert(!__has_virtual_destructor(HasMove), "");
+ static_assert(!__has_virtual_destructor(HasCopyAssign), "");
+ static_assert(!__has_virtual_destructor(HasMoveAssign), "");
+ static_assert(!__has_virtual_destructor(IntRef), "");
+ static_assert(!__has_virtual_destructor(VirtAr), "");
+ static_assert(!__has_virtual_destructor(ACompleteType[]), "");
+
+ static_assert(!__has_virtual_destructor(AnIncompleteType[]), ""); // expected-error {{incomplete type}}
+ static_assert(__has_virtual_destructor(HasVirtDest), "");
+ static_assert(__has_virtual_destructor(DerivedVirtDest), "");
+ static_assert(!__has_virtual_destructor(VirtDestAr), "");
+ static_assert(!__has_virtual_destructor(void), "");
+ static_assert(!__has_virtual_destructor(cvoid), "");
+ static_assert(!__has_virtual_destructor(AllPrivate), "");
}
@@ -2031,11 +2029,11 @@ class class_forward; // expected-note 2 {{forward declaration of 'class_forward'
template <typename Base, typename Derived>
void isBaseOfT() {
- int t[T(__is_base_of(Base, Derived))];
+ static_assert(__is_base_of(Base, Derived), "");
};
template <typename Base, typename Derived>
void isBaseOfF() {
- int t[F(__is_base_of(Base, Derived))];
+ static_assert(!__is_base_of(Base, Derived), "");
};
template <class T> class DerivedTemp : Base {};
@@ -2043,43 +2041,43 @@ template <class T> class NonderivedTemp {};
template <class T> class UndefinedTemp; // expected-note {{declared here}}
void is_base_of() {
- { 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 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>'}}
-
- { int arr[F(__is_base_of(IncompleteUnion, IncompleteUnion))]; }
- { int arr[F(__is_base_of(Union, IncompleteUnion))]; }
- { int arr[F(__is_base_of(IncompleteUnion, Union))]; }
- { int arr[F(__is_base_of(IncompleteStruct, IncompleteUnion))]; }
- { int arr[F(__is_base_of(IncompleteUnion, IncompleteStruct))]; }
- { int arr[F(__is_base_of(Empty, IncompleteUnion))]; }
- { int arr[F(__is_base_of(IncompleteUnion, Empty))]; }
- { int arr[F(__is_base_of(int, IncompleteUnion))]; }
- { int arr[F(__is_base_of(IncompleteUnion, int))]; }
- { int arr[F(__is_base_of(Empty, Union))]; }
- { int arr[F(__is_base_of(Union, Empty))]; }
- { int arr[F(__is_base_of(int, Empty))]; }
- { int arr[F(__is_base_of(Union, int))]; }
+ static_assert(__is_base_of(Base, Derived), "");
+ static_assert(__is_base_of(const Base, Derived), "");
+ static_assert(!__is_base_of(Derived, Base), "");
+ static_assert(!__is_base_of(Derived, int), "");
+ static_assert(__is_base_of(Base, Base), "");
+ static_assert(__is_base_of(Base, Derived3), "");
+ static_assert(__is_base_of(Derived, Derived3), "");
+ static_assert(__is_base_of(Derived2b, Derived3), "");
+ static_assert(__is_base_of(Derived2a, Derived3), "");
+ static_assert(__is_base_of(BaseA<int>, DerivedB<int>), "");
+ static_assert(!__is_base_of(DerivedB<int>, BaseA<int>), "");
+ static_assert(__is_base_of(Base, CrazyDerived<Base>), "");
+ static_assert(!__is_base_of(Union, Union), "");
+ static_assert(__is_base_of(Empty, Empty), "");
+ static_assert(__is_base_of(class_forward, class_forward), "");
+ static_assert(!__is_base_of(Empty, class_forward), ""); // expected-error {{incomplete type 'class_forward' used in type trait expression}}
+ static_assert(!__is_base_of(Base&, Derived&), "");
+ static_assert(!__is_base_of(Base[10], Derived[10]), "");
+ static_assert(!__is_base_of(int, int), "");
+ static_assert(!__is_base_of(long, int), "");
+ static_assert(__is_base_of(Base, DerivedTemp<int>), "");
+ static_assert(!__is_base_of(Base, NonderivedTemp<int>), "");
+ static_assert(!__is_base_of(Base, UndefinedTemp<int>), ""); // expected-error {{implicit instantiation of undefined template 'UndefinedTemp<int>'}}
+
+ static_assert(!__is_base_of(IncompleteUnion, IncompleteUnion), "");
+ static_assert(!__is_base_of(Union, IncompleteUnion), "");
+ static_assert(!__is_base_of(IncompleteUnion, Union), "");
+ static_assert(!__is_base_of(IncompleteStruct, IncompleteUnion), "");
+ static_assert(!__is_base_of(IncompleteUnion, IncompleteStruct), "");
+ static_assert(!__is_base_of(Empty, IncompleteUnion), "");
+ static_assert(!__is_base_of(IncompleteUnion, Empty), "");
+ static_assert(!__is_base_of(int, IncompleteUnion), "");
+ static_assert(!__is_base_of(IncompleteUnion, int), "");
+ static_assert(!__is_base_of(Empty, Union), "");
+ static_assert(!__is_base_of(Union, Empty), "");
+ static_assert(!__is_base_of(int, Empty), "");
+ static_assert(!__is_base_of(Union, int), "");
isBaseOfT<Base, Derived>();
isBaseOfF<Derived, Base>();
@@ -2101,17 +2099,17 @@ typedef class Base BaseTypedef;
void is_same()
{
- int t01[T(__is_same(Base, Base))];
- int t02[T(__is_same(Base, BaseTypedef))];
- int t03[T(__is_same(TemplateClass<int, int>, TemplateAlias<int>))];
+ static_assert(__is_same(Base, Base), "");
+ static_assert(__is_same(Base, BaseTypedef), "");
+ static_assert(__is_same(TemplateClass<int, int>, TemplateAlias<int>), "");
- int t10[F(__is_same(Base, const Base))];
- int t11[F(__is_same(Base, Base&))];
- int t12[F(__is_same(Base, Derived))];
+ static_assert(!__is_same(Base, const Base), "");
+ static_assert(!__is_same(Base, Base&), "");
+ static_assert(!__is_same(Base, Derived), "");
// __is_same_as is a GCC compatibility synonym for __is_same.
- int t20[T(__is_same_as(int, int))];
- int t21[F(__is_same_as(int, float))];
+ static_assert(__is_same_as(int, int), "");
+ static_assert(!__is_same_as(int, float), "");
}
struct IntWrapper
@@ -2139,14 +2137,14 @@ struct FloatWrapper
void is_convertible()
{
- int t01[T(__is_convertible(IntWrapper, IntWrapper))];
- int t02[T(__is_convertible(IntWrapper, const IntWrapper))];
- int t03[T(__is_convertible(IntWrapper, int))];
- int t04[T(__is_convertible(int, IntWrapper))];
- int t05[T(__is_convertible(IntWrapper, FloatWrapper))];
- int t06[T(__is_convertible(FloatWrapper, IntWrapper))];
- int t07[T(__is_convertible(FloatWrapper, float))];
- int t08[T(__is_convertible(float, FloatWrapper))];
+ static_assert(__is_convertible(IntWrapper, IntWrapper), "");
+ static_assert(__is_convertible(IntWrapper, const IntWrapper), "");
+ static_assert(__is_convertible(IntWrapper, int), "");
+ static_assert(__is_convertible(int, IntWrapper), "");
+ static_assert(__is_convertible(IntWrapper, FloatWrapper), "");
+ static_assert(__is_convertible(FloatWrapper, IntWrapper), "");
+ static_assert(__is_convertible(FloatWrapper, float), "");
+ static_assert(__is_convertible(float, FloatWrapper), "");
}
struct FromInt { FromInt(int); };
@@ -2167,30 +2165,30 @@ struct X0 {
struct Abstract { virtual void f() = 0; };
void is_convertible_to() {
- { 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>))]; }
- { int arr[F(__is_convertible_to(Abstract, Abstract))]; }
+ static_assert(__is_convertible_to(Int, Int), "");
+ static_assert(!__is_convertible_to(Int, IntAr), "");
+ static_assert(!__is_convertible_to(IntAr, IntAr), "");
+ static_assert(__is_convertible_to(void, void), "");
+ static_assert(__is_convertible_to(cvoid, void), "");
+ static_assert(__is_convertible_to(void, cvoid), "");
+ static_assert(__is_convertible_to(cvoid, cvoid), "");
+ static_assert(__is_convertible_to(int, FromInt), "");
+ static_assert(__is_convertible_to(long, FromInt), "");
+ static_assert(__is_convertible_to(double, FromInt), "");
+ static_assert(__is_convertible_to(const int, FromInt), "");
+ static_assert(__is_convertible_to(const int&, FromInt), "");
+ static_assert(__is_convertible_to(ToInt, int), "");
+ static_assert(__is_convertible_to(ToInt, const int&), "");
+ static_assert(__is_convertible_to(ToInt, long), "");
+ static_assert(!__is_convertible_to(ToInt, int&), "");
+ static_assert(!__is_convertible_to(ToInt, FromInt), "");
+ static_assert(__is_convertible_to(IntAr&, IntAr&), "");
+ static_assert(__is_convertible_to(IntAr&, const IntAr&), "");
+ static_assert(!__is_convertible_to(const IntAr&, IntAr&), "");
+ static_assert(!__is_convertible_to(Function, Function), "");
+ static_assert(!__is_convertible_to(PrivateCopy, PrivateCopy), "");
+ static_assert(__is_convertible_to(X0<int>, X0<float>), "");
+ static_assert(!__is_convertible_to(Abstract, Abstract), "");
}
namespace is_convertible_to_instantiate {
@@ -2201,269 +2199,269 @@ namespace is_convertible_to_instantiate {
void is_trivial()
{
- { 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(IntArNB))]; }
- { 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(Derives))]; }
- { int arr[T(__is_trivial(DerivesAr))]; }
- { int arr[T(__is_trivial(DerivesArNB))]; }
- { int arr[T(__is_trivial(DerivesEmpty))]; }
- { 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(HasPriv))]; }
- { int arr[T(__is_trivial(HasProt))]; }
- { int arr[T(__is_trivial(DerivesHasPriv))]; }
- { int arr[T(__is_trivial(DerivesHasProt))]; }
- { int arr[T(__is_trivial(Vector))]; }
- { int arr[T(__is_trivial(VectorExt))]; }
-
- { int arr[F(__is_trivial(HasCons))]; }
- { int arr[F(__is_trivial(HasCopyAssign))]; }
- { int arr[F(__is_trivial(HasMoveAssign))]; }
- { 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(DerivesHasCons))]; }
- { int arr[F(__is_trivial(DerivesHasCopyAssign))]; }
- { int arr[F(__is_trivial(DerivesHasMoveAssign))]; }
- { int arr[F(__is_trivial(DerivesHasDest))]; }
- { int arr[F(__is_trivial(DerivesHasRef))]; }
- { int arr[F(__is_trivial(DerivesHasVirt))]; }
- { int arr[F(__is_trivial(void))]; }
- { int arr[F(__is_trivial(cvoid))]; }
+ static_assert(__is_trivial(int), "");
+ static_assert(__is_trivial(Enum), "");
+ static_assert(__is_trivial(POD), "");
+ static_assert(__is_trivial(Int), "");
+ static_assert(__is_trivial(IntAr), "");
+ static_assert(__is_trivial(IntArNB), "");
+ static_assert(__is_trivial(Statics), "");
+ static_assert(__is_trivial(Empty), "");
+ static_assert(__is_trivial(EmptyUnion), "");
+ static_assert(__is_trivial(Union), "");
+ static_assert(__is_trivial(Derives), "");
+ static_assert(__is_trivial(DerivesAr), "");
+ static_assert(__is_trivial(DerivesArNB), "");
+ static_assert(__is_trivial(DerivesEmpty), "");
+ static_assert(__is_trivial(HasFunc), "");
+ static_assert(__is_trivial(HasOp), "");
+ static_assert(__is_trivial(HasConv), "");
+ static_assert(__is_trivial(HasAssign), "");
+ static_assert(__is_trivial(HasAnonymousUnion), "");
+ static_assert(__is_trivial(HasPriv), "");
+ static_assert(__is_trivial(HasProt), "");
+ static_assert(__is_trivial(DerivesHasPriv), "");
+ static_assert(__is_trivial(DerivesHasProt), "");
+ static_assert(__is_trivial(Vector), "");
+ static_assert(__is_trivial(VectorExt), "");
+
+ static_assert(!__is_trivial(HasCons), "");
+ static_assert(!__is_trivial(HasCopyAssign), "");
+ static_assert(!__is_trivial(HasMoveAssign), "");
+ static_assert(!__is_trivial(HasDest), "");
+ static_assert(!__is_trivial(HasRef), "");
+ static_assert(!__is_trivial(HasNonPOD), "");
+ static_assert(!__is_trivial(HasVirt), "");
+ static_assert(!__is_trivial(DerivesHasCons), "");
+ static_assert(!__is_trivial(DerivesHasCopyAssign), "");
+ static_assert(!__is_trivial(DerivesHasMoveAssign), "");
+ static_assert(!__is_trivial(DerivesHasDest), "");
+ static_assert(!__is_trivial(DerivesHasRef), "");
+ static_assert(!__is_trivial(DerivesHasVirt), "");
+ static_assert(!__is_trivial(void), "");
+ static_assert(!__is_trivial(cvoid), "");
}
template<typename T> struct TriviallyConstructibleTemplate {};
void trivial_checks()
{
- { int arr[T(__is_trivially_copyable(int))]; }
- { int arr[T(__is_trivially_copyable(Enum))]; }
- { int arr[T(__is_trivially_copyable(POD))]; }
- { int arr[T(__is_trivially_copyable(Int))]; }
- { int arr[T(__is_trivially_copyable(IntAr))]; }
- { int arr[T(__is_trivially_copyable(IntArNB))]; }
- { int arr[T(__is_trivially_copyable(Statics))]; }
- { int arr[T(__is_trivially_copyable(Empty))]; }
- { int arr[T(__is_trivially_copyable(EmptyUnion))]; }
- { int arr[T(__is_trivially_copyable(Union))]; }
- { int arr[T(__is_trivially_copyable(Derives))]; }
- { int arr[T(__is_trivially_copyable(DerivesAr))]; }
- { int arr[T(__is_trivially_copyable(DerivesArNB))]; }
- { int arr[T(__is_trivially_copyable(DerivesEmpty))]; }
- { int arr[T(__is_trivially_copyable(HasFunc))]; }
- { int arr[T(__is_trivially_copyable(HasOp))]; }
- { int arr[T(__is_trivially_copyable(HasConv))]; }
- { int arr[T(__is_trivially_copyable(HasAssign))]; }
- { int arr[T(__is_trivially_copyable(HasAnonymousUnion))]; }
- { int arr[T(__is_trivially_copyable(HasPriv))]; }
- { int arr[T(__is_trivially_copyable(HasProt))]; }
- { int arr[T(__is_trivially_copyable(DerivesHasPriv))]; }
- { int arr[T(__is_trivially_copyable(DerivesHasProt))]; }
- { int arr[T(__is_trivially_copyable(Vector))]; }
- { int arr[T(__is_trivially_copyable(VectorExt))]; }
- { int arr[T(__is_trivially_copyable(HasCons))]; }
- { int arr[T(__is_trivially_copyable(HasRef))]; }
- { int arr[T(__is_trivially_copyable(HasNonPOD))]; }
- { int arr[T(__is_trivially_copyable(DerivesHasCons))]; }
- { int arr[T(__is_trivially_copyable(DerivesHasRef))]; }
- { int arr[T(__is_trivially_copyable(NonTrivialDefault))]; }
- { int arr[T(__is_trivially_copyable(NonTrivialDefault[]))]; }
- { int arr[T(__is_trivially_copyable(NonTrivialDefault[3]))]; }
-
- { int arr[F(__is_trivially_copyable(HasCopyAssign))]; }
- { int arr[F(__is_trivially_copyable(HasMoveAssign))]; }
- { int arr[F(__is_trivially_copyable(HasDest))]; }
- { int arr[F(__is_trivially_copyable(HasVirt))]; }
- { int arr[F(__is_trivially_copyable(DerivesHasCopyAssign))]; }
- { int arr[F(__is_trivially_copyable(DerivesHasMoveAssign))]; }
- { int arr[F(__is_trivially_copyable(DerivesHasDest))]; }
- { int arr[F(__is_trivially_copyable(DerivesHasVirt))]; }
- { int arr[F(__is_trivially_copyable(void))]; }
- { int arr[F(__is_trivially_copyable(cvoid))]; }
-
- { int arr[T((__is_trivially_constructible(int)))]; }
- { int arr[T((__is_trivially_constructible(int, int)))]; }
- { int arr[T((__is_trivially_constructible(int, float)))]; }
- { int arr[T((__is_trivially_constructible(int, int&)))]; }
- { int arr[T((__is_trivially_constructible(int, const int&)))]; }
- { int arr[T((__is_trivially_constructible(int, int)))]; }
- { int arr[T((__is_trivially_constructible(HasCopyAssign, HasCopyAssign)))]; }
- { int arr[T((__is_trivially_constructible(HasCopyAssign, const HasCopyAssign&)))]; }
- { int arr[T((__is_trivially_constructible(HasCopyAssign, HasCopyAssign&&)))]; }
- { int arr[T((__is_trivially_constructible(HasCopyAssign)))]; }
- { int arr[T((__is_trivially_constructible(NonTrivialDefault,
- const NonTrivialDefault&)))]; }
- { int arr[T((__is_trivially_constructible(NonTrivialDefault,
- NonTrivialDefault&&)))]; }
- { int arr[T((__is_trivially_constructible(AllDefaulted)))]; }
- { int arr[T((__is_trivially_constructible(AllDefaulted,
- const AllDefaulted &)))]; }
- { int arr[T((__is_trivially_constructible(AllDefaulted,
- AllDefaulted &&)))]; }
-
- { int arr[F((__is_trivially_constructible(int, int*)))]; }
- { int arr[F((__is_trivially_constructible(NonTrivialDefault)))]; }
- { int arr[F((__is_trivially_constructible(ThreeArgCtor, int*, char*, int&)))]; }
- { int arr[F((__is_trivially_constructible(AllDeleted)))]; }
- { int arr[F((__is_trivially_constructible(AllDeleted,
- const AllDeleted &)))]; }
- { int arr[F((__is_trivially_constructible(AllDeleted,
- AllDeleted &&)))]; }
- { int arr[F((__is_trivially_constructible(ExtDefaulted)))]; }
- { int arr[F((__is_trivially_constructible(ExtDefaulted,
- const ExtDefaulted &)))]; }
- { int arr[F((__is_trivially_constructible(ExtDefaulted,
- ExtDefaulted &&)))]; }
-
- { int arr[T((__is_trivially_constructible(TriviallyConstructibleTemplate<int>)))]; }
- { int arr[F((__is_trivially_constructible(class_forward)))]; } // expected-error {{incomplete type 'class_forward' used in type trait expression}}
- { int arr[F((__is_trivially_constructible(class_forward[])))]; }
- { int arr[F((__is_trivially_constructible(void)))]; }
-
- { int arr[T((__is_trivially_assignable(int&, int)))]; }
- { int arr[T((__is_trivially_assignable(int&, int&)))]; }
- { int arr[T((__is_trivially_assignable(int&, int&&)))]; }
- { int arr[T((__is_trivially_assignable(int&, const int&)))]; }
- { int arr[T((__is_trivially_assignable(POD&, POD)))]; }
- { int arr[T((__is_trivially_assignable(POD&, POD&)))]; }
- { int arr[T((__is_trivially_assignable(POD&, POD&&)))]; }
- { int arr[T((__is_trivially_assignable(POD&, const POD&)))]; }
- { int arr[T((__is_trivially_assignable(int*&, int*)))]; }
- { int arr[T((__is_trivially_assignable(AllDefaulted,
- const AllDefaulted &)))]; }
- { int arr[T((__is_trivially_assignable(AllDefaulted,
- AllDefaulted &&)))]; }
-
- { int arr[F((__is_trivially_assignable(int*&, float*)))]; }
- { int arr[F((__is_trivially_assignable(HasCopyAssign&, HasCopyAssign)))]; }
- { int arr[F((__is_trivially_assignable(HasCopyAssign&, HasCopyAssign&)))]; }
- { int arr[F((__is_trivially_assignable(HasCopyAssign&, const HasCopyAssign&)))]; }
- { int arr[F((__is_trivially_assignable(HasCopyAssign&, HasCopyAssign&&)))]; }
- { int arr[F((__is_trivially_assignable(TrivialMoveButNotCopy&,
- TrivialMoveButNotCopy&)))]; }
- { int arr[F((__is_trivially_assignable(TrivialMoveButNotCopy&,
- const TrivialMoveButNotCopy&)))]; }
- { int arr[F((__is_trivially_assignable(AllDeleted,
- const AllDeleted &)))]; }
- { int arr[F((__is_trivially_assignable(AllDeleted,
- AllDeleted &&)))]; }
- { int arr[F((__is_trivially_assignable(ExtDefaulted,
- const ExtDefaulted &)))]; }
- { int arr[F((__is_trivially_assignable(ExtDefaulted,
- ExtDefaulted &&)))]; }
-
- { int arr[T((__is_trivially_assignable(HasDefaultTrivialCopyAssign&,
- HasDefaultTrivialCopyAssign&)))]; }
- { int arr[T((__is_trivially_assignable(HasDefaultTrivialCopyAssign&,
- const HasDefaultTrivialCopyAssign&)))]; }
- { int arr[T((__is_trivially_assignable(TrivialMoveButNotCopy&,
- TrivialMoveButNotCopy)))]; }
- { int arr[T((__is_trivially_assignable(TrivialMoveButNotCopy&,
- TrivialMoveButNotCopy&&)))]; }
- { int arr[T((__is_trivially_assignable(int&, int)))]; }
- { int arr[T((__is_trivially_assignable(int&, int&)))]; }
- { int arr[T((__is_trivially_assignable(int&, int&&)))]; }
- { int arr[T((__is_trivially_assignable(int&, const int&)))]; }
- { int arr[T((__is_trivially_assignable(POD&, POD)))]; }
- { int arr[T((__is_trivially_assignable(POD&, POD&)))]; }
- { int arr[T((__is_trivially_assignable(POD&, POD&&)))]; }
- { int arr[T((__is_trivially_assignable(POD&, const POD&)))]; }
- { int arr[T((__is_trivially_assignable(int*&, int*)))]; }
- { int arr[T((__is_trivially_assignable(AllDefaulted,
- const AllDefaulted &)))]; }
- { int arr[T((__is_trivially_assignable(AllDefaulted,
- AllDefaulted &&)))]; }
-
- { int arr[F((__is_assignable(int *&, float *)))]; }
- { int arr[T((__is_assignable(HasCopyAssign &, HasCopyAssign)))]; }
- { int arr[T((__is_assignable(HasCopyAssign &, HasCopyAssign &)))]; }
- { int arr[T((__is_assignable(HasCopyAssign &, const HasCopyAssign &)))]; }
- { int arr[T((__is_assignable(HasCopyAssign &, HasCopyAssign &&)))]; }
- { int arr[T((__is_assignable(TrivialMoveButNotCopy &,
- TrivialMoveButNotCopy &)))]; }
- { int arr[T((__is_assignable(TrivialMoveButNotCopy &,
- const TrivialMoveButNotCopy &)))]; }
- { int arr[F((__is_assignable(AllDeleted,
- const AllDeleted &)))]; }
- { int arr[F((__is_assignable(AllDeleted,
- AllDeleted &&)))]; }
- { int arr[T((__is_assignable(ExtDefaulted,
- const ExtDefaulted &)))]; }
- { int arr[T((__is_assignable(ExtDefaulted,
- ExtDefaulted &&)))]; }
-
- { int arr[T((__is_assignable(HasDefaultTrivialCopyAssign &,
- HasDefaultTrivialCopyAssign &)))]; }
- { int arr[T((__is_assignable(HasDefaultTrivialCopyAssign &,
- const HasDefaultTrivialCopyAssign &)))]; }
- { int arr[T((__is_assignable(TrivialMoveButNotCopy &,
- TrivialMoveButNotCopy)))]; }
- { int arr[T((__is_assignable(TrivialMoveButNotCopy &,
- TrivialMoveButNotCopy &&)))]; }
-
- { int arr[T(__is_assignable(ACompleteType, ACompleteType))]; }
- { int arr[F(__is_assignable(AnIncompleteType, AnIncompleteType))]; } // expected-error {{incomplete type}}
- { int arr[F(__is_assignable(AnIncompleteType[], AnIncompleteType[]))]; }
- { int arr[F(__is_assignable(AnIncompleteType[1], AnIncompleteType[1]))]; } // expected-error {{incomplete type}}
- { int arr[F(__is_assignable(void, void))]; }
- { int arr[F(__is_assignable(const volatile void, const volatile void))]; }
+ static_assert(__is_trivially_copyable(int), "");
+ static_assert(__is_trivially_copyable(Enum), "");
+ static_assert(__is_trivially_copyable(POD), "");
+ static_assert(__is_trivially_copyable(Int), "");
+ static_assert(__is_trivially_copyable(IntAr), "");
+ static_assert(__is_trivially_copyable(IntArNB), "");
+ static_assert(__is_trivially_copyable(Statics), "");
+ static_assert(__is_trivially_copyable(Empty), "");
+ static_assert(__is_trivially_copyable(EmptyUnion), "");
+ static_assert(__is_trivially_copyable(Union), "");
+ static_assert(__is_trivially_copyable(Derives), "");
+ static_assert(__is_trivially_copyable(DerivesAr), "");
+ static_assert(__is_trivially_copyable(DerivesArNB), "");
+ static_assert(__is_trivially_copyable(DerivesEmpty), "");
+ static_assert(__is_trivially_copyable(HasFunc), "");
+ static_assert(__is_trivially_copyable(HasOp), "");
+ static_assert(__is_trivially_copyable(HasConv), "");
+ static_assert(__is_trivially_copyable(HasAssign), "");
+ static_assert(__is_trivially_copyable(HasAnonymousUnion), "");
+ static_assert(__is_trivially_copyable(HasPriv), "");
+ static_assert(__is_trivially_copyable(HasProt), "");
+ static_assert(__is_trivially_copyable(DerivesHasPriv), "");
+ static_assert(__is_trivially_copyable(DerivesHasProt), "");
+ static_assert(__is_trivially_copyable(Vector), "");
+ static_assert(__is_trivially_copyable(VectorExt), "");
+ static_assert(__is_trivially_copyable(HasCons), "");
+ static_assert(__is_trivially_copyable(HasRef), "");
+ static_assert(__is_trivially_copyable(HasNonPOD), "");
+ static_assert(__is_trivially_copyable(DerivesHasCons), "");
+ static_assert(__is_trivially_copyable(DerivesHasRef), "");
+ static_assert(__is_trivially_copyable(NonTrivialDefault), "");
+ static_assert(__is_trivially_copyable(NonTrivialDefault[]), "");
+ static_assert(__is_trivially_copyable(NonTrivialDefault[3]), "");
+
+ static_assert(!__is_trivially_copyable(HasCopyAssign), "");
+ static_assert(!__is_trivially_copyable(HasMoveAssign), "");
+ static_assert(!__is_trivially_copyable(HasDest), "");
+ static_assert(!__is_trivially_copyable(HasVirt), "");
+ static_assert(!__is_trivially_copyable(DerivesHasCopyAssign), "");
+ static_assert(!__is_trivially_copyable(DerivesHasMoveAssign), "");
+ static_assert(!__is_trivially_copyable(DerivesHasDest), "");
+ static_assert(!__is_trivially_copyable(DerivesHasVirt), "");
+ static_assert(!__is_trivially_copyable(void), "");
+ static_assert(!__is_trivially_copyable(cvoid), "");
+
+ static_assert((__is_trivially_constructible(int)), "");
+ static_assert((__is_trivially_constructible(int, int)), "");
+ static_assert((__is_trivially_constructible(int, float)), "");
+ static_assert((__is_trivially_constructible(int, int&)), "");
+ static_assert((__is_trivially_constructible(int, const int&)), "");
+ static_assert((__is_trivially_constructible(int, int)), "");
+ static_assert((__is_trivially_constructible(HasCopyAssign, HasCopyAssign)), "");
+ static_assert((__is_trivially_constructible(HasCopyAssign, const HasCopyAssign&)), "");
+ static_assert((__is_trivially_constructible(HasCopyAssign, HasCopyAssign&&)), "");
+ static_assert((__is_trivially_constructible(HasCopyAssign)), "");
+ static_assert((__is_trivially_constructible(NonTrivialDefault,
+ const NonTrivialDefault&)), "");
+ static_assert((__is_trivially_constructible(NonTrivialDefault,
+ NonTrivialDefault&&)), "");
+ static_assert((__is_trivially_constructible(AllDefaulted)), "");
+ static_assert((__is_trivially_constructible(AllDefaulted,
+ const AllDefaulted &)), "");
+ static_assert((__is_trivially_constructible(AllDefaulted,
+ AllDefaulted &&)), "");
+
+ static_assert(!(__is_trivially_constructible(int, int*)), "");
+ static_assert(!(__is_trivially_constructible(NonTrivialDefault)), "");
+ static_assert(!(__is_trivially_constructible(ThreeArgCtor, int*, char*, int&)), "");
+ static_assert(!(__is_trivially_constructible(AllDeleted)), "");
+ static_assert(!(__is_trivially_constructible(AllDeleted,
+ const AllDeleted &)), "");
+ static_assert(!(__is_trivially_constructible(AllDeleted,
+ AllDeleted &&)), "");
+ static_assert(!(__is_trivially_constructible(ExtDefaulted)), "");
+ static_assert(!(__is_trivially_constructible(ExtDefaulted,
+ const ExtDefaulted &)), "");
+ static_assert(!(__is_trivially_constructible(ExtDefaulted,
+ ExtDefaulted &&)), "");
+
+ static_assert((__is_trivially_constructible(TriviallyConstructibleTemplate<int>)), "");
+ static_assert(!(__is_trivially_constructible(class_forward)), ""); // expected-error {{incomplete type 'class_forward' used in type trait expression}}
+ static_assert(!(__is_trivially_constructible(class_forward[])), "");
+ static_assert(!(__is_trivially_constructible(void)), "");
+
+ static_assert((__is_trivially_assignable(int&, int)), "");
+ static_assert((__is_trivially_assignable(int&, int&)), "");
+ static_assert((__is_trivially_assignable(int&, int&&)), "");
+ static_assert((__is_trivially_assignable(int&, const int&)), "");
+ static_assert((__is_trivially_assignable(POD&, POD)), "");
+ static_assert((__is_trivially_assignable(POD&, POD&)), "");
+ static_assert((__is_trivially_assignable(POD&, POD&&)), "");
+ static_assert((__is_trivially_assignable(POD&, const POD&)), "");
+ static_assert((__is_trivially_assignable(int*&, int*)), "");
+ static_assert((__is_trivially_assignable(AllDefaulted,
+ const AllDefaulted &)), "");
+ static_assert((__is_trivially_assignable(AllDefaulted,
+ AllDefaulted &&)), "");
+
+ static_assert(!(__is_trivially_assignable(int*&, float*)), "");
+ static_assert(!(__is_trivially_assignable(HasCopyAssign&, HasCopyAssign)), "");
+ static_assert(!(__is_trivially_assignable(HasCopyAssign&, HasCopyAssign&)), "");
+ static_assert(!(__is_trivially_assignable(HasCopyAssign&, const HasCopyAssign&)), "");
+ static_assert(!(__is_trivially_assignable(HasCopyAssign&, HasCopyAssign&&)), "");
+ static_assert(!(__is_trivially_assignable(TrivialMoveButNotCopy&,
+ TrivialMoveButNotCopy&)), "");
+ static_assert(!(__is_trivially_assignable(TrivialMoveButNotCopy&,
+ const TrivialMoveButNotCopy&)), "");
+ static_assert(!(__is_trivially_assignable(AllDeleted,
+ const AllDeleted &)), "");
+ static_assert(!(__is_trivially_assignable(AllDeleted,
+ AllDeleted &&)), "");
+ static_assert(!(__is_trivially_assignable(ExtDefaulted,
+ const ExtDefaulted &)), "");
+ static_assert(!(__is_trivially_assignable(ExtDefaulted,
+ ExtDefaulted &&)), "");
+
+ static_assert((__is_trivially_assignable(HasDefaultTrivialCopyAssign&,
+ HasDefaultTrivialCopyAssign&)), "");
+ static_assert((__is_trivially_assignable(HasDefaultTrivialCopyAssign&,
+ const HasDefaultTrivialCopyAssign&)), "");
+ static_assert((__is_trivially_assignable(TrivialMoveButNotCopy&,
+ TrivialMoveButNotCopy)), "");
+ static_assert((__is_trivially_assignable(TrivialMoveButNotCopy&,
+ TrivialMoveButNotCopy&&)), "");
+ static_assert((__is_trivially_assignable(int&, int)), "");
+ static_assert((__is_trivially_assignable(int&, int&)), "");
+ static_assert((__is_trivially_assignable(int&, int&&)), "");
+ static_assert((__is_trivially_assignable(int&, const int&)), "");
+ static_assert((__is_trivially_assignable(POD&, POD)), "");
+ static_assert((__is_trivially_assignable(POD&, POD&)), "");
+ static_assert((__is_trivially_assignable(POD&, POD&&)), "");
+ static_assert((__is_trivially_assignable(POD&, const POD&)), "");
+ static_assert((__is_trivially_assignable(int*&, int*)), "");
+ static_assert((__is_trivially_assignable(AllDefaulted,
+ const AllDefaulted &)), "");
+ static_assert((__is_trivially_assignable(AllDefaulted,
+ AllDefaulted &&)), "");
+
+ static_assert(!(__is_assignable(int *&, float *)), "");
+ static_assert((__is_assignable(HasCopyAssign &, HasCopyAssign)), "");
+ static_assert((__is_assignable(HasCopyAssign &, HasCopyAssign &)), "");
+ static_assert((__is_assignable(HasCopyAssign &, const HasCopyAssign &)), "");
+ static_assert((__is_assignable(HasCopyAssign &, HasCopyAssign &&)), "");
+ static_assert((__is_assignable(TrivialMoveButNotCopy &,
+ TrivialMoveButNotCopy &)), "");
+ static_assert((__is_assignable(TrivialMoveButNotCopy &,
+ const TrivialMoveButNotCopy &)), "");
+ static_assert(!(__is_assignable(AllDeleted,
+ const AllDeleted &)), "");
+ static_assert(!(__is_assignable(AllDeleted,
+ AllDeleted &&)), "");
+ static_assert((__is_assignable(ExtDefaulted,
+ const ExtDefaulted &)), "");
+ static_assert((__is_assignable(ExtDefaulted,
+ ExtDefaulted &&)), "");
+
+ static_assert((__is_assignable(HasDefaultTrivialCopyAssign &,
+ HasDefaultTrivialCopyAssign &)), "");
+ static_assert((__is_assignable(HasDefaultTrivialCopyAssign &,
+ const HasDefaultTrivialCopyAssign &)), "");
+ static_assert((__is_assignable(TrivialMoveButNotCopy &,
+ TrivialMoveButNotCopy)), "");
+ static_assert((__is_assignable(TrivialMoveButNotCopy &,
+ TrivialMoveButNotCopy &&)), "");
+
+ static_assert(__is_assignable(ACompleteType, ACompleteType), "");
+ static_assert(!__is_assignable(AnIncompleteType, AnIncompleteType), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_assignable(AnIncompleteType[], AnIncompleteType[]), "");
+ static_assert(!__is_assignable(AnIncompleteType[1], AnIncompleteType[1]), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_assignable(void, void), "");
+ static_assert(!__is_assignable(const volatile void, const volatile void), "");
}
void constructible_checks() {
- { int arr[T(__is_constructible(HasNoThrowConstructorWithArgs))]; }
- { int arr[F(__is_nothrow_constructible(HasNoThrowConstructorWithArgs))]; } // MSVC doesn't look into default args and gets this wrong.
+ static_assert(__is_constructible(HasNoThrowConstructorWithArgs), "");
+ static_assert(!__is_nothrow_constructible(HasNoThrowConstructorWithArgs), ""); // MSVC doesn't look into default args and gets this wrong.
- { int arr[T(__is_constructible(HasNoThrowConstructorWithArgs, HasCons))]; }
- { int arr[T(__is_nothrow_constructible(HasNoThrowConstructorWithArgs, HasCons))]; }
+ static_assert(__is_constructible(HasNoThrowConstructorWithArgs, HasCons), "");
+ static_assert(__is_nothrow_constructible(HasNoThrowConstructorWithArgs, HasCons), "");
- { int arr[T(__is_constructible(NonTrivialDefault))]; }
- { int arr[F(__is_nothrow_constructible(NonTrivialDefault))]; }
+ static_assert(__is_constructible(NonTrivialDefault), "");
+ static_assert(!__is_nothrow_constructible(NonTrivialDefault), "");
- { int arr[T(__is_constructible(int))]; }
- { int arr[T(__is_nothrow_constructible(int))]; }
+ static_assert(__is_constructible(int), "");
+ static_assert(__is_nothrow_constructible(int), "");
- { int arr[F(__is_constructible(NonPOD))]; }
- { int arr[F(__is_nothrow_constructible(NonPOD))]; }
+ static_assert(!__is_constructible(NonPOD), "");
+ static_assert(!__is_nothrow_constructible(NonPOD), "");
- { int arr[T(__is_constructible(NonPOD, int))]; }
- { int arr[F(__is_nothrow_constructible(NonPOD, int))]; }
+ static_assert(__is_constructible(NonPOD, int), "");
+ static_assert(!__is_nothrow_constructible(NonPOD, int), "");
// PR19178
- { int arr[F(__is_constructible(Abstract))]; }
- { int arr[F(__is_nothrow_constructible(Abstract))]; }
+ static_assert(!__is_constructible(Abstract), "");
+ static_assert(!__is_nothrow_constructible(Abstract), "");
// PR20228
- { int arr[T(__is_constructible(VariadicCtor,
- int, int, int, int, int, int, int, int, int))]; }
+ static_assert(__is_constructible(VariadicCtor,
+ int, int, int, int, int, int, int, int, int), "");
// PR25513
- { int arr[F(__is_constructible(int(int)))]; }
- { int arr[T(__is_constructible(int const &, long))]; }
-
- { int arr[T(__is_constructible(ACompleteType))]; }
- { int arr[T(__is_nothrow_constructible(ACompleteType))]; }
- { int arr[F(__is_constructible(AnIncompleteType))]; } // expected-error {{incomplete type}}
- { int arr[F(__is_nothrow_constructible(AnIncompleteType))]; } // expected-error {{incomplete type}}
- { int arr[F(__is_constructible(AnIncompleteType[]))]; }
- { int arr[F(__is_nothrow_constructible(AnIncompleteType[]))]; }
- { int arr[F(__is_constructible(AnIncompleteType[1]))]; } // expected-error {{incomplete type}}
- { int arr[F(__is_nothrow_constructible(AnIncompleteType[1]))]; } // expected-error {{incomplete type}}
- { int arr[F(__is_constructible(void))]; }
- { int arr[F(__is_nothrow_constructible(void))]; }
- { int arr[F(__is_constructible(const volatile void))]; }
- { int arr[F(__is_nothrow_constructible(const volatile void))]; }
+ static_assert(!__is_constructible(int(int)), "");
+ static_assert(__is_constructible(int const &, long), "");
+
+ static_assert(__is_constructible(ACompleteType), "");
+ static_assert(__is_nothrow_constructible(ACompleteType), "");
+ static_assert(!__is_constructible(AnIncompleteType), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_nothrow_constructible(AnIncompleteType), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_constructible(AnIncompleteType[]), "");
+ static_assert(!__is_nothrow_constructible(AnIncompleteType[]), "");
+ static_assert(!__is_constructible(AnIncompleteType[1]), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_nothrow_constructible(AnIncompleteType[1]), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_constructible(void), "");
+ static_assert(!__is_nothrow_constructible(void), "");
+ static_assert(!__is_constructible(const volatile void), "");
+ static_assert(!__is_nothrow_constructible(const volatile void), "");
}
// Instantiation of __is_trivially_constructible
@@ -2473,32 +2471,32 @@ struct is_trivially_constructible {
};
void is_trivially_constructible_test() {
- { int arr[T((is_trivially_constructible<int>::value))]; }
- { int arr[T((is_trivially_constructible<int, int>::value))]; }
- { int arr[T((is_trivially_constructible<int, float>::value))]; }
- { int arr[T((is_trivially_constructible<int, int&>::value))]; }
- { int arr[T((is_trivially_constructible<int, const int&>::value))]; }
- { int arr[T((is_trivially_constructible<int, int>::value))]; }
- { int arr[T((is_trivially_constructible<HasCopyAssign, HasCopyAssign>::value))]; }
- { int arr[T((is_trivially_constructible<HasCopyAssign, const HasCopyAssign&>::value))]; }
- { int arr[T((is_trivially_constructible<HasCopyAssign, HasCopyAssign&&>::value))]; }
- { int arr[T((is_trivially_constructible<HasCopyAssign>::value))]; }
- { int arr[T((is_trivially_constructible<NonTrivialDefault,
- const NonTrivialDefault&>::value))]; }
- { int arr[T((is_trivially_constructible<NonTrivialDefault,
- NonTrivialDefault&&>::value))]; }
-
- { int arr[F((is_trivially_constructible<int, int*>::value))]; }
- { int arr[F((is_trivially_constructible<NonTrivialDefault>::value))]; }
- { int arr[F((is_trivially_constructible<ThreeArgCtor, int*, char*, int&>::value))]; }
- { int arr[F((is_trivially_constructible<Abstract>::value))]; } // PR19178
-
- { int arr[T(__is_trivially_constructible(ACompleteType))]; }
- { int arr[F(__is_trivially_constructible(AnIncompleteType))]; } // expected-error {{incomplete type}}
- { int arr[F(__is_trivially_constructible(AnIncompleteType[]))]; }
- { int arr[F(__is_trivially_constructible(AnIncompleteType[1]))]; } // expected-error {{incomplete type}}
- { int arr[F(__is_trivially_constructible(void))]; }
- { int arr[F(__is_trivially_constructible(const volatile void))]; }
+ static_assert((is_trivially_constructible<int>::value), "");
+ static_assert((is_trivially_constructible<int, int>::value), "");
+ static_assert((is_trivially_constructible<int, float>::value), "");
+ static_assert((is_trivially_constructible<int, int&>::value), "");
+ static_assert((is_trivially_constructible<int, const int&>::value), "");
+ static_assert((is_trivially_constructible<int, int>::value), "");
+ static_assert((is_trivially_constructible<HasCopyAssign, HasCopyAssign>::value), "");
+ static_assert((is_trivially_constructible<HasCopyAssign, const HasCopyAssign&>::value), "");
+ static_assert((is_trivially_constructible<HasCopyAssign, HasCopyAssign&&>::value), "");
+ static_assert((is_trivially_constructible<HasCopyAssign>::value), "");
+ static_assert((is_trivially_constructible<NonTrivialDefault,
+ const NonTrivialDefault&>::value), "");
+ static_assert((is_trivially_constructible<NonTrivialDefault,
+ NonTrivialDefault&&>::value), "");
+
+ static_assert(!(is_trivially_constructible<int, int*>::value), "");
+ static_assert(!(is_trivially_constructible<NonTrivialDefault>::value), "");
+ static_assert(!(is_trivially_constructible<ThreeArgCtor, int*, char*, int&>::value), "");
+ static_assert(!(is_trivially_constructible<Abstract>::value), ""); // PR19178
+
+ static_assert(__is_trivially_constructible(ACompleteType), "");
+ static_assert(!__is_trivially_constructible(AnIncompleteType), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_trivially_constructible(AnIncompleteType[]), "");
+ static_assert(!__is_trivially_constructible(AnIncompleteType[1]), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_trivially_constructible(void), "");
+ static_assert(!__is_trivially_constructible(const volatile void), "");
}
template <class T, class RefType = T &>
@@ -2508,38 +2506,38 @@ struct ConvertsToRef {
};
void reference_binds_to_temporary_checks() {
- { int arr[F((__reference_binds_to_temporary(int &, int &)))]; }
- { int arr[F((__reference_binds_to_temporary(int &, int &&)))]; }
+ static_assert(!(__reference_binds_to_temporary(int &, int &)), "");
+ static_assert(!(__reference_binds_to_temporary(int &, int &&)), "");
- { int arr[F((__reference_binds_to_temporary(int const &, int &)))]; }
- { int arr[F((__reference_binds_to_temporary(int const &, int const &)))]; }
- { int arr[F((__reference_binds_to_temporary(int const &, int &&)))]; }
+ static_assert(!(__reference_binds_to_temporary(int const &, int &)), "");
+ static_assert(!(__reference_binds_to_temporary(int const &, int const &)), "");
+ static_assert(!(__reference_binds_to_temporary(int const &, int &&)), "");
- { int arr[F((__reference_binds_to_temporary(int &, long &)))]; } // doesn't construct
- { int arr[T((__reference_binds_to_temporary(int const &, long &)))]; }
- { int arr[T((__reference_binds_to_temporary(int const &, long &&)))]; }
- { int arr[T((__reference_binds_to_temporary(int &&, long &)))]; }
+ static_assert(!(__reference_binds_to_temporary(int &, long &)), ""); // doesn't construct
+ static_assert((__reference_binds_to_temporary(int const &, long &)), "");
+ static_assert((__reference_binds_to_temporary(int const &, long &&)), "");
+ static_assert((__reference_binds_to_temporary(int &&, long &)), "");
using LRef = ConvertsToRef<int, int &>;
using RRef = ConvertsToRef<int, int &&>;
using CLRef = ConvertsToRef<int, const int &>;
using LongRef = ConvertsToRef<long, long &>;
- { int arr[T((__is_constructible(int &, LRef)))]; }
- { int arr[F((__reference_binds_to_temporary(int &, LRef)))]; }
+ static_assert((__is_constructible(int &, LRef)), "");
+ static_assert(!(__reference_binds_to_temporary(int &, LRef)), "");
- { int arr[T((__is_constructible(int &&, RRef)))]; }
- { int arr[F((__reference_binds_to_temporary(int &&, RRef)))]; }
+ static_assert((__is_constructible(int &&, RRef)), "");
+ static_assert(!(__reference_binds_to_temporary(int &&, RRef)), "");
- { int arr[T((__is_constructible(int const &, CLRef)))]; }
- { int arr[F((__reference_binds_to_temporary(int &&, CLRef)))]; }
+ static_assert((__is_constructible(int const &, CLRef)), "");
+ static_assert(!(__reference_binds_to_temporary(int &&, CLRef)), "");
- { int arr[T((__is_constructible(int const &, LongRef)))]; }
- { int arr[T((__reference_binds_to_temporary(int const &, LongRef)))]; }
+ static_assert((__is_constructible(int const &, LongRef)), "");
+ static_assert((__reference_binds_to_temporary(int const &, LongRef)), "");
// Test that it doesn't accept non-reference types as input.
- { int arr[F((__reference_binds_to_temporary(int, long)))]; }
+ static_assert(!(__reference_binds_to_temporary(int, long)), "");
- { int arr[T((__reference_binds_to_temporary(const int &, long)))]; }
+ static_assert((__reference_binds_to_temporary(const int &, long)), "");
}
void reference_constructs_from_temporary_checks() {
@@ -2588,81 +2586,81 @@ void reference_constructs_from_temporary_checks() {
}
void array_rank() {
- int t01[T(__array_rank(IntAr) == 1)];
- int t02[T(__array_rank(ConstIntArAr) == 2)];
+ static_assert(__array_rank(IntAr) == 1, "");
+ static_assert(__array_rank(ConstIntArAr) == 2, "");
}
void array_extent() {
- int t01[T(__array_extent(IntAr, 0) == 10)];
- int t02[T(__array_extent(ConstIntArAr, 0) == 4)];
- int t03[T(__array_extent(ConstIntArAr, 1) == 10)];
+ static_assert(__array_extent(IntAr, 0) == 10, "");
+ static_assert(__array_extent(ConstIntArAr, 0) == 4, "");
+ static_assert(__array_extent(ConstIntArAr, 1) == 10, "");
}
void is_destructible_test() {
- { int arr[T(__is_destructible(int))]; }
- { int arr[T(__is_destructible(int[2]))]; }
- { int arr[F(__is_destructible(int[]))]; }
- { int arr[F(__is_destructible(void))]; }
- { int arr[T(__is_destructible(int &))]; }
- { int arr[T(__is_destructible(HasDest))]; }
- { int arr[F(__is_destructible(AllPrivate))]; }
- { int arr[T(__is_destructible(SuperNonTrivialStruct))]; }
- { int arr[T(__is_destructible(AllDefaulted))]; }
- { int arr[F(__is_destructible(AllDeleted))]; }
- { int arr[T(__is_destructible(ThrowingDtor))]; }
- { int arr[T(__is_destructible(NoThrowDtor))]; }
-
- { int arr[T(__is_destructible(ACompleteType))]; }
- { int arr[F(__is_destructible(AnIncompleteType))]; } // expected-error {{incomplete type}}
- { int arr[F(__is_destructible(AnIncompleteType[]))]; }
- { int arr[F(__is_destructible(AnIncompleteType[1]))]; } // expected-error {{incomplete type}}
- { int arr[F(__is_destructible(void))]; }
- { int arr[F(__is_destructible(const volatile void))]; }
+ static_assert(__is_destructible(int), "");
+ static_assert(__is_destructible(int[2]), "");
+ static_assert(!__is_destructible(int[]), "");
+ static_assert(!__is_destructible(void), "");
+ static_assert(__is_destructible(int &), "");
+ static_assert(__is_destructible(HasDest), "");
+ static_assert(!__is_destructible(AllPrivate), "");
+ static_assert(__is_destructible(SuperNonTrivialStruct), "");
+ static_assert(__is_destructible(AllDefaulted), "");
+ static_assert(!__is_destructible(AllDeleted), "");
+ static_assert(__is_destructible(ThrowingDtor), "");
+ static_assert(__is_destructible(NoThrowDtor), "");
+
+ static_assert(__is_destructible(ACompleteType), "");
+ static_assert(!__is_destructible(AnIncompleteType), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_destructible(AnIncompleteType[]), "");
+ static_assert(!__is_destructible(AnIncompleteType[1]), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_destructible(void), "");
+ static_assert(!__is_destructible(const volatile void), "");
}
void is_nothrow_destructible_test() {
- { int arr[T(__is_nothrow_destructible(int))]; }
- { int arr[T(__is_nothrow_destructible(int[2]))]; }
- { int arr[F(__is_nothrow_destructible(int[]))]; }
- { int arr[F(__is_nothrow_destructible(void))]; }
- { int arr[T(__is_nothrow_destructible(int &))]; }
- { int arr[T(__is_nothrow_destructible(HasDest))]; }
- { int arr[F(__is_nothrow_destructible(AllPrivate))]; }
- { int arr[T(__is_nothrow_destructible(SuperNonTrivialStruct))]; }
- { int arr[T(__is_nothrow_destructible(AllDefaulted))]; }
- { int arr[F(__is_nothrow_destructible(AllDeleted))]; }
- { int arr[F(__is_nothrow_destructible(ThrowingDtor))]; }
- { int arr[T(__is_nothrow_destructible(NoExceptDtor))]; }
- { int arr[T(__is_nothrow_destructible(NoThrowDtor))]; }
-
- { int arr[T(__is_nothrow_destructible(ACompleteType))]; }
- { int arr[F(__is_nothrow_destructible(AnIncompleteType))]; } // expected-error {{incomplete type}}
- { int arr[F(__is_nothrow_destructible(AnIncompleteType[]))]; }
- { int arr[F(__is_nothrow_destructible(AnIncompleteType[1]))]; } // expected-error {{incomplete type}}
- { int arr[F(__is_nothrow_destructible(void))]; }
- { int arr[F(__is_nothrow_destructible(const volatile void))]; }
+ static_assert(__is_nothrow_destructible(int), "");
+ static_assert(__is_nothrow_destructible(int[2]), "");
+ static_assert(!__is_nothrow_destructible(int[]), "");
+ static_assert(!__is_nothrow_destructible(void), "");
+ static_assert(__is_nothrow_destructible(int &), "");
+ static_assert(__is_nothrow_destructible(HasDest), "");
+ static_assert(!__is_nothrow_destructible(AllPrivate), "");
+ static_assert(__is_nothrow_destructible(SuperNonTrivialStruct), "");
+ static_assert(__is_nothrow_destructible(AllDefaulted), "");
+ static_assert(!__is_nothrow_destructible(AllDeleted), "");
+ static_assert(!__is_nothrow_destructible(ThrowingDtor), "");
+ static_assert(__is_nothrow_destructible(NoExceptDtor), "");
+ static_assert(__is_nothrow_destructible(NoThrowDtor), "");
+
+ static_assert(__is_nothrow_destructible(ACompleteType), "");
+ static_assert(!__is_nothrow_destructible(AnIncompleteType), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_nothrow_destructible(AnIncompleteType[]), "");
+ static_assert(!__is_nothrow_destructible(AnIncompleteType[1]), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_nothrow_destructible(void), "");
+ static_assert(!__is_nothrow_destructible(const volatile void), "");
}
void is_trivially_destructible_test() {
- { int arr[T(__is_trivially_destructible(int))]; }
- { int arr[T(__is_trivially_destructible(int[2]))]; }
- { int arr[F(__is_trivially_destructible(int[]))]; }
- { int arr[F(__is_trivially_destructible(void))]; }
- { int arr[T(__is_trivially_destructible(int &))]; }
- { int arr[F(__is_trivially_destructible(HasDest))]; }
- { int arr[F(__is_trivially_destructible(AllPrivate))]; }
- { int arr[F(__is_trivially_destructible(SuperNonTrivialStruct))]; }
- { int arr[T(__is_trivially_destructible(AllDefaulted))]; }
- { int arr[F(__is_trivially_destructible(AllDeleted))]; }
- { int arr[F(__is_trivially_destructible(ThrowingDtor))]; }
- { int arr[F(__is_trivially_destructible(NoThrowDtor))]; }
-
- { int arr[T(__is_trivially_destructible(ACompleteType))]; }
- { int arr[F(__is_trivially_destructible(AnIncompleteType))]; } // expected-error {{incomplete type}}
- { int arr[F(__is_trivially_destructible(AnIncompleteType[]))]; }
- { int arr[F(__is_trivially_destructible(AnIncompleteType[1]))]; } // expected-error {{incomplete type}}
- { int arr[F(__is_trivially_destructible(void))]; }
- { int arr[F(__is_trivially_destructible(const volatile void))]; }
+ static_assert(__is_trivially_destructible(int), "");
+ static_assert(__is_trivially_destructible(int[2]), "");
+ static_assert(!__is_trivially_destructible(int[]), "");
+ static_assert(!__is_trivially_destructible(void), "");
+ static_assert(__is_trivially_destructible(int &), "");
+ static_assert(!__is_trivially_destructible(HasDest), "");
+ static_assert(!__is_trivially_destructible(AllPrivate), "");
+ static_assert(!__is_trivially_destructible(SuperNonTrivialStruct), "");
+ static_assert(__is_trivially_destructible(AllDefaulted), "");
+ static_assert(!__is_trivially_destructible(AllDeleted), "");
+ static_assert(!__is_trivially_destructible(ThrowingDtor), "");
+ static_assert(!__is_trivially_destructible(NoThrowDtor), "");
+
+ static_assert(__is_trivially_destructible(ACompleteType), "");
+ static_assert(!__is_trivially_destructible(AnIncompleteType), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_trivially_destructible(AnIncompleteType[]), "");
+ static_assert(!__is_trivially_destructible(AnIncompleteType[1]), ""); // expected-error {{incomplete type}}
+ static_assert(!__is_trivially_destructible(void), "");
+ static_assert(!__is_trivially_destructible(const volatile void), "");
}
// Instantiation of __has_unique_object_representations
>From 7c6f7badf9382b413b808368879620a1c398d32a Mon Sep 17 00:00:00 2001
From: Amirreza Ashouri <ar.ashouri999 at gmail.com>
Date: Wed, 10 Jan 2024 14:38:59 +0330
Subject: [PATCH 2/3] [clang][NFC] Use `__is_base_of` builtin in lieu of
`isBaseOfT` and `isBaseOfF`
---
clang/test/SemaCXX/type-traits.cpp | 21 ++++++---------------
1 file changed, 6 insertions(+), 15 deletions(-)
diff --git a/clang/test/SemaCXX/type-traits.cpp b/clang/test/SemaCXX/type-traits.cpp
index c0d5fba5c356f0..0cb986d176c28b 100644
--- a/clang/test/SemaCXX/type-traits.cpp
+++ b/clang/test/SemaCXX/type-traits.cpp
@@ -2027,15 +2027,6 @@ template<typename T> struct CrazyDerived : T { };
class class_forward; // expected-note 2 {{forward declaration of 'class_forward'}}
-template <typename Base, typename Derived>
-void isBaseOfT() {
- static_assert(__is_base_of(Base, Derived), "");
-};
-template <typename Base, typename Derived>
-void isBaseOfF() {
- static_assert(!__is_base_of(Base, Derived), "");
-};
-
template <class T> class DerivedTemp : Base {};
template <class T> class NonderivedTemp {};
template <class T> class UndefinedTemp; // expected-note {{declared here}}
@@ -2079,14 +2070,14 @@ void is_base_of() {
static_assert(!__is_base_of(int, Empty), "");
static_assert(!__is_base_of(Union, int), "");
- isBaseOfT<Base, Derived>();
- isBaseOfF<Derived, Base>();
+ static_assert(__is_base_of(Base, Derived), "");
+ static_assert(!__is_base_of(Derived, Base), "");
- isBaseOfT<Base, CrazyDerived<Base> >();
- isBaseOfF<CrazyDerived<Base>, Base>();
+ static_assert(__is_base_of(Base, CrazyDerived<Base>), "");
+ static_assert(!__is_base_of(CrazyDerived<Base>, Base), "");
- isBaseOfT<BaseA<int>, DerivedB<int> >();
- isBaseOfF<DerivedB<int>, BaseA<int> >();
+ static_assert(__is_base_of(BaseA<int>, DerivedB<int>), "");
+ static_assert(!__is_base_of(DerivedB<int>, BaseA<int>), "");
}
template<class T, class U>
>From d2721a6a410a37cbdc167a751db38beb1a235074 Mon Sep 17 00:00:00 2001
From: Amirreza Ashouri <ar.ashouri999 at gmail.com>
Date: Tue, 9 Jan 2024 18:05:07 +0330
Subject: [PATCH 3/3] [clang][NFC] Simply use
`__has_unique_object_representations` builtin instead of
`has_unique_object_representations` struct
---
clang/test/SemaCXX/type-traits.cpp | 226 ++++++++++++++---------------
1 file changed, 113 insertions(+), 113 deletions(-)
diff --git a/clang/test/SemaCXX/type-traits.cpp b/clang/test/SemaCXX/type-traits.cpp
index 0cb986d176c28b..a0ba0f781e0d0d 100644
--- a/clang/test/SemaCXX/type-traits.cpp
+++ b/clang/test/SemaCXX/type-traits.cpp
@@ -2660,202 +2660,202 @@ struct has_unique_object_representations {
static const bool value = __has_unique_object_representations(T);
};
-static_assert(!has_unique_object_representations<void>::value, "void is never unique");
-static_assert(!has_unique_object_representations<const void>::value, "void is never unique");
-static_assert(!has_unique_object_representations<volatile void>::value, "void is never unique");
-static_assert(!has_unique_object_representations<const volatile void>::value, "void is never unique");
-
-static_assert(has_unique_object_representations<int>::value, "integrals are");
-static_assert(has_unique_object_representations<const int>::value, "integrals are");
-static_assert(has_unique_object_representations<volatile int>::value, "integrals are");
-static_assert(has_unique_object_representations<const volatile int>::value, "integrals are");
-
-static_assert(has_unique_object_representations<void *>::value, "as are pointers");
-static_assert(has_unique_object_representations<const void *>::value, "as are pointers");
-static_assert(has_unique_object_representations<volatile void *>::value, "are pointers");
-static_assert(has_unique_object_representations<const volatile void *>::value, "as are pointers");
-
-static_assert(has_unique_object_representations<int *>::value, "as are pointers");
-static_assert(has_unique_object_representations<const int *>::value, "as are pointers");
-static_assert(has_unique_object_representations<volatile int *>::value, "as are pointers");
-static_assert(has_unique_object_representations<const volatile int *>::value, "as are pointers");
+static_assert(!__has_unique_object_representations(void), "void is never unique");
+static_assert(!__has_unique_object_representations(const void), "void is never unique");
+static_assert(!__has_unique_object_representations(volatile void), "void is never unique");
+static_assert(!__has_unique_object_representations(const volatile void), "void is never unique");
+
+static_assert(__has_unique_object_representations(int), "integrals are");
+static_assert(__has_unique_object_representations(const int), "integrals are");
+static_assert(__has_unique_object_representations(volatile int), "integrals are");
+static_assert(__has_unique_object_representations(const volatile int), "integrals are");
+
+static_assert(__has_unique_object_representations(void *), "as are pointers");
+static_assert(__has_unique_object_representations(const void *), "as are pointers");
+static_assert(__has_unique_object_representations(volatile void *), "are pointers");
+static_assert(__has_unique_object_representations(const volatile void *), "as are pointers");
+
+static_assert(__has_unique_object_representations(int *), "as are pointers");
+static_assert(__has_unique_object_representations(const int *), "as are pointers");
+static_assert(__has_unique_object_representations(volatile int *), "as are pointers");
+static_assert(__has_unique_object_representations(const volatile int *), "as are pointers");
class C {};
using FP = int (*)(int);
using PMF = int (C::*)(int);
using PMD = int C::*;
-static_assert(has_unique_object_representations<FP>::value, "even function pointers");
-static_assert(has_unique_object_representations<const FP>::value, "even function pointers");
-static_assert(has_unique_object_representations<volatile FP>::value, "even function pointers");
-static_assert(has_unique_object_representations<const volatile FP>::value, "even function pointers");
-
-static_assert(has_unique_object_representations<PMF>::value, "and pointer to members");
-static_assert(has_unique_object_representations<const PMF>::value, "and pointer to members");
-static_assert(has_unique_object_representations<volatile PMF>::value, "and pointer to members");
-static_assert(has_unique_object_representations<const volatile PMF>::value, "and pointer to members");
-
-static_assert(has_unique_object_representations<PMD>::value, "and pointer to members");
-static_assert(has_unique_object_representations<const PMD>::value, "and pointer to members");
-static_assert(has_unique_object_representations<volatile PMD>::value, "and pointer to members");
-static_assert(has_unique_object_representations<const volatile PMD>::value, "and pointer to members");
-
-static_assert(has_unique_object_representations<bool>::value, "yes, all integral types");
-static_assert(has_unique_object_representations<char>::value, "yes, all integral types");
-static_assert(has_unique_object_representations<signed char>::value, "yes, all integral types");
-static_assert(has_unique_object_representations<unsigned char>::value, "yes, all integral types");
-static_assert(has_unique_object_representations<short>::value, "yes, all integral types");
-static_assert(has_unique_object_representations<unsigned short>::value, "yes, all integral types");
-static_assert(has_unique_object_representations<int>::value, "yes, all integral types");
-static_assert(has_unique_object_representations<unsigned int>::value, "yes, all integral types");
-static_assert(has_unique_object_representations<long>::value, "yes, all integral types");
-static_assert(has_unique_object_representations<unsigned long>::value, "yes, all integral types");
-static_assert(has_unique_object_representations<long long>::value, "yes, all integral types");
-static_assert(has_unique_object_representations<unsigned long long>::value, "yes, all integral types");
-static_assert(has_unique_object_representations<wchar_t>::value, "yes, all integral types");
-static_assert(has_unique_object_representations<char16_t>::value, "yes, all integral types");
-static_assert(has_unique_object_representations<char32_t>::value, "yes, all integral types");
-
-static_assert(!has_unique_object_representations<void>::value, "but not void!");
-static_assert(!has_unique_object_representations<decltype(nullptr)>::value, "or nullptr_t");
-static_assert(!has_unique_object_representations<float>::value, "definitely not Floating Point");
-static_assert(!has_unique_object_representations<double>::value, "definitely not Floating Point");
-static_assert(!has_unique_object_representations<long double>::value, "definitely not Floating Point");
+static_assert(__has_unique_object_representations(FP), "even function pointers");
+static_assert(__has_unique_object_representations(const FP), "even function pointers");
+static_assert(__has_unique_object_representations(volatile FP), "even function pointers");
+static_assert(__has_unique_object_representations(const volatile FP), "even function pointers");
+
+static_assert(__has_unique_object_representations(PMF), "and pointer to members");
+static_assert(__has_unique_object_representations(const PMF), "and pointer to members");
+static_assert(__has_unique_object_representations(volatile PMF), "and pointer to members");
+static_assert(__has_unique_object_representations(const volatile PMF), "and pointer to members");
+
+static_assert(__has_unique_object_representations(PMD), "and pointer to members");
+static_assert(__has_unique_object_representations(const PMD), "and pointer to members");
+static_assert(__has_unique_object_representations(volatile PMD), "and pointer to members");
+static_assert(__has_unique_object_representations(const volatile PMD), "and pointer to members");
+
+static_assert(__has_unique_object_representations(bool), "yes, all integral types");
+static_assert(__has_unique_object_representations(char), "yes, all integral types");
+static_assert(__has_unique_object_representations(signed char), "yes, all integral types");
+static_assert(__has_unique_object_representations(unsigned char), "yes, all integral types");
+static_assert(__has_unique_object_representations(short), "yes, all integral types");
+static_assert(__has_unique_object_representations(unsigned short), "yes, all integral types");
+static_assert(__has_unique_object_representations(int), "yes, all integral types");
+static_assert(__has_unique_object_representations(unsigned int), "yes, all integral types");
+static_assert(__has_unique_object_representations(long), "yes, all integral types");
+static_assert(__has_unique_object_representations(unsigned long), "yes, all integral types");
+static_assert(__has_unique_object_representations(long long), "yes, all integral types");
+static_assert(__has_unique_object_representations(unsigned long long), "yes, all integral types");
+static_assert(__has_unique_object_representations(wchar_t), "yes, all integral types");
+static_assert(__has_unique_object_representations(char16_t), "yes, all integral types");
+static_assert(__has_unique_object_representations(char32_t), "yes, all integral types");
+
+static_assert(!__has_unique_object_representations(void), "but not void!");
+static_assert(!__has_unique_object_representations(decltype(nullptr)), "or nullptr_t");
+static_assert(!__has_unique_object_representations(float), "definitely not Floating Point");
+static_assert(!__has_unique_object_representations(double), "definitely not Floating Point");
+static_assert(!__has_unique_object_representations(long double), "definitely not Floating Point");
struct NoPadding {
int a;
int b;
};
-static_assert(has_unique_object_representations<NoPadding>::value, "types without padding are");
+static_assert(__has_unique_object_representations(NoPadding), "types without padding are");
struct InheritsFromNoPadding : NoPadding {
int c;
int d;
};
-static_assert(has_unique_object_representations<InheritsFromNoPadding>::value, "types without padding are");
+static_assert(__has_unique_object_representations(InheritsFromNoPadding), "types without padding are");
struct VirtuallyInheritsFromNoPadding : virtual NoPadding {
int c;
int d;
};
-static_assert(!has_unique_object_representations<VirtuallyInheritsFromNoPadding>::value, "No virtual inheritance");
+static_assert(!__has_unique_object_representations(VirtuallyInheritsFromNoPadding), "No virtual inheritance");
struct Padding {
char a;
int b;
};
-//static_assert(!has_unique_object_representations<Padding>::value, "but not with padding");
+//static_assert(!__has_unique_object_representations(Padding), "but not with padding");
struct InheritsFromPadding : Padding {
int c;
int d;
};
-static_assert(!has_unique_object_representations<InheritsFromPadding>::value, "or its subclasses");
+static_assert(!__has_unique_object_representations(InheritsFromPadding), "or its subclasses");
struct TailPadding {
int a;
char b;
};
-static_assert(!has_unique_object_representations<TailPadding>::value, "even at the end");
+static_assert(!__has_unique_object_representations(TailPadding), "even at the end");
struct TinyStruct {
char a;
};
-static_assert(has_unique_object_representations<TinyStruct>::value, "Should be no padding");
+static_assert(__has_unique_object_representations(TinyStruct), "Should be no padding");
struct InheritsFromTinyStruct : TinyStruct {
int b;
};
-static_assert(!has_unique_object_representations<InheritsFromTinyStruct>::value, "Inherit causes padding");
+static_assert(!__has_unique_object_representations(InheritsFromTinyStruct), "Inherit causes padding");
union NoPaddingUnion {
int a;
unsigned int b;
};
-static_assert(has_unique_object_representations<NoPaddingUnion>::value, "unions follow the same rules as structs");
+static_assert(__has_unique_object_representations(NoPaddingUnion), "unions follow the same rules as structs");
union PaddingUnion {
int a;
long long b;
};
-static_assert(!has_unique_object_representations<PaddingUnion>::value, "unions follow the same rules as structs");
+static_assert(!__has_unique_object_representations(PaddingUnion), "unions follow the same rules as structs");
struct NotTriviallyCopyable {
int x;
NotTriviallyCopyable(const NotTriviallyCopyable &) {}
};
-static_assert(!has_unique_object_representations<NotTriviallyCopyable>::value, "must be trivially copyable");
+static_assert(!__has_unique_object_representations(NotTriviallyCopyable), "must be trivially copyable");
struct HasNonUniqueMember {
float x;
};
-static_assert(!has_unique_object_representations<HasNonUniqueMember>::value, "all members must be unique");
+static_assert(!__has_unique_object_representations(HasNonUniqueMember), "all members must be unique");
enum ExampleEnum { xExample,
yExample };
enum LLEnum : long long { xLongExample,
yLongExample };
-static_assert(has_unique_object_representations<ExampleEnum>::value, "Enums are integrals, so unique!");
-static_assert(has_unique_object_representations<LLEnum>::value, "Enums are integrals, so unique!");
+static_assert(__has_unique_object_representations(ExampleEnum), "Enums are integrals, so unique!");
+static_assert(__has_unique_object_representations(LLEnum), "Enums are integrals, so unique!");
enum class ExampleEnumClass { xExample,
yExample };
enum class LLEnumClass : long long { xLongExample,
yLongExample };
-static_assert(has_unique_object_representations<ExampleEnumClass>::value, "Enums are integrals, so unique!");
-static_assert(has_unique_object_representations<LLEnumClass>::value, "Enums are integrals, so unique!");
+static_assert(__has_unique_object_representations(ExampleEnumClass), "Enums are integrals, so unique!");
+static_assert(__has_unique_object_representations(LLEnumClass), "Enums are integrals, so unique!");
// because references aren't trivially copyable.
-static_assert(!has_unique_object_representations<int &>::value, "No references!");
-static_assert(!has_unique_object_representations<const int &>::value, "No references!");
-static_assert(!has_unique_object_representations<volatile int &>::value, "No references!");
-static_assert(!has_unique_object_representations<const volatile int &>::value, "No references!");
-static_assert(!has_unique_object_representations<Empty>::value, "No empty types!");
-static_assert(!has_unique_object_representations<EmptyUnion>::value, "No empty types!");
+static_assert(!__has_unique_object_representations(int &), "No references!");
+static_assert(!__has_unique_object_representations(const int &), "No references!");
+static_assert(!__has_unique_object_representations(volatile int &), "No references!");
+static_assert(!__has_unique_object_representations(const volatile int &), "No references!");
+static_assert(!__has_unique_object_representations(Empty), "No empty types!");
+static_assert(!__has_unique_object_representations(EmptyUnion), "No empty types!");
class Compressed : Empty {
int x;
};
-static_assert(has_unique_object_representations<Compressed>::value, "But inheriting from one is ok");
+static_assert(__has_unique_object_representations(Compressed), "But inheriting from one is ok");
class EmptyInheritor : Compressed {};
-static_assert(has_unique_object_representations<EmptyInheritor>::value, "As long as the base has items, empty is ok");
+static_assert(__has_unique_object_representations(EmptyInheritor), "As long as the base has items, empty is ok");
class Dynamic {
virtual void A();
int i;
};
-static_assert(!has_unique_object_representations<Dynamic>::value, "Dynamic types are not valid");
+static_assert(!__has_unique_object_representations(Dynamic), "Dynamic types are not valid");
class InheritsDynamic : Dynamic {
int j;
};
-static_assert(!has_unique_object_representations<InheritsDynamic>::value, "Dynamic types are not valid");
+static_assert(!__has_unique_object_representations(InheritsDynamic), "Dynamic types are not valid");
-static_assert(has_unique_object_representations<int[42]>::value, "Arrays are fine, as long as their value type is");
-static_assert(has_unique_object_representations<int[]>::value, "Arrays are fine, as long as their value type is");
-static_assert(has_unique_object_representations<int[][42]>::value, "Arrays are fine, as long as their value type is");
-static_assert(!has_unique_object_representations<double[42]>::value, "So no array of doubles!");
-static_assert(!has_unique_object_representations<double[]>::value, "So no array of doubles!");
-static_assert(!has_unique_object_representations<double[][42]>::value, "So no array of doubles!");
+static_assert(__has_unique_object_representations(int[42]), "Arrays are fine, as long as their value type is");
+static_assert(__has_unique_object_representations(int[]), "Arrays are fine, as long as their value type is");
+static_assert(__has_unique_object_representations(int[][42]), "Arrays are fine, as long as their value type is");
+static_assert(!__has_unique_object_representations(double[42]), "So no array of doubles!");
+static_assert(!__has_unique_object_representations(double[]), "So no array of doubles!");
+static_assert(!__has_unique_object_representations(double[][42]), "So no array of doubles!");
struct __attribute__((aligned(16))) WeirdAlignment {
int i;
@@ -2863,9 +2863,9 @@ struct __attribute__((aligned(16))) WeirdAlignment {
union __attribute__((aligned(16))) WeirdAlignmentUnion {
int i;
};
-static_assert(!has_unique_object_representations<WeirdAlignment>::value, "Alignment causes padding");
-static_assert(!has_unique_object_representations<WeirdAlignmentUnion>::value, "Alignment causes padding");
-static_assert(!has_unique_object_representations<WeirdAlignment[42]>::value, "Also no arrays that have padding");
+static_assert(!__has_unique_object_representations(WeirdAlignment), "Alignment causes padding");
+static_assert(!__has_unique_object_representations(WeirdAlignmentUnion), "Alignment causes padding");
+static_assert(!__has_unique_object_representations(WeirdAlignment[42]), "Also no arrays that have padding");
struct __attribute__((packed)) PackedNoPadding1 {
short i;
@@ -2875,10 +2875,10 @@ struct __attribute__((packed)) PackedNoPadding2 {
int j;
short i;
};
-static_assert(has_unique_object_representations<PackedNoPadding1>::value, "Packed structs have no padding");
-static_assert(has_unique_object_representations<PackedNoPadding2>::value, "Packed structs have no padding");
+static_assert(__has_unique_object_representations(PackedNoPadding1), "Packed structs have no padding");
+static_assert(__has_unique_object_representations(PackedNoPadding2), "Packed structs have no padding");
-static_assert(!has_unique_object_representations<int(int)>::value, "Functions are not unique");
+static_assert(!__has_unique_object_representations(int(int)), "Functions are not unique");
static_assert(!has_unique_object_representations<int(int) const>::value, "Functions are not unique");
static_assert(!has_unique_object_representations<int(int) volatile>::value, "Functions are not unique");
static_assert(!has_unique_object_representations<int(int) const volatile>::value, "Functions are not unique");
@@ -2891,7 +2891,7 @@ static_assert(!has_unique_object_representations<int(int) const &&>::value, "Fun
static_assert(!has_unique_object_representations<int(int) volatile &&>::value, "Functions are not unique");
static_assert(!has_unique_object_representations<int(int) const volatile &&>::value, "Functions are not unique");
-static_assert(!has_unique_object_representations<int(int, ...)>::value, "Functions are not unique");
+static_assert(!__has_unique_object_representations(int(int, ...)), "Functions are not unique");
static_assert(!has_unique_object_representations<int(int, ...) const>::value, "Functions are not unique");
static_assert(!has_unique_object_representations<int(int, ...) volatile>::value, "Functions are not unique");
static_assert(!has_unique_object_representations<int(int, ...) const volatile>::value, "Functions are not unique");
@@ -2906,10 +2906,10 @@ static_assert(!has_unique_object_representations<int(int, ...) const volatile &&
void foo(){
static auto lambda = []() {};
- static_assert(!has_unique_object_representations<decltype(lambda)>::value, "Lambdas follow struct rules");
+ static_assert(!__has_unique_object_representations(decltype(lambda)), "Lambdas follow struct rules");
int i;
static auto lambda2 = [i]() {};
- static_assert(has_unique_object_representations<decltype(lambda2)>::value, "Lambdas follow struct rules");
+ static_assert(__has_unique_object_representations(decltype(lambda2)), "Lambdas follow struct rules");
}
struct PaddedBitfield {
@@ -2949,26 +2949,26 @@ struct UnnamedEmptyBitfieldSplit {
short also_named;
};
-static_assert(!has_unique_object_representations<PaddedBitfield>::value, "Bitfield padding");
-static_assert(has_unique_object_representations<UnPaddedBitfield>::value, "Bitfield padding");
-static_assert(!has_unique_object_representations<AlignedPaddedBitfield>::value, "Bitfield padding");
-static_assert(!has_unique_object_representations<UnnamedBitfield>::value, "Bitfield padding");
-static_assert(!has_unique_object_representations<UnnamedBitfieldPacked>::value, "Bitfield padding");
-static_assert(has_unique_object_representations<UnnamedEmptyBitfield>::value, "Bitfield padding");
+static_assert(!__has_unique_object_representations(PaddedBitfield), "Bitfield padding");
+static_assert(__has_unique_object_representations(UnPaddedBitfield), "Bitfield padding");
+static_assert(!__has_unique_object_representations(AlignedPaddedBitfield), "Bitfield padding");
+static_assert(!__has_unique_object_representations(UnnamedBitfield), "Bitfield padding");
+static_assert(!__has_unique_object_representations(UnnamedBitfieldPacked), "Bitfield padding");
+static_assert(__has_unique_object_representations(UnnamedEmptyBitfield), "Bitfield padding");
static_assert(sizeof(UnnamedEmptyBitfieldSplit) != (sizeof(short) * 2), "Wrong size");
-static_assert(!has_unique_object_representations<UnnamedEmptyBitfieldSplit>::value, "Bitfield padding");
+static_assert(!__has_unique_object_representations(UnnamedEmptyBitfieldSplit), "Bitfield padding");
struct BoolBitfield {
bool b : 8;
};
-static_assert(has_unique_object_representations<BoolBitfield>::value, "Bitfield bool");
+static_assert(__has_unique_object_representations(BoolBitfield), "Bitfield bool");
struct BoolBitfield2 {
bool b : 16;
};
-static_assert(!has_unique_object_representations<BoolBitfield2>::value, "Bitfield bool");
+static_assert(!__has_unique_object_representations(BoolBitfield2), "Bitfield bool");
struct GreaterSizeBitfield {
//expected-warning at +1 {{width of bit-field 'n'}}
@@ -2976,13 +2976,13 @@ struct GreaterSizeBitfield {
};
static_assert(sizeof(GreaterSizeBitfield) == 128, "Bitfield Size");
-static_assert(!has_unique_object_representations<GreaterSizeBitfield>::value, "Bitfield padding");
+static_assert(!__has_unique_object_representations(GreaterSizeBitfield), "Bitfield padding");
struct StructWithRef {
int &I;
};
-static_assert(has_unique_object_representations<StructWithRef>::value, "References are still unique");
+static_assert(__has_unique_object_representations(StructWithRef), "References are still unique");
struct NotUniqueBecauseTailPadding {
int &r;
@@ -2992,12 +2992,12 @@ struct CanBeUniqueIfNoPadding : NotUniqueBecauseTailPadding {
char b[7];
};
-static_assert(!has_unique_object_representations<NotUniqueBecauseTailPadding>::value,
+static_assert(!__has_unique_object_representations(NotUniqueBecauseTailPadding),
"non trivial");
// Can be unique on Itanium, since the is child class' data is 'folded' into the
// parent's tail padding.
static_assert(sizeof(CanBeUniqueIfNoPadding) != 16 ||
- has_unique_object_representations<CanBeUniqueIfNoPadding>::value,
+ __has_unique_object_representations(CanBeUniqueIfNoPadding),
"inherit from std layout");
namespace ErrorType {
@@ -3009,10 +3009,10 @@ namespace ErrorType {
bool b = __has_unique_object_representations(T);
};
-static_assert(!has_unique_object_representations<_BitInt(7)>::value, "BitInt:");
-static_assert(has_unique_object_representations<_BitInt(8)>::value, "BitInt:");
-static_assert(!has_unique_object_representations<_BitInt(127)>::value, "BitInt:");
-static_assert(has_unique_object_representations<_BitInt(128)>::value, "BitInt:");
+static_assert(!__has_unique_object_representations(_BitInt(7)), "BitInt:");
+static_assert(__has_unique_object_representations(_BitInt(8)), "BitInt:");
+static_assert(!__has_unique_object_representations(_BitInt(127)), "BitInt:");
+static_assert(__has_unique_object_representations(_BitInt(128)), "BitInt:");
namespace PR46209 {
More information about the cfe-commits
mailing list