[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
Thu Mar 7 11:53:24 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/6] [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/6] [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/6] [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 {
>From 5e043defb789eccafe9ee19003953e386ea43b75 Mon Sep 17 00:00:00 2001
From: Amirreza Ashouri <ar.ashouri999 at gmail.com>
Date: Tue, 5 Mar 2024 12:42:52 +0330
Subject: [PATCH 4/6] [Clang] Get rid of the `static_assert`s' empty messages
---
clang/test/SemaCXX/type-traits.cpp | 4364 ++++++++++++++--------------
1 file changed, 2182 insertions(+), 2182 deletions(-)
diff --git a/clang/test/SemaCXX/type-traits.cpp b/clang/test/SemaCXX/type-traits.cpp
index a0ba0f781e0d0d..b6b06f3115def8 100644
--- a/clang/test/SemaCXX/type-traits.cpp
+++ b/clang/test/SemaCXX/type-traits.cpp
@@ -1,7 +1,7 @@
-// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted %s
-// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++14 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted %s
-// 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
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted -Wno-c++17-extensions %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++14 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted -Wno-c++17-extensions %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++17 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted -Wno-c++17-extensions %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++20 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted -Wno-c++17-extensions %s
struct NonPOD { NonPOD(int); };
@@ -212,56 +212,56 @@ struct HasVirtBase : virtual ACompleteType {};
void is_pod()
{
- 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}}
+ 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];
@@ -273,56 +273,56 @@ struct DerivesVirt : virtual POD {};
void is_empty()
{
- 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]), "");
+ 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()
{
- 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), "");
+ 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];
@@ -330,17 +330,17 @@ typedef Union UnionType;
void is_union()
{
- 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), "");
+ 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;
@@ -348,57 +348,57 @@ typedef EnumClass EnumClassType;
void is_enum()
{
- 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), "");
+ 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() {
- static_assert(!__is_scoped_enum(Enum), "");
- static_assert(!__is_scoped_enum(EnumType), "");
- static_assert(!__is_scoped_enum(SignedEnum), "");
- static_assert(!__is_scoped_enum(UnsignedEnum), "");
-
- static_assert(__is_scoped_enum(EnumClass), "");
- static_assert(__is_scoped_enum(EnumClassType), "");
- static_assert(__is_scoped_enum(SignedEnumClass), "");
- static_assert(__is_scoped_enum(UnsignedEnumClass), "");
-
- static_assert(!__is_scoped_enum(int), "");
- static_assert(!__is_scoped_enum(Union), "");
- static_assert(!__is_scoped_enum(Int), "");
- static_assert(!__is_scoped_enum(IntAr), "");
- static_assert(!__is_scoped_enum(UnionAr), "");
- static_assert(!__is_scoped_enum(Derives), "");
- static_assert(!__is_scoped_enum(ClassType), "");
- static_assert(!__is_scoped_enum(cvoid), "");
- static_assert(!__is_scoped_enum(IntArNB), "");
- static_assert(!__is_scoped_enum(HasAnonymousUnion), "");
- static_assert(!__is_scoped_enum(AnIncompleteType), "");
- static_assert(!__is_scoped_enum(AnIncompleteTypeAr), "");
- static_assert(!__is_scoped_enum(AnIncompleteTypeArMB), "");
- static_assert(!__is_scoped_enum(AnIncompleteTypeArNB), "");
+ static_assert(!__is_scoped_enum(Enum));
+ static_assert(!__is_scoped_enum(EnumType));
+ static_assert(!__is_scoped_enum(SignedEnum));
+ static_assert(!__is_scoped_enum(UnsignedEnum));
+
+ static_assert(__is_scoped_enum(EnumClass));
+ static_assert(__is_scoped_enum(EnumClassType));
+ static_assert(__is_scoped_enum(SignedEnumClass));
+ static_assert(__is_scoped_enum(UnsignedEnumClass));
+
+ static_assert(!__is_scoped_enum(int));
+ static_assert(!__is_scoped_enum(Union));
+ static_assert(!__is_scoped_enum(Int));
+ static_assert(!__is_scoped_enum(IntAr));
+ static_assert(!__is_scoped_enum(UnionAr));
+ static_assert(!__is_scoped_enum(Derives));
+ static_assert(!__is_scoped_enum(ClassType));
+ static_assert(!__is_scoped_enum(cvoid));
+ static_assert(!__is_scoped_enum(IntArNB));
+ static_assert(!__is_scoped_enum(HasAnonymousUnion));
+ static_assert(!__is_scoped_enum(AnIncompleteType));
+ static_assert(!__is_scoped_enum(AnIncompleteTypeAr));
+ static_assert(!__is_scoped_enum(AnIncompleteTypeArMB));
+ static_assert(!__is_scoped_enum(AnIncompleteTypeArNB));
}
struct FinalClass final {
@@ -419,20 +419,20 @@ struct PotentiallyFinal<int> final { };
void is_final()
{
- 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), "");
+ 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));
}
@@ -441,78 +441,78 @@ struct InheritPolymorph : Polymorph {};
void is_polymorphic()
{
- 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), "");
+ 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()
{
- 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), "");
+ 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()
{
- 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), "");
+ 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>
@@ -535,274 +535,274 @@ void is_aggregate()
__is_aggregate(IncompleteUnion); // expected-error {{incomplete type}}
// Valid since LWG3823
- static_assert(__is_aggregate(AnIncompleteType[]), "");
- static_assert(__is_aggregate(AnIncompleteType[1]), "");
- static_assert(__is_aggregate(AnIncompleteTypeAr), "");
- static_assert(__is_aggregate(AnIncompleteTypeArNB), "");
- static_assert(__is_aggregate(AnIncompleteTypeArMB), "");
-
- static_assert(!__is_aggregate(NonPOD), "");
- static_assert(__is_aggregate(NonPODAr), "");
- static_assert(__is_aggregate(NonPODArNB), "");
- static_assert(__is_aggregate(NonPODArMB), "");
-
- static_assert(!__is_aggregate(Enum), "");
- static_assert(__is_aggregate(POD), "");
- static_assert(__is_aggregate(Empty), "");
- static_assert(__is_aggregate(EmptyAr), "");
- static_assert(__is_aggregate(EmptyArNB), "");
- static_assert(__is_aggregate(EmptyArMB), "");
- static_assert(!__is_aggregate(void), "");
- static_assert(!__is_aggregate(const volatile void), "");
- static_assert(!__is_aggregate(int), "");
- static_assert(__is_aggregate(IntAr), "");
- static_assert(__is_aggregate(IntArNB), "");
- static_assert(__is_aggregate(EmptyUnion), "");
- static_assert(__is_aggregate(Union), "");
- static_assert(__is_aggregate(Statics), "");
- static_assert(__is_aggregate(HasFunc), "");
- static_assert(__is_aggregate(HasOp), "");
- static_assert(__is_aggregate(HasAssign), "");
- static_assert(__is_aggregate(HasAnonymousUnion), "");
-
- static_assert(__is_aggregate(Derives) == TrueAfterCpp14, "");
- static_assert(__is_aggregate(DerivesAr), "");
- static_assert(__is_aggregate(DerivesArNB), "");
- static_assert(!__is_aggregate(HasCons), "");
+ static_assert(__is_aggregate(AnIncompleteType[]));
+ static_assert(__is_aggregate(AnIncompleteType[1]));
+ static_assert(__is_aggregate(AnIncompleteTypeAr));
+ static_assert(__is_aggregate(AnIncompleteTypeArNB));
+ static_assert(__is_aggregate(AnIncompleteTypeArMB));
+
+ static_assert(!__is_aggregate(NonPOD));
+ static_assert(__is_aggregate(NonPODAr));
+ static_assert(__is_aggregate(NonPODArNB));
+ static_assert(__is_aggregate(NonPODArMB));
+
+ static_assert(!__is_aggregate(Enum));
+ static_assert(__is_aggregate(POD));
+ static_assert(__is_aggregate(Empty));
+ static_assert(__is_aggregate(EmptyAr));
+ static_assert(__is_aggregate(EmptyArNB));
+ static_assert(__is_aggregate(EmptyArMB));
+ static_assert(!__is_aggregate(void));
+ static_assert(!__is_aggregate(const volatile void));
+ static_assert(!__is_aggregate(int));
+ static_assert(__is_aggregate(IntAr));
+ static_assert(__is_aggregate(IntArNB));
+ static_assert(__is_aggregate(EmptyUnion));
+ static_assert(__is_aggregate(Union));
+ static_assert(__is_aggregate(Statics));
+ static_assert(__is_aggregate(HasFunc));
+ static_assert(__is_aggregate(HasOp));
+ static_assert(__is_aggregate(HasAssign));
+ static_assert(__is_aggregate(HasAnonymousUnion));
+
+ static_assert(__is_aggregate(Derives) == TrueAfterCpp14);
+ static_assert(__is_aggregate(DerivesAr));
+ static_assert(__is_aggregate(DerivesArNB));
+ static_assert(!__is_aggregate(HasCons));
#if __cplusplus >= 202002L
- static_assert(!__is_aggregate(HasDefaultCons), "");
+ static_assert(!__is_aggregate(HasDefaultCons));
#else
- static_assert(__is_aggregate(HasDefaultCons), "");
+ static_assert(__is_aggregate(HasDefaultCons));
#endif
- static_assert(!__is_aggregate(HasExplicitDefaultCons), "");
- static_assert(!__is_aggregate(HasInheritedCons), "");
- static_assert(__is_aggregate(HasNoInheritedCons) == TrueAfterCpp14, "");
- static_assert(__is_aggregate(HasCopyAssign), "");
- static_assert(!__is_aggregate(NonTrivialDefault), "");
- static_assert(__is_aggregate(HasDest), "");
- static_assert(!__is_aggregate(HasPriv), "");
- static_assert(!__is_aggregate(HasProt), "");
- static_assert(__is_aggregate(HasRefAggregate), "");
- static_assert(__is_aggregate(HasNonPOD), "");
- static_assert(!__is_aggregate(HasVirt), "");
- static_assert(__is_aggregate(VirtAr), "");
- static_assert(__is_aggregate(HasInClassInit) == TrueAfterCpp11, "");
- static_assert(!__is_aggregate(HasPrivateBase), "");
- static_assert(!__is_aggregate(HasProtectedBase), "");
- static_assert(!__is_aggregate(HasVirtBase), "");
-
- static_assert(__is_aggregate(AggregateTemplate<int>), "");
- static_assert(!__is_aggregate(NonAggregateTemplate<int>), "");
-
- static_assert(__is_aggregate(Vector), ""); // Extension supported by GCC and Clang
- static_assert(__is_aggregate(VectorExt), "");
- static_assert(__is_aggregate(ComplexInt), "");
- static_assert(__is_aggregate(ComplexFloat), "");
+ static_assert(!__is_aggregate(HasExplicitDefaultCons));
+ static_assert(!__is_aggregate(HasInheritedCons));
+ static_assert(__is_aggregate(HasNoInheritedCons) == TrueAfterCpp14);
+ static_assert(__is_aggregate(HasCopyAssign));
+ static_assert(!__is_aggregate(NonTrivialDefault));
+ static_assert(__is_aggregate(HasDest));
+ static_assert(!__is_aggregate(HasPriv));
+ static_assert(!__is_aggregate(HasProt));
+ static_assert(__is_aggregate(HasRefAggregate));
+ static_assert(__is_aggregate(HasNonPOD));
+ static_assert(!__is_aggregate(HasVirt));
+ static_assert(__is_aggregate(VirtAr));
+ static_assert(__is_aggregate(HasInClassInit) == TrueAfterCpp11);
+ static_assert(!__is_aggregate(HasPrivateBase));
+ static_assert(!__is_aggregate(HasProtectedBase));
+ static_assert(!__is_aggregate(HasVirtBase));
+
+ static_assert(__is_aggregate(AggregateTemplate<int>));
+ static_assert(!__is_aggregate(NonAggregateTemplate<int>));
+
+ static_assert(__is_aggregate(Vector)); // Extension supported by GCC and Clang
+ static_assert(__is_aggregate(VectorExt));
+ static_assert(__is_aggregate(ComplexInt));
+ static_assert(__is_aggregate(ComplexFloat));
}
void is_arithmetic()
{
- 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), "");
+ 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()
{
- 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), "");
+ 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()
{
- 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*), "");
+ 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()
{
- 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*), "");
+ 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) {
- static_assert(__is_bounded_array(IntAr), "");
- static_assert(!__is_bounded_array(IntArNB), "");
- static_assert(__is_bounded_array(UnionAr), "");
-
- static_assert(!__is_bounded_array(void), "");
- static_assert(!__is_bounded_array(cvoid), "");
- static_assert(!__is_bounded_array(float), "");
- static_assert(!__is_bounded_array(double), "");
- static_assert(!__is_bounded_array(long double), "");
- static_assert(!__is_bounded_array(bool), "");
- static_assert(!__is_bounded_array(char), "");
- static_assert(!__is_bounded_array(signed char), "");
- static_assert(!__is_bounded_array(unsigned char), "");
- static_assert(!__is_bounded_array(wchar_t), "");
- static_assert(!__is_bounded_array(short), "");
- static_assert(!__is_bounded_array(unsigned short), "");
- static_assert(!__is_bounded_array(int), "");
- static_assert(!__is_bounded_array(unsigned int), "");
- static_assert(!__is_bounded_array(long), "");
- static_assert(!__is_bounded_array(unsigned long), "");
- static_assert(!__is_bounded_array(Union), "");
- static_assert(!__is_bounded_array(Derives), "");
- static_assert(!__is_bounded_array(ClassType), "");
- static_assert(!__is_bounded_array(Enum), "");
- static_assert(!__is_bounded_array(void *), "");
- static_assert(!__is_bounded_array(cvoid *), "");
+ static_assert(__is_bounded_array(IntAr));
+ static_assert(!__is_bounded_array(IntArNB));
+ static_assert(__is_bounded_array(UnionAr));
+
+ static_assert(!__is_bounded_array(void));
+ static_assert(!__is_bounded_array(cvoid));
+ static_assert(!__is_bounded_array(float));
+ static_assert(!__is_bounded_array(double));
+ static_assert(!__is_bounded_array(long double));
+ static_assert(!__is_bounded_array(bool));
+ static_assert(!__is_bounded_array(char));
+ static_assert(!__is_bounded_array(signed char));
+ static_assert(!__is_bounded_array(unsigned char));
+ static_assert(!__is_bounded_array(wchar_t));
+ static_assert(!__is_bounded_array(short));
+ static_assert(!__is_bounded_array(unsigned short));
+ static_assert(!__is_bounded_array(int));
+ static_assert(!__is_bounded_array(unsigned int));
+ static_assert(!__is_bounded_array(long));
+ static_assert(!__is_bounded_array(unsigned long));
+ static_assert(!__is_bounded_array(Union));
+ static_assert(!__is_bounded_array(Derives));
+ static_assert(!__is_bounded_array(ClassType));
+ static_assert(!__is_bounded_array(Enum));
+ static_assert(!__is_bounded_array(void *));
+ static_assert(!__is_bounded_array(cvoid *));
int t32[n];
(void)__is_bounded_array(decltype(t32)); // expected-error{{variable length arrays are not supported for '__is_bounded_array'}}
}
void is_unbounded_array(int n) {
- static_assert(!__is_unbounded_array(IntAr), "");
- static_assert(__is_unbounded_array(IntArNB), "");
- static_assert(!__is_unbounded_array(UnionAr), "");
-
- static_assert(!__is_unbounded_array(void), "");
- static_assert(!__is_unbounded_array(cvoid), "");
- static_assert(!__is_unbounded_array(float), "");
- static_assert(!__is_unbounded_array(double), "");
- static_assert(!__is_unbounded_array(long double), "");
- static_assert(!__is_unbounded_array(bool), "");
- static_assert(!__is_unbounded_array(char), "");
- static_assert(!__is_unbounded_array(signed char), "");
- static_assert(!__is_unbounded_array(unsigned char), "");
- static_assert(!__is_unbounded_array(wchar_t), "");
- static_assert(!__is_unbounded_array(short), "");
- static_assert(!__is_unbounded_array(unsigned short), "");
- static_assert(!__is_unbounded_array(int), "");
- static_assert(!__is_unbounded_array(unsigned int), "");
- static_assert(!__is_unbounded_array(long), "");
- static_assert(!__is_unbounded_array(unsigned long), "");
- static_assert(!__is_unbounded_array(Union), "");
- static_assert(!__is_unbounded_array(Derives), "");
- static_assert(!__is_unbounded_array(ClassType), "");
- static_assert(!__is_unbounded_array(Enum), "");
- static_assert(!__is_unbounded_array(void *), "");
- static_assert(!__is_unbounded_array(cvoid *), "");
+ static_assert(!__is_unbounded_array(IntAr));
+ static_assert(__is_unbounded_array(IntArNB));
+ static_assert(!__is_unbounded_array(UnionAr));
+
+ static_assert(!__is_unbounded_array(void));
+ static_assert(!__is_unbounded_array(cvoid));
+ static_assert(!__is_unbounded_array(float));
+ static_assert(!__is_unbounded_array(double));
+ static_assert(!__is_unbounded_array(long double));
+ static_assert(!__is_unbounded_array(bool));
+ static_assert(!__is_unbounded_array(char));
+ static_assert(!__is_unbounded_array(signed char));
+ static_assert(!__is_unbounded_array(unsigned char));
+ static_assert(!__is_unbounded_array(wchar_t));
+ static_assert(!__is_unbounded_array(short));
+ static_assert(!__is_unbounded_array(unsigned short));
+ static_assert(!__is_unbounded_array(int));
+ static_assert(!__is_unbounded_array(unsigned int));
+ static_assert(!__is_unbounded_array(long));
+ static_assert(!__is_unbounded_array(unsigned long));
+ static_assert(!__is_unbounded_array(Union));
+ static_assert(!__is_unbounded_array(Derives));
+ static_assert(!__is_unbounded_array(ClassType));
+ static_assert(!__is_unbounded_array(Enum));
+ static_assert(!__is_unbounded_array(void *));
+ static_assert(!__is_unbounded_array(cvoid *));
int t32[n];
(void)__is_unbounded_array(decltype(t32)); // expected-error{{variable length arrays are not supported for '__is_unbounded_array'}}
}
void is_referenceable() {
- static_assert(__is_referenceable(int), "");
- static_assert(__is_referenceable(const int), "");
- static_assert(__is_referenceable(volatile int), "");
- static_assert(__is_referenceable(const volatile int), "");
- static_assert(__is_referenceable(int *), "");
- static_assert(__is_referenceable(int &), "");
- static_assert(__is_referenceable(int &&), "");
- static_assert(__is_referenceable(int (*)()), "");
- static_assert(__is_referenceable(int (&)()), "");
- static_assert(__is_referenceable(int(&&)()), "");
- static_assert(__is_referenceable(IntAr), "");
- static_assert(__is_referenceable(IntArNB), "");
- static_assert(__is_referenceable(decltype(nullptr)), "");
- static_assert(__is_referenceable(Empty), "");
- static_assert(__is_referenceable(Union), "");
- static_assert(__is_referenceable(Derives), "");
- static_assert(__is_referenceable(Enum), "");
- static_assert(__is_referenceable(EnumClass), "");
- static_assert(__is_referenceable(int Empty::*), "");
- static_assert(__is_referenceable(int(Empty::*)()), "");
- static_assert(__is_referenceable(AnIncompleteType), "");
- static_assert(__is_referenceable(struct AnIncompleteType), "");
+ static_assert(__is_referenceable(int));
+ static_assert(__is_referenceable(const int));
+ static_assert(__is_referenceable(volatile int));
+ static_assert(__is_referenceable(const volatile int));
+ static_assert(__is_referenceable(int *));
+ static_assert(__is_referenceable(int &));
+ static_assert(__is_referenceable(int &&));
+ static_assert(__is_referenceable(int (*)()));
+ static_assert(__is_referenceable(int (&)()));
+ static_assert(__is_referenceable(int(&&)()));
+ static_assert(__is_referenceable(IntAr));
+ static_assert(__is_referenceable(IntArNB));
+ static_assert(__is_referenceable(decltype(nullptr)));
+ static_assert(__is_referenceable(Empty));
+ static_assert(__is_referenceable(Union));
+ static_assert(__is_referenceable(Derives));
+ static_assert(__is_referenceable(Enum));
+ static_assert(__is_referenceable(EnumClass));
+ static_assert(__is_referenceable(int Empty::*));
+ static_assert(__is_referenceable(int(Empty::*)()));
+ static_assert(__is_referenceable(AnIncompleteType));
+ static_assert(__is_referenceable(struct AnIncompleteType));
using function_type = void(int);
- static_assert(__is_referenceable(function_type), "");
+ static_assert(__is_referenceable(function_type));
- static_assert(!__is_referenceable(void), "");
+ static_assert(!__is_referenceable(void));
}
template <typename T> void tmpl_func(T&) {}
@@ -815,152 +815,152 @@ template <typename T> struct type_wrapper {
void is_function()
{
- static_assert(__is_function(type_wrapper<void(void)>::type), "");
- static_assert(__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);
- 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), "");
+ 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()
{
- static_assert(__is_reference(int&), "");
- static_assert(__is_reference(const int&), "");
- static_assert(__is_reference(void *&), "");
+ static_assert(__is_reference(int&));
+ static_assert(__is_reference(const int&));
+ static_assert(__is_reference(void *&));
- static_assert(!__is_reference(int), "");
- static_assert(!__is_reference(const int), "");
- static_assert(!__is_reference(void *), "");
+ static_assert(!__is_reference(int));
+ static_assert(!__is_reference(const int));
+ static_assert(!__is_reference(void *));
}
void is_lvalue_reference()
{
- 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 *), "");
+ 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()
{
- 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 *), "");
+ 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()
{
- 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), "");
+ 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()
{
- 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), "");
+ 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()
{
- 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), "");
+ 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 {
@@ -970,314 +970,314 @@ struct StructWithMembers {
void is_compound()
{
- 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), "");
+ 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;
- 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::*) ()), "");
+ 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() {
StructWithMembers x;
- static_assert(__is_nullptr(decltype(nullptr)), "");
- static_assert(!__is_nullptr(void *), "");
- static_assert(!__is_nullptr(cvoid *), "");
- static_assert(!__is_nullptr(cvoid *), "");
- static_assert(!__is_nullptr(char *), "");
- static_assert(!__is_nullptr(int *), "");
- static_assert(!__is_nullptr(int **), "");
- static_assert(!__is_nullptr(ClassType *), "");
- static_assert(!__is_nullptr(Derives *), "");
- static_assert(!__is_nullptr(Enum *), "");
- static_assert(!__is_nullptr(IntArNB *), "");
- static_assert(!__is_nullptr(Union *), "");
- static_assert(!__is_nullptr(UnionAr *), "");
- static_assert(!__is_nullptr(StructWithMembers *), "");
- static_assert(!__is_nullptr(void (*)()), "");
-
- static_assert(!__is_nullptr(void), "");
- static_assert(!__is_nullptr(cvoid), "");
- static_assert(!__is_nullptr(cvoid), "");
- static_assert(!__is_nullptr(char), "");
- static_assert(!__is_nullptr(int), "");
- static_assert(!__is_nullptr(int), "");
- static_assert(!__is_nullptr(ClassType), "");
- static_assert(!__is_nullptr(Derives), "");
- static_assert(!__is_nullptr(Enum), "");
- static_assert(!__is_nullptr(IntArNB), "");
- static_assert(!__is_nullptr(Union), "");
- static_assert(!__is_nullptr(UnionAr), "");
- static_assert(!__is_nullptr(StructWithMembers), "");
- static_assert(!__is_nullptr(int StructWithMembers::*), "");
- static_assert(!__is_nullptr(void(StructWithMembers::*)()), "");
+ static_assert(__is_nullptr(decltype(nullptr)));
+ static_assert(!__is_nullptr(void *));
+ static_assert(!__is_nullptr(cvoid *));
+ static_assert(!__is_nullptr(cvoid *));
+ static_assert(!__is_nullptr(char *));
+ static_assert(!__is_nullptr(int *));
+ static_assert(!__is_nullptr(int **));
+ static_assert(!__is_nullptr(ClassType *));
+ static_assert(!__is_nullptr(Derives *));
+ static_assert(!__is_nullptr(Enum *));
+ static_assert(!__is_nullptr(IntArNB *));
+ static_assert(!__is_nullptr(Union *));
+ static_assert(!__is_nullptr(UnionAr *));
+ static_assert(!__is_nullptr(StructWithMembers *));
+ static_assert(!__is_nullptr(void (*)()));
+
+ static_assert(!__is_nullptr(void));
+ static_assert(!__is_nullptr(cvoid));
+ static_assert(!__is_nullptr(cvoid));
+ static_assert(!__is_nullptr(char));
+ static_assert(!__is_nullptr(int));
+ static_assert(!__is_nullptr(int));
+ static_assert(!__is_nullptr(ClassType));
+ static_assert(!__is_nullptr(Derives));
+ static_assert(!__is_nullptr(Enum));
+ static_assert(!__is_nullptr(IntArNB));
+ static_assert(!__is_nullptr(Union));
+ static_assert(!__is_nullptr(UnionAr));
+ static_assert(!__is_nullptr(StructWithMembers));
+ static_assert(!__is_nullptr(int StructWithMembers::*));
+ static_assert(!__is_nullptr(void(StructWithMembers::*)()));
}
void is_member_object_pointer()
{
StructWithMembers x;
- 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 (*)()), "");
+ 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;
- 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 (*)()), "");
+ 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;
- 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 (*)()), "");
+ 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()
{
- 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), "");
+ 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()
{
- 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), "");
+ 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 {
@@ -1350,87 +1350,87 @@ ExtDefaulted::~ExtDefaulted() = default;
void is_trivial2()
{
- 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), "");
+ 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()
{
- 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), "");
+ 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 {
@@ -1475,32 +1475,32 @@ void is_standard_layout()
typedef ConstInt ConstIntAr[4];
typedef CppStructStandard CppStructStandardAr[4];
- 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), "");
+ 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];
- 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), "");
+ 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; };
@@ -1508,11 +1508,11 @@ void is_standard_layout()
struct DerivesFromBitfieldWithBitfield : HasAnonBitfield { int : 5; };
struct DerivesFromBitfieldTwice : DerivesFromBitfield, HasAnonEmptyBitfield {};
- 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), "");
+ 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 {};
@@ -1526,16 +1526,16 @@ void is_standard_layout()
struct HasEmptyIndirectBaseAsSecondMember : HasEmptyBase { int n; Empty e; };
struct HasEmptyIndirectBaseAfterBitfield : HasEmptyBase { int : 4; Empty e; };
- 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?
+ 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;
@@ -1552,68 +1552,68 @@ void is_standard_layout()
UnionWithEmptyFields u;
};
- static_assert(__is_standard_layout(HasEmptyIndirectBaseAsSecondStructMember), "");
- static_assert(!__is_standard_layout(HasEmptyIndirectBaseAsSecondUnionMember), "");
+ static_assert(__is_standard_layout(HasEmptyIndirectBaseAsSecondStructMember));
+ static_assert(!__is_standard_layout(HasEmptyIndirectBaseAsSecondUnionMember));
}
void is_signed()
{
- //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), "");
+ //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()
{
- 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), "");
+ 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;
@@ -1636,35 +1636,35 @@ struct HasTemplateCons {
};
void has_trivial_default_constructor() {
- 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), "");
+ 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() {
@@ -1680,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.
- 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), "");
+ 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() {
- 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), "");
+ 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() {
- 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), "");
+ 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() {
- 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), "");
+ 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() {
- static_assert(!__has_trivial_destructor(A), "");
- static_assert(!__has_trivial_destructor(B<int>), "");
+ static_assert(!__has_trivial_destructor(A));
+ static_assert(!__has_trivial_destructor(B<int>));
}
class PR11110 {
@@ -1821,69 +1821,69 @@ class UsingAssign : public UsingAssignBase {
};
void has_nothrow_assign() {
- 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), "");
+ 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() {
- 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), "");
+ 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() {
@@ -1898,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;
- 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), "");
+ 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() {
- 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), "");
+ 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() {
- 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), "");
+ 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() {
- 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), "");
+ 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));
}
@@ -2032,52 +2032,52 @@ template <class T> class NonderivedTemp {};
template <class T> class UndefinedTemp; // expected-note {{declared here}}
void is_base_of() {
- 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), "");
-
- static_assert(__is_base_of(Base, Derived), "");
- static_assert(!__is_base_of(Derived, Base), "");
-
- static_assert(__is_base_of(Base, CrazyDerived<Base>), "");
- static_assert(!__is_base_of(CrazyDerived<Base>, Base), "");
-
- static_assert(__is_base_of(BaseA<int>, DerivedB<int>), "");
- static_assert(!__is_base_of(DerivedB<int>, BaseA<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));
+
+ static_assert(__is_base_of(Base, Derived));
+ static_assert(!__is_base_of(Derived, Base));
+
+ static_assert(__is_base_of(Base, CrazyDerived<Base>));
+ static_assert(!__is_base_of(CrazyDerived<Base>, Base));
+
+ static_assert(__is_base_of(BaseA<int>, DerivedB<int>));
+ static_assert(!__is_base_of(DerivedB<int>, BaseA<int>));
}
template<class T, class U>
@@ -2090,17 +2090,17 @@ typedef class Base BaseTypedef;
void is_same()
{
- static_assert(__is_same(Base, Base), "");
- static_assert(__is_same(Base, BaseTypedef), "");
- static_assert(__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>));
- static_assert(!__is_same(Base, const Base), "");
- static_assert(!__is_same(Base, Base&), "");
- static_assert(!__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.
- static_assert(__is_same_as(int, int), "");
- static_assert(!__is_same_as(int, float), "");
+ static_assert(__is_same_as(int, int));
+ static_assert(!__is_same_as(int, float));
}
struct IntWrapper
@@ -2128,14 +2128,14 @@ struct FloatWrapper
void is_convertible()
{
- 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), "");
+ 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); };
@@ -2156,30 +2156,30 @@ struct X0 {
struct Abstract { virtual void f() = 0; };
void is_convertible_to() {
- 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), "");
+ 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 {
@@ -2190,269 +2190,269 @@ namespace is_convertible_to_instantiate {
void is_trivial()
{
- 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), "");
+ 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()
{
- 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_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&)), "");
+ const NonTrivialDefault&)));
static_assert((__is_trivially_constructible(NonTrivialDefault,
- NonTrivialDefault&&)), "");
- static_assert((__is_trivially_constructible(AllDefaulted)), "");
+ NonTrivialDefault&&)));
+ static_assert((__is_trivially_constructible(AllDefaulted)));
static_assert((__is_trivially_constructible(AllDefaulted,
- const AllDefaulted &)), "");
+ const AllDefaulted &)));
static_assert((__is_trivially_constructible(AllDefaulted,
- 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(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 &)), "");
+ const AllDeleted &)));
static_assert(!(__is_trivially_constructible(AllDeleted,
- AllDeleted &&)), "");
- static_assert(!(__is_trivially_constructible(ExtDefaulted)), "");
+ AllDeleted &&)));
+ static_assert(!(__is_trivially_constructible(ExtDefaulted)));
static_assert(!(__is_trivially_constructible(ExtDefaulted,
- const 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*)), "");
+ 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 &)), "");
+ const AllDefaulted &)));
static_assert((__is_trivially_assignable(AllDefaulted,
- 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(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&)), "");
+ TrivialMoveButNotCopy&)));
static_assert(!(__is_trivially_assignable(TrivialMoveButNotCopy&,
- const TrivialMoveButNotCopy&)), "");
+ const TrivialMoveButNotCopy&)));
static_assert(!(__is_trivially_assignable(AllDeleted,
- const AllDeleted &)), "");
+ const AllDeleted &)));
static_assert(!(__is_trivially_assignable(AllDeleted,
- AllDeleted &&)), "");
+ AllDeleted &&)));
static_assert(!(__is_trivially_assignable(ExtDefaulted,
- const ExtDefaulted &)), "");
+ const ExtDefaulted &)));
static_assert(!(__is_trivially_assignable(ExtDefaulted,
- ExtDefaulted &&)), "");
+ ExtDefaulted &&)));
static_assert((__is_trivially_assignable(HasDefaultTrivialCopyAssign&,
- HasDefaultTrivialCopyAssign&)), "");
+ HasDefaultTrivialCopyAssign&)));
static_assert((__is_trivially_assignable(HasDefaultTrivialCopyAssign&,
- const HasDefaultTrivialCopyAssign&)), "");
+ const HasDefaultTrivialCopyAssign&)));
static_assert((__is_trivially_assignable(TrivialMoveButNotCopy&,
- 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*)), "");
+ 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 &)), "");
+ const AllDefaulted &)));
static_assert((__is_trivially_assignable(AllDefaulted,
- 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(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 &)), "");
+ TrivialMoveButNotCopy &)));
static_assert((__is_assignable(TrivialMoveButNotCopy &,
- const TrivialMoveButNotCopy &)), "");
+ const TrivialMoveButNotCopy &)));
static_assert(!(__is_assignable(AllDeleted,
- const AllDeleted &)), "");
+ const AllDeleted &)));
static_assert(!(__is_assignable(AllDeleted,
- AllDeleted &&)), "");
+ AllDeleted &&)));
static_assert((__is_assignable(ExtDefaulted,
- const ExtDefaulted &)), "");
+ const ExtDefaulted &)));
static_assert((__is_assignable(ExtDefaulted,
- ExtDefaulted &&)), "");
+ ExtDefaulted &&)));
static_assert((__is_assignable(HasDefaultTrivialCopyAssign &,
- HasDefaultTrivialCopyAssign &)), "");
+ HasDefaultTrivialCopyAssign &)));
static_assert((__is_assignable(HasDefaultTrivialCopyAssign &,
- const HasDefaultTrivialCopyAssign &)), "");
+ const HasDefaultTrivialCopyAssign &)));
static_assert((__is_assignable(TrivialMoveButNotCopy &,
- 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), "");
+ 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() {
- static_assert(__is_constructible(HasNoThrowConstructorWithArgs), "");
- static_assert(!__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.
- static_assert(__is_constructible(HasNoThrowConstructorWithArgs, HasCons), "");
- static_assert(__is_nothrow_constructible(HasNoThrowConstructorWithArgs, HasCons), "");
+ static_assert(__is_constructible(HasNoThrowConstructorWithArgs, HasCons));
+ static_assert(__is_nothrow_constructible(HasNoThrowConstructorWithArgs, HasCons));
- static_assert(__is_constructible(NonTrivialDefault), "");
- static_assert(!__is_nothrow_constructible(NonTrivialDefault), "");
+ static_assert(__is_constructible(NonTrivialDefault));
+ static_assert(!__is_nothrow_constructible(NonTrivialDefault));
- static_assert(__is_constructible(int), "");
- static_assert(__is_nothrow_constructible(int), "");
+ static_assert(__is_constructible(int));
+ static_assert(__is_nothrow_constructible(int));
- static_assert(!__is_constructible(NonPOD), "");
- static_assert(!__is_nothrow_constructible(NonPOD), "");
+ static_assert(!__is_constructible(NonPOD));
+ static_assert(!__is_nothrow_constructible(NonPOD));
- static_assert(__is_constructible(NonPOD, int), "");
- static_assert(!__is_nothrow_constructible(NonPOD, int), "");
+ static_assert(__is_constructible(NonPOD, int));
+ static_assert(!__is_nothrow_constructible(NonPOD, int));
// PR19178
- static_assert(!__is_constructible(Abstract), "");
- static_assert(!__is_nothrow_constructible(Abstract), "");
+ static_assert(!__is_constructible(Abstract));
+ static_assert(!__is_nothrow_constructible(Abstract));
// PR20228
static_assert(__is_constructible(VariadicCtor,
- int, int, int, int, int, int, int, int, int), "");
+ int, int, int, int, int, int, int, int, int));
// PR25513
- 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), "");
+ 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
@@ -2462,32 +2462,32 @@ struct is_trivially_constructible {
};
void is_trivially_constructible_test() {
- 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<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), "");
+ 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), "");
+ 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 &>
@@ -2497,161 +2497,161 @@ struct ConvertsToRef {
};
void reference_binds_to_temporary_checks() {
- static_assert(!(__reference_binds_to_temporary(int &, int &)), "");
- static_assert(!(__reference_binds_to_temporary(int &, int &&)), "");
+ static_assert(!(__reference_binds_to_temporary(int &, int &)));
+ static_assert(!(__reference_binds_to_temporary(int &, 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 &&)), "");
+ 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 &&)));
- 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 &)), "");
+ 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 &>;
- static_assert((__is_constructible(int &, LRef)), "");
- static_assert(!(__reference_binds_to_temporary(int &, LRef)), "");
+ static_assert((__is_constructible(int &, LRef)));
+ static_assert(!(__reference_binds_to_temporary(int &, LRef)));
- static_assert((__is_constructible(int &&, RRef)), "");
- static_assert(!(__reference_binds_to_temporary(int &&, RRef)), "");
+ static_assert((__is_constructible(int &&, RRef)));
+ static_assert(!(__reference_binds_to_temporary(int &&, RRef)));
- static_assert((__is_constructible(int const &, CLRef)), "");
- static_assert(!(__reference_binds_to_temporary(int &&, CLRef)), "");
+ static_assert((__is_constructible(int const &, CLRef)));
+ static_assert(!(__reference_binds_to_temporary(int &&, CLRef)));
- static_assert((__is_constructible(int const &, LongRef)), "");
- static_assert((__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.
- static_assert(!(__reference_binds_to_temporary(int, long)), "");
+ static_assert(!(__reference_binds_to_temporary(int, long)));
- static_assert((__reference_binds_to_temporary(const int &, long)), "");
+ static_assert((__reference_binds_to_temporary(const int &, long)));
}
void reference_constructs_from_temporary_checks() {
- static_assert(!__reference_constructs_from_temporary(int &, int &), "");
- static_assert(!__reference_constructs_from_temporary(int &, int &&), "");
+ static_assert(!__reference_constructs_from_temporary(int &, int &));
+ static_assert(!__reference_constructs_from_temporary(int &, int &&));
- static_assert(!__reference_constructs_from_temporary(int const &, int &), "");
- static_assert(!__reference_constructs_from_temporary(int const &, int const &), "");
- static_assert(!__reference_constructs_from_temporary(int const &, int &&), "");
+ static_assert(!__reference_constructs_from_temporary(int const &, int &));
+ static_assert(!__reference_constructs_from_temporary(int const &, int const &));
+ static_assert(!__reference_constructs_from_temporary(int const &, int &&));
- static_assert(!__reference_constructs_from_temporary(int &, long &), ""); // doesn't construct
+ static_assert(!__reference_constructs_from_temporary(int &, long &)); // doesn't construct
- static_assert(__reference_constructs_from_temporary(int const &, long &), "");
- static_assert(__reference_constructs_from_temporary(int const &, long &&), "");
- static_assert(__reference_constructs_from_temporary(int &&, long &), "");
+ static_assert(__reference_constructs_from_temporary(int const &, long &));
+ static_assert(__reference_constructs_from_temporary(int const &, long &&));
+ static_assert(__reference_constructs_from_temporary(int &&, long &));
using LRef = ConvertsToRef<int, int &>;
using RRef = ConvertsToRef<int, int &&>;
using CLRef = ConvertsToRef<int, const int &>;
using LongRef = ConvertsToRef<long, long &>;
- static_assert(__is_constructible(int &, LRef), "");
- static_assert(!__reference_constructs_from_temporary(int &, LRef), "");
+ static_assert(__is_constructible(int &, LRef));
+ static_assert(!__reference_constructs_from_temporary(int &, LRef));
- static_assert(__is_constructible(int &&, RRef), "");
- static_assert(!__reference_constructs_from_temporary(int &&, RRef), "");
+ static_assert(__is_constructible(int &&, RRef));
+ static_assert(!__reference_constructs_from_temporary(int &&, RRef));
- static_assert(__is_constructible(int const &, CLRef), "");
- static_assert(!__reference_constructs_from_temporary(int &&, CLRef), "");
+ static_assert(__is_constructible(int const &, CLRef));
+ static_assert(!__reference_constructs_from_temporary(int &&, CLRef));
- static_assert(__is_constructible(int const &, LongRef), "");
- static_assert(__reference_constructs_from_temporary(int const &, LongRef), "");
+ static_assert(__is_constructible(int const &, LongRef));
+ static_assert(__reference_constructs_from_temporary(int const &, LongRef));
// Test that it doesn't accept non-reference types as input.
- static_assert(!__reference_constructs_from_temporary(int, long), "");
+ static_assert(!__reference_constructs_from_temporary(int, long));
- static_assert(__reference_constructs_from_temporary(const int &, long), "");
+ static_assert(__reference_constructs_from_temporary(const int &, long));
// Additional checks
- static_assert(__reference_constructs_from_temporary(POD const&, Derives), "");
- static_assert(__reference_constructs_from_temporary(int&&, int), "");
- static_assert(__reference_constructs_from_temporary(const int&, int), "");
- static_assert(!__reference_constructs_from_temporary(int&&, int&&), "");
- static_assert(!__reference_constructs_from_temporary(const int&, int&&), "");
- static_assert(__reference_constructs_from_temporary(int&&, long&&), "");
- static_assert(__reference_constructs_from_temporary(int&&, long), "");
+ static_assert(__reference_constructs_from_temporary(POD const&, Derives));
+ static_assert(__reference_constructs_from_temporary(int&&, int));
+ static_assert(__reference_constructs_from_temporary(const int&, int));
+ static_assert(!__reference_constructs_from_temporary(int&&, int&&));
+ static_assert(!__reference_constructs_from_temporary(const int&, int&&));
+ static_assert(__reference_constructs_from_temporary(int&&, long&&));
+ static_assert(__reference_constructs_from_temporary(int&&, long));
}
void array_rank() {
- static_assert(__array_rank(IntAr) == 1, "");
- static_assert(__array_rank(ConstIntArAr) == 2, "");
+ static_assert(__array_rank(IntAr) == 1);
+ static_assert(__array_rank(ConstIntArAr) == 2);
}
void array_extent() {
- static_assert(__array_extent(IntAr, 0) == 10, "");
- static_assert(__array_extent(ConstIntArAr, 0) == 4, "");
- static_assert(__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() {
- 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), "");
+ 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() {
- 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), "");
+ 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() {
- 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), "");
+ 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
@@ -3027,8 +3027,8 @@ namespace PR46209 {
Foo foo;
};
- static_assert(!__is_trivially_assignable(Foo &, const Foo &), "");
- static_assert(!__is_trivially_assignable(Bar &, const Bar &), "");
+ static_assert(!__is_trivially_assignable(Foo &, const Foo &));
+ static_assert(!__is_trivially_assignable(Bar &, const Bar &));
// Foo2 has both a trivial assignment operator and a non-trivial one.
struct Foo2 {
@@ -3041,8 +3041,8 @@ namespace PR46209 {
Foo2 foo;
};
- static_assert(__is_trivially_assignable(Foo2 &, const Foo2 &), "");
- static_assert(__is_trivially_assignable(Bar2 &, const Bar2 &), "");
+ static_assert(__is_trivially_assignable(Foo2 &, const Foo2 &));
+ static_assert(__is_trivially_assignable(Bar2 &, const Bar2 &));
}
namespace ConstClass {
@@ -3052,7 +3052,7 @@ namespace ConstClass {
struct B {
const A a;
};
- static_assert(!__is_trivially_assignable(B&, const B&), "");
+ static_assert(!__is_trivially_assignable(B&, const B&));
}
namespace type_trait_expr_numargs_overflow {
@@ -3078,21 +3078,21 @@ void test() { (void) __is_constructible(int, T32768(int)); }
namespace is_trivially_relocatable {
-static_assert(!__is_trivially_relocatable(void), "");
-static_assert(__is_trivially_relocatable(int), "");
-static_assert(__is_trivially_relocatable(int[]), "");
+static_assert(!__is_trivially_relocatable(void));
+static_assert(__is_trivially_relocatable(int));
+static_assert(__is_trivially_relocatable(int[]));
enum Enum {};
-static_assert(__is_trivially_relocatable(Enum), "");
-static_assert(__is_trivially_relocatable(Enum[]), "");
+static_assert(__is_trivially_relocatable(Enum));
+static_assert(__is_trivially_relocatable(Enum[]));
union Union {int x;};
-static_assert(__is_trivially_relocatable(Union), "");
-static_assert(__is_trivially_relocatable(Union[]), "");
+static_assert(__is_trivially_relocatable(Union));
+static_assert(__is_trivially_relocatable(Union[]));
struct Trivial {};
-static_assert(__is_trivially_relocatable(Trivial), "");
-static_assert(__is_trivially_relocatable(Trivial[]), "");
+static_assert(__is_trivially_relocatable(Trivial));
+static_assert(__is_trivially_relocatable(Trivial[]));
struct Incomplete; // expected-note {{forward declaration of 'is_trivially_relocatable::Incomplete'}}
bool unused = __is_trivially_relocatable(Incomplete); // expected-error {{incomplete type}}
@@ -3100,67 +3100,67 @@ bool unused = __is_trivially_relocatable(Incomplete); // expected-error {{incomp
struct NontrivialDtor {
~NontrivialDtor() {}
};
-static_assert(!__is_trivially_relocatable(NontrivialDtor), "");
-static_assert(!__is_trivially_relocatable(NontrivialDtor[]), "");
+static_assert(!__is_trivially_relocatable(NontrivialDtor));
+static_assert(!__is_trivially_relocatable(NontrivialDtor[]));
struct NontrivialCopyCtor {
NontrivialCopyCtor(const NontrivialCopyCtor&) {}
};
-static_assert(!__is_trivially_relocatable(NontrivialCopyCtor), "");
-static_assert(!__is_trivially_relocatable(NontrivialCopyCtor[]), "");
+static_assert(!__is_trivially_relocatable(NontrivialCopyCtor));
+static_assert(!__is_trivially_relocatable(NontrivialCopyCtor[]));
struct NontrivialMoveCtor {
NontrivialMoveCtor(NontrivialMoveCtor&&) {}
};
-static_assert(!__is_trivially_relocatable(NontrivialMoveCtor), "");
-static_assert(!__is_trivially_relocatable(NontrivialMoveCtor[]), "");
+static_assert(!__is_trivially_relocatable(NontrivialMoveCtor));
+static_assert(!__is_trivially_relocatable(NontrivialMoveCtor[]));
struct [[clang::trivial_abi]] TrivialAbiNontrivialDtor {
~TrivialAbiNontrivialDtor() {}
};
-static_assert(__is_trivially_relocatable(TrivialAbiNontrivialDtor), "");
-static_assert(__is_trivially_relocatable(TrivialAbiNontrivialDtor[]), "");
+static_assert(__is_trivially_relocatable(TrivialAbiNontrivialDtor));
+static_assert(__is_trivially_relocatable(TrivialAbiNontrivialDtor[]));
struct [[clang::trivial_abi]] TrivialAbiNontrivialCopyCtor {
TrivialAbiNontrivialCopyCtor(const TrivialAbiNontrivialCopyCtor&) {}
};
-static_assert(__is_trivially_relocatable(TrivialAbiNontrivialCopyCtor), "");
-static_assert(__is_trivially_relocatable(TrivialAbiNontrivialCopyCtor[]), "");
+static_assert(__is_trivially_relocatable(TrivialAbiNontrivialCopyCtor));
+static_assert(__is_trivially_relocatable(TrivialAbiNontrivialCopyCtor[]));
// A more complete set of tests for the behavior of trivial_abi can be found in
// clang/test/SemaCXX/attr-trivial-abi.cpp
struct [[clang::trivial_abi]] TrivialAbiNontrivialMoveCtor {
TrivialAbiNontrivialMoveCtor(TrivialAbiNontrivialMoveCtor&&) {}
};
-static_assert(__is_trivially_relocatable(TrivialAbiNontrivialMoveCtor), "");
-static_assert(__is_trivially_relocatable(TrivialAbiNontrivialMoveCtor[]), "");
+static_assert(__is_trivially_relocatable(TrivialAbiNontrivialMoveCtor));
+static_assert(__is_trivially_relocatable(TrivialAbiNontrivialMoveCtor[]));
} // namespace is_trivially_relocatable
namespace is_trivially_equality_comparable {
struct ForwardDeclared; // expected-note {{forward declaration of 'is_trivially_equality_comparable::ForwardDeclared'}}
-static_assert(!__is_trivially_equality_comparable(ForwardDeclared), ""); // expected-error {{incomplete type 'ForwardDeclared' used in type trait expression}}
+static_assert(!__is_trivially_equality_comparable(ForwardDeclared)); // expected-error {{incomplete type 'ForwardDeclared' used in type trait expression}}
-static_assert(!__is_trivially_equality_comparable(void), "");
-static_assert(__is_trivially_equality_comparable(int), "");
-static_assert(!__is_trivially_equality_comparable(int[]), "");
-static_assert(!__is_trivially_equality_comparable(int[3]), "");
-static_assert(!__is_trivially_equality_comparable(float), "");
-static_assert(!__is_trivially_equality_comparable(double), "");
-static_assert(!__is_trivially_equality_comparable(long double), "");
+static_assert(!__is_trivially_equality_comparable(void));
+static_assert(__is_trivially_equality_comparable(int));
+static_assert(!__is_trivially_equality_comparable(int[]));
+static_assert(!__is_trivially_equality_comparable(int[3]));
+static_assert(!__is_trivially_equality_comparable(float));
+static_assert(!__is_trivially_equality_comparable(double));
+static_assert(!__is_trivially_equality_comparable(long double));
struct NonTriviallyEqualityComparableNoComparator {
int i;
int j;
};
-static_assert(!__is_trivially_equality_comparable(NonTriviallyEqualityComparableNoComparator), "");
+static_assert(!__is_trivially_equality_comparable(NonTriviallyEqualityComparableNoComparator));
struct NonTriviallyEqualityComparableNonDefaultedComparator {
int i;
int j;
bool operator==(const NonTriviallyEqualityComparableNonDefaultedComparator&);
};
-static_assert(!__is_trivially_equality_comparable(NonTriviallyEqualityComparableNonDefaultedComparator), "");
+static_assert(!__is_trivially_equality_comparable(NonTriviallyEqualityComparableNonDefaultedComparator));
#if __cplusplus >= 202002L
@@ -3214,7 +3214,7 @@ struct NotTriviallyEqualityComparableHasPadding {
bool operator==(const NotTriviallyEqualityComparableHasPadding&) const = default;
};
-static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasPadding), "");
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasPadding));
struct NotTriviallyEqualityComparableHasFloat {
float i;
@@ -3222,7 +3222,7 @@ struct NotTriviallyEqualityComparableHasFloat {
bool operator==(const NotTriviallyEqualityComparableHasFloat&) const = default;
};
-static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasFloat), "");
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasFloat));
struct NotTriviallyEqualityComparableHasTailPadding {
int i;
@@ -3230,14 +3230,14 @@ struct NotTriviallyEqualityComparableHasTailPadding {
bool operator==(const NotTriviallyEqualityComparableHasTailPadding&) const = default;
};
-static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasTailPadding), "");
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasTailPadding));
struct NotTriviallyEqualityComparableBase : NotTriviallyEqualityComparableHasTailPadding {
char j;
bool operator==(const NotTriviallyEqualityComparableBase&) const = default;
};
-static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBase), "");
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBase));
class TriviallyEqualityComparablePaddedOutBase {
int i;
@@ -3246,14 +3246,14 @@ class TriviallyEqualityComparablePaddedOutBase {
public:
bool operator==(const TriviallyEqualityComparablePaddedOutBase&) const = default;
};
-static_assert(!__is_trivially_equality_comparable(TriviallyEqualityComparablePaddedOutBase), "");
+static_assert(!__is_trivially_equality_comparable(TriviallyEqualityComparablePaddedOutBase));
struct TriviallyEqualityComparablePaddedOut : TriviallyEqualityComparablePaddedOutBase {
char j[3];
bool operator==(const TriviallyEqualityComparablePaddedOut&) const = default;
};
-static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparablePaddedOut), "");
+static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparablePaddedOut));
struct TriviallyEqualityComparable1 {
char i;
@@ -3376,7 +3376,7 @@ struct TriviallyEqualityComparable {
friend bool operator==(const TriviallyEqualityComparable&, const TriviallyEqualityComparable&) = default;
};
-static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable), "");
+static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable));
struct TriviallyEqualityComparableNonTriviallyCopyable {
TriviallyEqualityComparableNonTriviallyCopyable(const TriviallyEqualityComparableNonTriviallyCopyable&);
@@ -3392,7 +3392,7 @@ struct NotTriviallyEqualityComparableHasPadding {
friend bool operator==(const NotTriviallyEqualityComparableHasPadding&, const NotTriviallyEqualityComparableHasPadding&) = default;
};
-static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasPadding), "");
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasPadding));
struct NotTriviallyEqualityComparableHasFloat {
float i;
@@ -3400,7 +3400,7 @@ struct NotTriviallyEqualityComparableHasFloat {
friend bool operator==(const NotTriviallyEqualityComparableHasFloat&, const NotTriviallyEqualityComparableHasFloat&) = default;
};
-static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasFloat), "");
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasFloat));
struct NotTriviallyEqualityComparableHasTailPadding {
int i;
@@ -3408,14 +3408,14 @@ struct NotTriviallyEqualityComparableHasTailPadding {
friend bool operator==(const NotTriviallyEqualityComparableHasTailPadding&, const NotTriviallyEqualityComparableHasTailPadding&) = default;
};
-static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasTailPadding), "");
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasTailPadding));
struct NotTriviallyEqualityComparableBase : NotTriviallyEqualityComparableHasTailPadding {
char j;
friend bool operator==(const NotTriviallyEqualityComparableBase&, const NotTriviallyEqualityComparableBase&) = default;
};
-static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBase), "");
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBase));
class TriviallyEqualityComparablePaddedOutBase {
int i;
@@ -3424,14 +3424,14 @@ class TriviallyEqualityComparablePaddedOutBase {
public:
friend bool operator==(const TriviallyEqualityComparablePaddedOutBase&, const TriviallyEqualityComparablePaddedOutBase&) = default;
};
-static_assert(!__is_trivially_equality_comparable(TriviallyEqualityComparablePaddedOutBase), "");
+static_assert(!__is_trivially_equality_comparable(TriviallyEqualityComparablePaddedOutBase));
struct TriviallyEqualityComparablePaddedOut : TriviallyEqualityComparablePaddedOutBase {
char j[3];
friend bool operator==(const TriviallyEqualityComparablePaddedOut&, const TriviallyEqualityComparablePaddedOut&) = default;
};
-static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparablePaddedOut), "");
+static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparablePaddedOut));
struct TriviallyEqualityComparable1 {
char i;
@@ -3548,10 +3548,10 @@ union D {
int x;
};
-static_assert(__can_pass_in_regs(A), "");
-static_assert(__can_pass_in_regs(A), "");
-static_assert(!__can_pass_in_regs(B), "");
-static_assert(__can_pass_in_regs(D), "");
+static_assert(__can_pass_in_regs(A));
+static_assert(__can_pass_in_regs(A));
+static_assert(!__can_pass_in_regs(B));
+static_assert(__can_pass_in_regs(D));
void test_errors() {
(void)__can_pass_in_regs(const A); // expected-error {{not an unqualified class type}}
@@ -3568,379 +3568,379 @@ struct S {};
template <class T> using remove_const_t = __remove_const(T);
void check_remove_const() {
- static_assert(__is_same(remove_const_t<void>, void), "");
- static_assert(__is_same(remove_const_t<const void>, void), "");
- static_assert(__is_same(remove_const_t<int>, int), "");
- static_assert(__is_same(remove_const_t<const int>, int), "");
- static_assert(__is_same(remove_const_t<volatile int>, volatile int), "");
- static_assert(__is_same(remove_const_t<const volatile int>, volatile int), "");
- static_assert(__is_same(remove_const_t<int *>, int *), "");
- static_assert(__is_same(remove_const_t<int *const>, int *), "");
- static_assert(__is_same(remove_const_t<int const *const>, int const *), "");
- static_assert(__is_same(remove_const_t<int const *const __restrict>, int const *__restrict), "");
- static_assert(__is_same(remove_const_t<int &>, int &), "");
- static_assert(__is_same(remove_const_t<int const &>, int const &), "");
- static_assert(__is_same(remove_const_t<int &&>, int &&), "");
- static_assert(__is_same(remove_const_t<int const &&>, int const &&), "");
- static_assert(__is_same(remove_const_t<int()>, int()), "");
- static_assert(__is_same(remove_const_t<int (*const)()>, int (*)()), "");
- static_assert(__is_same(remove_const_t<int (&)()>, int (&)()), "");
-
- static_assert(__is_same(remove_const_t<S>, S), "");
- static_assert(__is_same(remove_const_t<const S>, S), "");
- static_assert(__is_same(remove_const_t<volatile S>, volatile S), "");
- static_assert(__is_same(remove_const_t<S *__restrict>, S *__restrict), "");
- static_assert(__is_same(remove_const_t<const volatile S>, volatile S), "");
- static_assert(__is_same(remove_const_t<S *const volatile __restrict>, S *volatile __restrict), "");
- static_assert(__is_same(remove_const_t<int S::*const>, int S::*), "");
- static_assert(__is_same(remove_const_t<int (S::*const)()>, int(S::*)()), "");
+ static_assert(__is_same(remove_const_t<void>, void));
+ static_assert(__is_same(remove_const_t<const void>, void));
+ static_assert(__is_same(remove_const_t<int>, int));
+ static_assert(__is_same(remove_const_t<const int>, int));
+ static_assert(__is_same(remove_const_t<volatile int>, volatile int));
+ static_assert(__is_same(remove_const_t<const volatile int>, volatile int));
+ static_assert(__is_same(remove_const_t<int *>, int *));
+ static_assert(__is_same(remove_const_t<int *const>, int *));
+ static_assert(__is_same(remove_const_t<int const *const>, int const *));
+ static_assert(__is_same(remove_const_t<int const *const __restrict>, int const *__restrict));
+ static_assert(__is_same(remove_const_t<int &>, int &));
+ static_assert(__is_same(remove_const_t<int const &>, int const &));
+ static_assert(__is_same(remove_const_t<int &&>, int &&));
+ static_assert(__is_same(remove_const_t<int const &&>, int const &&));
+ static_assert(__is_same(remove_const_t<int()>, int()));
+ static_assert(__is_same(remove_const_t<int (*const)()>, int (*)()));
+ static_assert(__is_same(remove_const_t<int (&)()>, int (&)()));
+
+ static_assert(__is_same(remove_const_t<S>, S));
+ static_assert(__is_same(remove_const_t<const S>, S));
+ static_assert(__is_same(remove_const_t<volatile S>, volatile S));
+ static_assert(__is_same(remove_const_t<S *__restrict>, S *__restrict));
+ static_assert(__is_same(remove_const_t<const volatile S>, volatile S));
+ static_assert(__is_same(remove_const_t<S *const volatile __restrict>, S *volatile __restrict));
+ static_assert(__is_same(remove_const_t<int S::*const>, int S::*));
+ static_assert(__is_same(remove_const_t<int (S::*const)()>, int(S::*)()));
}
template <class T> using remove_restrict_t = __remove_restrict(T);
void check_remove_restrict() {
- static_assert(__is_same(remove_restrict_t<void>, void), "");
- static_assert(__is_same(remove_restrict_t<int>, int), "");
- static_assert(__is_same(remove_restrict_t<const int>, const int), "");
- static_assert(__is_same(remove_restrict_t<volatile int>, volatile int), "");
- static_assert(__is_same(remove_restrict_t<int *__restrict>, int *), "");
- static_assert(__is_same(remove_restrict_t<int *const volatile __restrict>, int *const volatile), "");
- static_assert(__is_same(remove_restrict_t<int *>, int *), "");
- static_assert(__is_same(remove_restrict_t<int *__restrict>, int *), "");
- static_assert(__is_same(remove_restrict_t<int &>, int &), "");
- static_assert(__is_same(remove_restrict_t<int &__restrict>, int &), "");
- static_assert(__is_same(remove_restrict_t<int &&>, int &&), "");
- static_assert(__is_same(remove_restrict_t<int &&__restrict>, int &&), "");
- static_assert(__is_same(remove_restrict_t<int()>, int()), "");
- static_assert(__is_same(remove_restrict_t<int (*const volatile)()>, int (*const volatile)()), "");
- static_assert(__is_same(remove_restrict_t<int (&)()>, int (&)()), "");
-
- static_assert(__is_same(remove_restrict_t<S>, S), "");
- static_assert(__is_same(remove_restrict_t<const S>, const S), "");
- static_assert(__is_same(remove_restrict_t<volatile S>, volatile S), "");
- static_assert(__is_same(remove_restrict_t<S *__restrict>, S *), "");
- static_assert(__is_same(remove_restrict_t<S *const volatile __restrict>, S *const volatile), "");
- static_assert(__is_same(remove_restrict_t<int S::*__restrict>, int S::*), "");
- static_assert(__is_same(remove_restrict_t<int (S::*const volatile)()>, int(S::*const volatile)()), "");
+ static_assert(__is_same(remove_restrict_t<void>, void));
+ static_assert(__is_same(remove_restrict_t<int>, int));
+ static_assert(__is_same(remove_restrict_t<const int>, const int));
+ static_assert(__is_same(remove_restrict_t<volatile int>, volatile int));
+ static_assert(__is_same(remove_restrict_t<int *__restrict>, int *));
+ static_assert(__is_same(remove_restrict_t<int *const volatile __restrict>, int *const volatile));
+ static_assert(__is_same(remove_restrict_t<int *>, int *));
+ static_assert(__is_same(remove_restrict_t<int *__restrict>, int *));
+ static_assert(__is_same(remove_restrict_t<int &>, int &));
+ static_assert(__is_same(remove_restrict_t<int &__restrict>, int &));
+ static_assert(__is_same(remove_restrict_t<int &&>, int &&));
+ static_assert(__is_same(remove_restrict_t<int &&__restrict>, int &&));
+ static_assert(__is_same(remove_restrict_t<int()>, int()));
+ static_assert(__is_same(remove_restrict_t<int (*const volatile)()>, int (*const volatile)()));
+ static_assert(__is_same(remove_restrict_t<int (&)()>, int (&)()));
+
+ static_assert(__is_same(remove_restrict_t<S>, S));
+ static_assert(__is_same(remove_restrict_t<const S>, const S));
+ static_assert(__is_same(remove_restrict_t<volatile S>, volatile S));
+ static_assert(__is_same(remove_restrict_t<S *__restrict>, S *));
+ static_assert(__is_same(remove_restrict_t<S *const volatile __restrict>, S *const volatile));
+ static_assert(__is_same(remove_restrict_t<int S::*__restrict>, int S::*));
+ static_assert(__is_same(remove_restrict_t<int (S::*const volatile)()>, int(S::*const volatile)()));
}
template <class T> using remove_volatile_t = __remove_volatile(T);
void check_remove_volatile() {
- static_assert(__is_same(remove_volatile_t<void>, void), "");
- static_assert(__is_same(remove_volatile_t<volatile void>, void), "");
- static_assert(__is_same(remove_volatile_t<int>, int), "");
- static_assert(__is_same(remove_volatile_t<const int>, const int), "");
- static_assert(__is_same(remove_volatile_t<volatile int>, int), "");
- static_assert(__is_same(remove_volatile_t<int *__restrict>, int *__restrict), "");
- static_assert(__is_same(remove_volatile_t<const volatile int>, const int), "");
- static_assert(__is_same(remove_volatile_t<int *const volatile __restrict>, int *const __restrict), "");
- static_assert(__is_same(remove_volatile_t<int *>, int *), "");
- static_assert(__is_same(remove_volatile_t<int *volatile>, int *), "");
- static_assert(__is_same(remove_volatile_t<int volatile *volatile>, int volatile *), "");
- static_assert(__is_same(remove_volatile_t<int &>, int &), "");
- static_assert(__is_same(remove_volatile_t<int volatile &>, int volatile &), "");
- static_assert(__is_same(remove_volatile_t<int &&>, int &&), "");
- static_assert(__is_same(remove_volatile_t<int volatile &&>, int volatile &&), "");
- static_assert(__is_same(remove_volatile_t<int()>, int()), "");
- static_assert(__is_same(remove_volatile_t<int (*volatile)()>, int (*)()), "");
- static_assert(__is_same(remove_volatile_t<int (&)()>, int (&)()), "");
-
- static_assert(__is_same(remove_volatile_t<S>, S), "");
- static_assert(__is_same(remove_volatile_t<const S>, const S), "");
- static_assert(__is_same(remove_volatile_t<volatile S>, S), "");
- static_assert(__is_same(remove_volatile_t<const volatile S>, const S), "");
- static_assert(__is_same(remove_volatile_t<int S::*volatile>, int S::*), "");
- static_assert(__is_same(remove_volatile_t<int (S::*volatile)()>, int(S::*)()), "");
+ static_assert(__is_same(remove_volatile_t<void>, void));
+ static_assert(__is_same(remove_volatile_t<volatile void>, void));
+ static_assert(__is_same(remove_volatile_t<int>, int));
+ static_assert(__is_same(remove_volatile_t<const int>, const int));
+ static_assert(__is_same(remove_volatile_t<volatile int>, int));
+ static_assert(__is_same(remove_volatile_t<int *__restrict>, int *__restrict));
+ static_assert(__is_same(remove_volatile_t<const volatile int>, const int));
+ static_assert(__is_same(remove_volatile_t<int *const volatile __restrict>, int *const __restrict));
+ static_assert(__is_same(remove_volatile_t<int *>, int *));
+ static_assert(__is_same(remove_volatile_t<int *volatile>, int *));
+ static_assert(__is_same(remove_volatile_t<int volatile *volatile>, int volatile *));
+ static_assert(__is_same(remove_volatile_t<int &>, int &));
+ static_assert(__is_same(remove_volatile_t<int volatile &>, int volatile &));
+ static_assert(__is_same(remove_volatile_t<int &&>, int &&));
+ static_assert(__is_same(remove_volatile_t<int volatile &&>, int volatile &&));
+ static_assert(__is_same(remove_volatile_t<int()>, int()));
+ static_assert(__is_same(remove_volatile_t<int (*volatile)()>, int (*)()));
+ static_assert(__is_same(remove_volatile_t<int (&)()>, int (&)()));
+
+ static_assert(__is_same(remove_volatile_t<S>, S));
+ static_assert(__is_same(remove_volatile_t<const S>, const S));
+ static_assert(__is_same(remove_volatile_t<volatile S>, S));
+ static_assert(__is_same(remove_volatile_t<const volatile S>, const S));
+ static_assert(__is_same(remove_volatile_t<int S::*volatile>, int S::*));
+ static_assert(__is_same(remove_volatile_t<int (S::*volatile)()>, int(S::*)()));
}
template <class T> using remove_cv_t = __remove_cv(T);
void check_remove_cv() {
- static_assert(__is_same(remove_cv_t<void>, void), "");
- static_assert(__is_same(remove_cv_t<const volatile void>, void), "");
- static_assert(__is_same(remove_cv_t<int>, int), "");
- static_assert(__is_same(remove_cv_t<const int>, int), "");
- static_assert(__is_same(remove_cv_t<volatile int>, int), "");
- static_assert(__is_same(remove_cv_t<const volatile int>, int), "");
- static_assert(__is_same(remove_cv_t<int *>, int *), "");
- static_assert(__is_same(remove_cv_t<int *const volatile>, int *), "");
- static_assert(__is_same(remove_cv_t<int const *const volatile>, int const *), "");
- static_assert(__is_same(remove_cv_t<int const *const volatile __restrict>, int const *__restrict), "");
- static_assert(__is_same(remove_cv_t<int const *const volatile _Nonnull>, int const *_Nonnull), "");
- static_assert(__is_same(remove_cv_t<int &>, int &), "");
- static_assert(__is_same(remove_cv_t<int const volatile &>, int const volatile &), "");
- static_assert(__is_same(remove_cv_t<int &&>, int &&), "");
- static_assert(__is_same(remove_cv_t<int const volatile &&>, int const volatile &&), "");
- static_assert(__is_same(remove_cv_t<int()>, int()), "");
- static_assert(__is_same(remove_cv_t<int (*const volatile)()>, int (*)()), "");
- static_assert(__is_same(remove_cv_t<int (&)()>, int (&)()), "");
-
- static_assert(__is_same(remove_cv_t<S>, S), "");
- static_assert(__is_same(remove_cv_t<const S>, S), "");
- static_assert(__is_same(remove_cv_t<volatile S>, S), "");
- static_assert(__is_same(remove_cv_t<const volatile S>, S), "");
- static_assert(__is_same(remove_cv_t<int S::*const volatile>, int S::*), "");
- static_assert(__is_same(remove_cv_t<int (S::*const volatile)()>, int(S::*)()), "");
+ static_assert(__is_same(remove_cv_t<void>, void));
+ static_assert(__is_same(remove_cv_t<const volatile void>, void));
+ static_assert(__is_same(remove_cv_t<int>, int));
+ static_assert(__is_same(remove_cv_t<const int>, int));
+ static_assert(__is_same(remove_cv_t<volatile int>, int));
+ static_assert(__is_same(remove_cv_t<const volatile int>, int));
+ static_assert(__is_same(remove_cv_t<int *>, int *));
+ static_assert(__is_same(remove_cv_t<int *const volatile>, int *));
+ static_assert(__is_same(remove_cv_t<int const *const volatile>, int const *));
+ static_assert(__is_same(remove_cv_t<int const *const volatile __restrict>, int const *__restrict));
+ static_assert(__is_same(remove_cv_t<int const *const volatile _Nonnull>, int const *_Nonnull));
+ static_assert(__is_same(remove_cv_t<int &>, int &));
+ static_assert(__is_same(remove_cv_t<int const volatile &>, int const volatile &));
+ static_assert(__is_same(remove_cv_t<int &&>, int &&));
+ static_assert(__is_same(remove_cv_t<int const volatile &&>, int const volatile &&));
+ static_assert(__is_same(remove_cv_t<int()>, int()));
+ static_assert(__is_same(remove_cv_t<int (*const volatile)()>, int (*)()));
+ static_assert(__is_same(remove_cv_t<int (&)()>, int (&)()));
+
+ static_assert(__is_same(remove_cv_t<S>, S));
+ static_assert(__is_same(remove_cv_t<const S>, S));
+ static_assert(__is_same(remove_cv_t<volatile S>, S));
+ static_assert(__is_same(remove_cv_t<const volatile S>, S));
+ static_assert(__is_same(remove_cv_t<int S::*const volatile>, int S::*));
+ static_assert(__is_same(remove_cv_t<int (S::*const volatile)()>, int(S::*)()));
}
template <class T> using add_pointer_t = __add_pointer(T);
void add_pointer() {
- static_assert(__is_same(add_pointer_t<void>, void *), "");
- static_assert(__is_same(add_pointer_t<const void>, const void *), "");
- static_assert(__is_same(add_pointer_t<volatile void>, volatile void *), "");
- static_assert(__is_same(add_pointer_t<const volatile void>, const volatile void *), "");
- static_assert(__is_same(add_pointer_t<int>, int *), "");
- static_assert(__is_same(add_pointer_t<const int>, const int *), "");
- static_assert(__is_same(add_pointer_t<volatile int>, volatile int *), "");
- static_assert(__is_same(add_pointer_t<const volatile int>, const volatile int *), "");
- static_assert(__is_same(add_pointer_t<int *>, int **), "");
- static_assert(__is_same(add_pointer_t<int &>, int *), "");
- static_assert(__is_same(add_pointer_t<int &&>, int *), "");
- static_assert(__is_same(add_pointer_t<int()>, int (*)()), "");
- static_assert(__is_same(add_pointer_t<int (*)()>, int (**)()), "");
- static_assert(__is_same(add_pointer_t<int (&)()>, int (*)()), "");
-
- static_assert(__is_same(add_pointer_t<S>, S *), "");
- static_assert(__is_same(add_pointer_t<const S>, const S *), "");
- static_assert(__is_same(add_pointer_t<volatile S>, volatile S *), "");
- static_assert(__is_same(add_pointer_t<const volatile S>, const volatile S *), "");
- static_assert(__is_same(add_pointer_t<int S::*>, int S::**), "");
- static_assert(__is_same(add_pointer_t<int (S::*)()>, int(S::**)()), "");
-
- static_assert(__is_same(add_pointer_t<int __attribute__((address_space(1)))>, int __attribute__((address_space(1))) *), "");
- static_assert(__is_same(add_pointer_t<S __attribute__((address_space(2)))>, S __attribute__((address_space(2))) *), "");
+ static_assert(__is_same(add_pointer_t<void>, void *));
+ static_assert(__is_same(add_pointer_t<const void>, const void *));
+ static_assert(__is_same(add_pointer_t<volatile void>, volatile void *));
+ static_assert(__is_same(add_pointer_t<const volatile void>, const volatile void *));
+ static_assert(__is_same(add_pointer_t<int>, int *));
+ static_assert(__is_same(add_pointer_t<const int>, const int *));
+ static_assert(__is_same(add_pointer_t<volatile int>, volatile int *));
+ static_assert(__is_same(add_pointer_t<const volatile int>, const volatile int *));
+ static_assert(__is_same(add_pointer_t<int *>, int **));
+ static_assert(__is_same(add_pointer_t<int &>, int *));
+ static_assert(__is_same(add_pointer_t<int &&>, int *));
+ static_assert(__is_same(add_pointer_t<int()>, int (*)()));
+ static_assert(__is_same(add_pointer_t<int (*)()>, int (**)()));
+ static_assert(__is_same(add_pointer_t<int (&)()>, int (*)()));
+
+ static_assert(__is_same(add_pointer_t<S>, S *));
+ static_assert(__is_same(add_pointer_t<const S>, const S *));
+ static_assert(__is_same(add_pointer_t<volatile S>, volatile S *));
+ static_assert(__is_same(add_pointer_t<const volatile S>, const volatile S *));
+ static_assert(__is_same(add_pointer_t<int S::*>, int S::**));
+ static_assert(__is_same(add_pointer_t<int (S::*)()>, int(S::**)()));
+
+ static_assert(__is_same(add_pointer_t<int __attribute__((address_space(1)))>, int __attribute__((address_space(1))) *));
+ static_assert(__is_same(add_pointer_t<S __attribute__((address_space(2)))>, S __attribute__((address_space(2))) *));
}
template <class T> using remove_pointer_t = __remove_pointer(T);
void remove_pointer() {
- static_assert(__is_same(remove_pointer_t<void>, void), "");
- static_assert(__is_same(remove_pointer_t<const void>, const void), "");
- static_assert(__is_same(remove_pointer_t<volatile void>, volatile void), "");
- static_assert(__is_same(remove_pointer_t<const volatile void>, const volatile void), "");
- static_assert(__is_same(remove_pointer_t<int>, int), "");
- static_assert(__is_same(remove_pointer_t<const int>, const int), "");
- static_assert(__is_same(remove_pointer_t<volatile int>, volatile int), "");
- static_assert(__is_same(remove_pointer_t<const volatile int>, const volatile int), "");
- static_assert(__is_same(remove_pointer_t<int *>, int), "");
- static_assert(__is_same(remove_pointer_t<const int *>, const int), "");
- static_assert(__is_same(remove_pointer_t<volatile int *>, volatile int), "");
- static_assert(__is_same(remove_pointer_t<const volatile int *>, const volatile int), "");
- static_assert(__is_same(remove_pointer_t<int *const>, int), "");
- static_assert(__is_same(remove_pointer_t<int *volatile>, int), "");
- static_assert(__is_same(remove_pointer_t<int *const volatile>, int), "");
- static_assert(__is_same(remove_pointer_t<int &>, int &), "");
- static_assert(__is_same(remove_pointer_t<int &&>, int &&), "");
- static_assert(__is_same(remove_pointer_t<int()>, int()), "");
- static_assert(__is_same(remove_pointer_t<int (*)()>, int()), "");
- static_assert(__is_same(remove_pointer_t<int (&)()>, int (&)()), "");
-
- static_assert(__is_same(remove_pointer_t<S>, S), "");
- static_assert(__is_same(remove_pointer_t<const S>, const S), "");
- static_assert(__is_same(remove_pointer_t<volatile S>, volatile S), "");
- static_assert(__is_same(remove_pointer_t<const volatile S>, const volatile S), "");
- static_assert(__is_same(remove_pointer_t<int S::*>, int S::*), "");
- static_assert(__is_same(remove_pointer_t<int (S::*)()>, int(S::*)()), "");
-
- static_assert(__is_same(remove_pointer_t<int __attribute__((address_space(1))) *>, int __attribute__((address_space(1)))), "");
- static_assert(__is_same(remove_pointer_t<S __attribute__((address_space(2))) *>, S __attribute__((address_space(2)))), "");
-
- static_assert(__is_same(remove_pointer_t<int (^)(char)>, int (^)(char)), "");
+ static_assert(__is_same(remove_pointer_t<void>, void));
+ static_assert(__is_same(remove_pointer_t<const void>, const void));
+ static_assert(__is_same(remove_pointer_t<volatile void>, volatile void));
+ static_assert(__is_same(remove_pointer_t<const volatile void>, const volatile void));
+ static_assert(__is_same(remove_pointer_t<int>, int));
+ static_assert(__is_same(remove_pointer_t<const int>, const int));
+ static_assert(__is_same(remove_pointer_t<volatile int>, volatile int));
+ static_assert(__is_same(remove_pointer_t<const volatile int>, const volatile int));
+ static_assert(__is_same(remove_pointer_t<int *>, int));
+ static_assert(__is_same(remove_pointer_t<const int *>, const int));
+ static_assert(__is_same(remove_pointer_t<volatile int *>, volatile int));
+ static_assert(__is_same(remove_pointer_t<const volatile int *>, const volatile int));
+ static_assert(__is_same(remove_pointer_t<int *const>, int));
+ static_assert(__is_same(remove_pointer_t<int *volatile>, int));
+ static_assert(__is_same(remove_pointer_t<int *const volatile>, int));
+ static_assert(__is_same(remove_pointer_t<int &>, int &));
+ static_assert(__is_same(remove_pointer_t<int &&>, int &&));
+ static_assert(__is_same(remove_pointer_t<int()>, int()));
+ static_assert(__is_same(remove_pointer_t<int (*)()>, int()));
+ static_assert(__is_same(remove_pointer_t<int (&)()>, int (&)()));
+
+ static_assert(__is_same(remove_pointer_t<S>, S));
+ static_assert(__is_same(remove_pointer_t<const S>, const S));
+ static_assert(__is_same(remove_pointer_t<volatile S>, volatile S));
+ static_assert(__is_same(remove_pointer_t<const volatile S>, const volatile S));
+ static_assert(__is_same(remove_pointer_t<int S::*>, int S::*));
+ static_assert(__is_same(remove_pointer_t<int (S::*)()>, int(S::*)()));
+
+ static_assert(__is_same(remove_pointer_t<int __attribute__((address_space(1))) *>, int __attribute__((address_space(1)))));
+ static_assert(__is_same(remove_pointer_t<S __attribute__((address_space(2))) *>, S __attribute__((address_space(2)))));
+
+ static_assert(__is_same(remove_pointer_t<int (^)(char)>, int (^)(char)));
}
template <class T> using add_lvalue_reference_t = __add_lvalue_reference(T);
void add_lvalue_reference() {
- static_assert(__is_same(add_lvalue_reference_t<void>, void), "");
- static_assert(__is_same(add_lvalue_reference_t<const void>, const void), "");
- static_assert(__is_same(add_lvalue_reference_t<volatile void>, volatile void), "");
- static_assert(__is_same(add_lvalue_reference_t<const volatile void>, const volatile void), "");
- static_assert(__is_same(add_lvalue_reference_t<int>, int &), "");
- static_assert(__is_same(add_lvalue_reference_t<const int>, const int &), "");
- static_assert(__is_same(add_lvalue_reference_t<volatile int>, volatile int &), "");
- static_assert(__is_same(add_lvalue_reference_t<const volatile int>, const volatile int &), "");
- static_assert(__is_same(add_lvalue_reference_t<int *>, int *&), "");
- static_assert(__is_same(add_lvalue_reference_t<int &>, int &), "");
- static_assert(__is_same(add_lvalue_reference_t<int &&>, int &), ""); // reference collapsing
- static_assert(__is_same(add_lvalue_reference_t<int()>, int (&)()), "");
- static_assert(__is_same(add_lvalue_reference_t<int (*)()>, int (*&)()), "");
- static_assert(__is_same(add_lvalue_reference_t<int (&)()>, int (&)()), "");
-
- static_assert(__is_same(add_lvalue_reference_t<S>, S &), "");
- static_assert(__is_same(add_lvalue_reference_t<const S>, const S &), "");
- static_assert(__is_same(add_lvalue_reference_t<volatile S>, volatile S &), "");
- static_assert(__is_same(add_lvalue_reference_t<const volatile S>, const volatile S &), "");
- static_assert(__is_same(add_lvalue_reference_t<int S::*>, int S::*&), "");
- static_assert(__is_same(add_lvalue_reference_t<int (S::*)()>, int(S::*&)()), "");
+ static_assert(__is_same(add_lvalue_reference_t<void>, void));
+ static_assert(__is_same(add_lvalue_reference_t<const void>, const void));
+ static_assert(__is_same(add_lvalue_reference_t<volatile void>, volatile void));
+ static_assert(__is_same(add_lvalue_reference_t<const volatile void>, const volatile void));
+ static_assert(__is_same(add_lvalue_reference_t<int>, int &));
+ static_assert(__is_same(add_lvalue_reference_t<const int>, const int &));
+ static_assert(__is_same(add_lvalue_reference_t<volatile int>, volatile int &));
+ static_assert(__is_same(add_lvalue_reference_t<const volatile int>, const volatile int &));
+ static_assert(__is_same(add_lvalue_reference_t<int *>, int *&));
+ static_assert(__is_same(add_lvalue_reference_t<int &>, int &));
+ static_assert(__is_same(add_lvalue_reference_t<int &&>, int &)); // reference collapsing
+ static_assert(__is_same(add_lvalue_reference_t<int()>, int (&)()));
+ static_assert(__is_same(add_lvalue_reference_t<int (*)()>, int (*&)()));
+ static_assert(__is_same(add_lvalue_reference_t<int (&)()>, int (&)()));
+
+ static_assert(__is_same(add_lvalue_reference_t<S>, S &));
+ static_assert(__is_same(add_lvalue_reference_t<const S>, const S &));
+ static_assert(__is_same(add_lvalue_reference_t<volatile S>, volatile S &));
+ static_assert(__is_same(add_lvalue_reference_t<const volatile S>, const volatile S &));
+ static_assert(__is_same(add_lvalue_reference_t<int S::*>, int S::*&));
+ static_assert(__is_same(add_lvalue_reference_t<int (S::*)()>, int(S::*&)()));
}
template <class T> using add_rvalue_reference_t = __add_rvalue_reference(T);
void add_rvalue_reference() {
- static_assert(__is_same(add_rvalue_reference_t<void>, void), "");
- static_assert(__is_same(add_rvalue_reference_t<const void>, const void), "");
- static_assert(__is_same(add_rvalue_reference_t<volatile void>, volatile void), "");
- static_assert(__is_same(add_rvalue_reference_t<const volatile void>, const volatile void), "");
- static_assert(__is_same(add_rvalue_reference_t<int>, int &&), "");
- static_assert(__is_same(add_rvalue_reference_t<const int>, const int &&), "");
- static_assert(__is_same(add_rvalue_reference_t<volatile int>, volatile int &&), "");
- static_assert(__is_same(add_rvalue_reference_t<const volatile int>, const volatile int &&), "");
- static_assert(__is_same(add_rvalue_reference_t<int *>, int *&&), "");
- static_assert(__is_same(add_rvalue_reference_t<int &>, int &), ""); // reference collapsing
- static_assert(__is_same(add_rvalue_reference_t<int &&>, int &&), "");
- static_assert(__is_same(add_rvalue_reference_t<int()>, int(&&)()), "");
- static_assert(__is_same(add_rvalue_reference_t<int (*)()>, int (*&&)()), "");
- static_assert(__is_same(add_rvalue_reference_t<int (&)()>, int (&)()), ""); // reference collapsing
-
- static_assert(__is_same(add_rvalue_reference_t<S>, S &&), "");
- static_assert(__is_same(add_rvalue_reference_t<const S>, const S &&), "");
- static_assert(__is_same(add_rvalue_reference_t<volatile S>, volatile S &&), "");
- static_assert(__is_same(add_rvalue_reference_t<const volatile S>, const volatile S &&), "");
- static_assert(__is_same(add_rvalue_reference_t<int S::*>, int S::*&&), "");
- static_assert(__is_same(add_rvalue_reference_t<int (S::*)()>, int(S::* &&)()), "");
+ static_assert(__is_same(add_rvalue_reference_t<void>, void));
+ static_assert(__is_same(add_rvalue_reference_t<const void>, const void));
+ static_assert(__is_same(add_rvalue_reference_t<volatile void>, volatile void));
+ static_assert(__is_same(add_rvalue_reference_t<const volatile void>, const volatile void));
+ static_assert(__is_same(add_rvalue_reference_t<int>, int &&));
+ static_assert(__is_same(add_rvalue_reference_t<const int>, const int &&));
+ static_assert(__is_same(add_rvalue_reference_t<volatile int>, volatile int &&));
+ static_assert(__is_same(add_rvalue_reference_t<const volatile int>, const volatile int &&));
+ static_assert(__is_same(add_rvalue_reference_t<int *>, int *&&));
+ static_assert(__is_same(add_rvalue_reference_t<int &>, int &)); // reference collapsing
+ static_assert(__is_same(add_rvalue_reference_t<int &&>, int &&));
+ static_assert(__is_same(add_rvalue_reference_t<int()>, int(&&)()));
+ static_assert(__is_same(add_rvalue_reference_t<int (*)()>, int (*&&)()));
+ static_assert(__is_same(add_rvalue_reference_t<int (&)()>, int (&)())); // reference collapsing
+
+ static_assert(__is_same(add_rvalue_reference_t<S>, S &&));
+ static_assert(__is_same(add_rvalue_reference_t<const S>, const S &&));
+ static_assert(__is_same(add_rvalue_reference_t<volatile S>, volatile S &&));
+ static_assert(__is_same(add_rvalue_reference_t<const volatile S>, const volatile S &&));
+ static_assert(__is_same(add_rvalue_reference_t<int S::*>, int S::*&&));
+ static_assert(__is_same(add_rvalue_reference_t<int (S::*)()>, int(S::* &&)()));
}
template <class T> using remove_reference_t = __remove_reference_t(T);
void check_remove_reference() {
- static_assert(__is_same(remove_reference_t<void>, void), "");
- static_assert(__is_same(remove_reference_t<const volatile void>, const volatile void), "");
- static_assert(__is_same(remove_reference_t<int>, int), "");
- static_assert(__is_same(remove_reference_t<const int>, const int), "");
- static_assert(__is_same(remove_reference_t<volatile int>, volatile int), "");
- static_assert(__is_same(remove_reference_t<const volatile int>, const volatile int), "");
- static_assert(__is_same(remove_reference_t<int *>, int *), "");
- static_assert(__is_same(remove_reference_t<int *const volatile>, int *const volatile), "");
- static_assert(__is_same(remove_reference_t<int const *const volatile>, int const *const volatile), "");
- static_assert(__is_same(remove_reference_t<int &>, int), "");
- static_assert(__is_same(remove_reference_t<int const volatile &>, int const volatile), "");
- static_assert(__is_same(remove_reference_t<int &&>, int), "");
- static_assert(__is_same(remove_reference_t<int const volatile &&>, int const volatile), "");
- static_assert(__is_same(remove_reference_t<int()>, int()), "");
- static_assert(__is_same(remove_reference_t<int (*const volatile)()>, int (*const volatile)()), "");
- static_assert(__is_same(remove_reference_t<int (&)()>, int()), "");
-
- static_assert(__is_same(remove_reference_t<S>, S), "");
- static_assert(__is_same(remove_reference_t<S &>, S), "");
- static_assert(__is_same(remove_reference_t<S &&>, S), "");
- static_assert(__is_same(remove_reference_t<const S>, const S), "");
- static_assert(__is_same(remove_reference_t<const S &>, const S), "");
- static_assert(__is_same(remove_reference_t<const S &&>, const S), "");
- static_assert(__is_same(remove_reference_t<volatile S>, volatile S), "");
- static_assert(__is_same(remove_reference_t<volatile S &>, volatile S), "");
- static_assert(__is_same(remove_reference_t<volatile S &&>, volatile S), "");
- static_assert(__is_same(remove_reference_t<const volatile S>, const volatile S), "");
- static_assert(__is_same(remove_reference_t<const volatile S &>, const volatile S), "");
- static_assert(__is_same(remove_reference_t<const volatile S &&>, const volatile S), "");
- static_assert(__is_same(remove_reference_t<int S::*const volatile &>, int S::*const volatile), "");
- static_assert(__is_same(remove_reference_t<int (S::*const volatile &)()>, int(S::*const volatile)()), "");
- static_assert(__is_same(remove_reference_t<int (S::*const volatile &&)() &>, int(S::*const volatile)() &), "");
+ static_assert(__is_same(remove_reference_t<void>, void));
+ static_assert(__is_same(remove_reference_t<const volatile void>, const volatile void));
+ static_assert(__is_same(remove_reference_t<int>, int));
+ static_assert(__is_same(remove_reference_t<const int>, const int));
+ static_assert(__is_same(remove_reference_t<volatile int>, volatile int));
+ static_assert(__is_same(remove_reference_t<const volatile int>, const volatile int));
+ static_assert(__is_same(remove_reference_t<int *>, int *));
+ static_assert(__is_same(remove_reference_t<int *const volatile>, int *const volatile));
+ static_assert(__is_same(remove_reference_t<int const *const volatile>, int const *const volatile));
+ static_assert(__is_same(remove_reference_t<int &>, int));
+ static_assert(__is_same(remove_reference_t<int const volatile &>, int const volatile));
+ static_assert(__is_same(remove_reference_t<int &&>, int));
+ static_assert(__is_same(remove_reference_t<int const volatile &&>, int const volatile));
+ static_assert(__is_same(remove_reference_t<int()>, int()));
+ static_assert(__is_same(remove_reference_t<int (*const volatile)()>, int (*const volatile)()));
+ static_assert(__is_same(remove_reference_t<int (&)()>, int()));
+
+ static_assert(__is_same(remove_reference_t<S>, S));
+ static_assert(__is_same(remove_reference_t<S &>, S));
+ static_assert(__is_same(remove_reference_t<S &&>, S));
+ static_assert(__is_same(remove_reference_t<const S>, const S));
+ static_assert(__is_same(remove_reference_t<const S &>, const S));
+ static_assert(__is_same(remove_reference_t<const S &&>, const S));
+ static_assert(__is_same(remove_reference_t<volatile S>, volatile S));
+ static_assert(__is_same(remove_reference_t<volatile S &>, volatile S));
+ static_assert(__is_same(remove_reference_t<volatile S &&>, volatile S));
+ static_assert(__is_same(remove_reference_t<const volatile S>, const volatile S));
+ static_assert(__is_same(remove_reference_t<const volatile S &>, const volatile S));
+ static_assert(__is_same(remove_reference_t<const volatile S &&>, const volatile S));
+ static_assert(__is_same(remove_reference_t<int S::*const volatile &>, int S::*const volatile));
+ static_assert(__is_same(remove_reference_t<int (S::*const volatile &)()>, int(S::*const volatile)()));
+ static_assert(__is_same(remove_reference_t<int (S::*const volatile &&)() &>, int(S::*const volatile)() &));
}
template <class T> using remove_cvref_t = __remove_cvref(T);
void check_remove_cvref() {
- static_assert(__is_same(remove_cvref_t<void>, void), "");
- static_assert(__is_same(remove_cvref_t<const volatile void>, void), "");
- static_assert(__is_same(remove_cvref_t<int>, int), "");
- static_assert(__is_same(remove_cvref_t<const int>, int), "");
- static_assert(__is_same(remove_cvref_t<volatile int>, int), "");
- static_assert(__is_same(remove_cvref_t<const volatile int>, int), "");
- static_assert(__is_same(remove_cvref_t<int *>, int *), "");
- static_assert(__is_same(remove_cvref_t<int *const volatile>, int *), "");
- static_assert(__is_same(remove_cvref_t<int const *const volatile>, int const *), "");
- static_assert(__is_same(remove_cvref_t<int const *const volatile __restrict>, int const *__restrict), "");
- static_assert(__is_same(remove_cvref_t<int const *const volatile _Nonnull>, int const *_Nonnull), "");
- static_assert(__is_same(remove_cvref_t<int &>, int), "");
- static_assert(__is_same(remove_cvref_t<int const volatile &>, int), "");
- static_assert(__is_same(remove_cvref_t<int &&>, int), "");
- static_assert(__is_same(remove_cvref_t<int const volatile &&>, int), "");
- static_assert(__is_same(remove_cvref_t<int()>, int()), "");
- static_assert(__is_same(remove_cvref_t<int (*const volatile)()>, int (*)()), "");
- static_assert(__is_same(remove_cvref_t<int (&)()>, int()), "");
-
- static_assert(__is_same(remove_cvref_t<S>, S), "");
- static_assert(__is_same(remove_cvref_t<S &>, S), "");
- static_assert(__is_same(remove_cvref_t<S &&>, S), "");
- static_assert(__is_same(remove_cvref_t<const S>, S), "");
- static_assert(__is_same(remove_cvref_t<const S &>, S), "");
- static_assert(__is_same(remove_cvref_t<const S &&>, S), "");
- static_assert(__is_same(remove_cvref_t<volatile S>, S), "");
- static_assert(__is_same(remove_cvref_t<volatile S &>, S), "");
- static_assert(__is_same(remove_cvref_t<volatile S &&>, S), "");
- static_assert(__is_same(remove_cvref_t<const volatile S>, S), "");
- static_assert(__is_same(remove_cvref_t<const volatile S &>, S), "");
- static_assert(__is_same(remove_cvref_t<const volatile S &&>, S), "");
- static_assert(__is_same(remove_cvref_t<int S::*const volatile>, int S::*), "");
- static_assert(__is_same(remove_cvref_t<int (S::*const volatile)()>, int(S::*)()), "");
- static_assert(__is_same(remove_cvref_t<int (S::*const volatile)() &>, int(S::*)() &), "");
- static_assert(__is_same(remove_cvref_t<int (S::*const volatile)() &&>, int(S::*)() &&), "");
+ static_assert(__is_same(remove_cvref_t<void>, void));
+ static_assert(__is_same(remove_cvref_t<const volatile void>, void));
+ static_assert(__is_same(remove_cvref_t<int>, int));
+ static_assert(__is_same(remove_cvref_t<const int>, int));
+ static_assert(__is_same(remove_cvref_t<volatile int>, int));
+ static_assert(__is_same(remove_cvref_t<const volatile int>, int));
+ static_assert(__is_same(remove_cvref_t<int *>, int *));
+ static_assert(__is_same(remove_cvref_t<int *const volatile>, int *));
+ static_assert(__is_same(remove_cvref_t<int const *const volatile>, int const *));
+ static_assert(__is_same(remove_cvref_t<int const *const volatile __restrict>, int const *__restrict));
+ static_assert(__is_same(remove_cvref_t<int const *const volatile _Nonnull>, int const *_Nonnull));
+ static_assert(__is_same(remove_cvref_t<int &>, int));
+ static_assert(__is_same(remove_cvref_t<int const volatile &>, int));
+ static_assert(__is_same(remove_cvref_t<int &&>, int));
+ static_assert(__is_same(remove_cvref_t<int const volatile &&>, int));
+ static_assert(__is_same(remove_cvref_t<int()>, int()));
+ static_assert(__is_same(remove_cvref_t<int (*const volatile)()>, int (*)()));
+ static_assert(__is_same(remove_cvref_t<int (&)()>, int()));
+
+ static_assert(__is_same(remove_cvref_t<S>, S));
+ static_assert(__is_same(remove_cvref_t<S &>, S));
+ static_assert(__is_same(remove_cvref_t<S &&>, S));
+ static_assert(__is_same(remove_cvref_t<const S>, S));
+ static_assert(__is_same(remove_cvref_t<const S &>, S));
+ static_assert(__is_same(remove_cvref_t<const S &&>, S));
+ static_assert(__is_same(remove_cvref_t<volatile S>, S));
+ static_assert(__is_same(remove_cvref_t<volatile S &>, S));
+ static_assert(__is_same(remove_cvref_t<volatile S &&>, S));
+ static_assert(__is_same(remove_cvref_t<const volatile S>, S));
+ static_assert(__is_same(remove_cvref_t<const volatile S &>, S));
+ static_assert(__is_same(remove_cvref_t<const volatile S &&>, S));
+ static_assert(__is_same(remove_cvref_t<int S::*const volatile>, int S::*));
+ static_assert(__is_same(remove_cvref_t<int (S::*const volatile)()>, int(S::*)()));
+ static_assert(__is_same(remove_cvref_t<int (S::*const volatile)() &>, int(S::*)() &));
+ static_assert(__is_same(remove_cvref_t<int (S::*const volatile)() &&>, int(S::*)() &&));
}
template <class T> using decay_t = __decay(T);
void check_decay() {
- static_assert(__is_same(decay_t<void>, void), "");
- static_assert(__is_same(decay_t<const volatile void>, void), "");
- static_assert(__is_same(decay_t<int>, int), "");
- static_assert(__is_same(decay_t<const int>, int), "");
- static_assert(__is_same(decay_t<volatile int>, int), "");
- static_assert(__is_same(decay_t<const volatile int>, int), "");
- static_assert(__is_same(decay_t<int *>, int *), "");
- static_assert(__is_same(decay_t<int *const volatile>, int *), "");
- static_assert(__is_same(decay_t<int *const volatile __restrict>, int *), "");
- static_assert(__is_same(decay_t<int const *const volatile>, int const *), "");
- static_assert(__is_same(decay_t<int const *const volatile _Nonnull>, int const *), "");
- static_assert(__is_same(decay_t<int &>, int), "");
- static_assert(__is_same(decay_t<int const volatile &>, int), "");
- static_assert(__is_same(decay_t<int &&>, int), "");
- static_assert(__is_same(decay_t<int const volatile &&>, int), "");
- static_assert(__is_same(decay_t<int()>, int (*)()), "");
- static_assert(__is_same(decay_t<int (*)()>, int (*)()), "");
- static_assert(__is_same(decay_t<int (*const)()>, int (*)()), "");
- static_assert(__is_same(decay_t<int (*volatile)()>, int (*)()), "");
- static_assert(__is_same(decay_t<int (*const volatile)()>, int (*)()), "");
- static_assert(__is_same(decay_t<int (&)()>, int (*)()), "");
- static_assert(__is_same(decay_t<IntAr>, int *), "");
- static_assert(__is_same(decay_t<IntArNB>, int *), "");
-
- static_assert(__is_same(decay_t<S>, S), "");
- static_assert(__is_same(decay_t<S &>, S), "");
- static_assert(__is_same(decay_t<S &&>, S), "");
- static_assert(__is_same(decay_t<const S>, S), "");
- static_assert(__is_same(decay_t<const S &>, S), "");
- static_assert(__is_same(decay_t<const S &&>, S), "");
- static_assert(__is_same(decay_t<volatile S>, S), "");
- static_assert(__is_same(decay_t<volatile S &>, S), "");
- static_assert(__is_same(decay_t<volatile S &&>, S), "");
- static_assert(__is_same(decay_t<const volatile S>, S), "");
- static_assert(__is_same(decay_t<const volatile S &>, S), "");
- static_assert(__is_same(decay_t<const volatile S &&>, S), "");
- static_assert(__is_same(decay_t<int S::*const volatile>, int S::*), "");
- static_assert(__is_same(decay_t<int (S::*const volatile)()>, int(S::*)()), "");
- static_assert(__is_same(decay_t<int S::*const volatile &>, int S::*), "");
- static_assert(__is_same(decay_t<int (S::*const volatile &)()>, int(S::*)()), "");
- static_assert(__is_same(decay_t<int S::*const volatile &&>, int S::*), "");
+ static_assert(__is_same(decay_t<void>, void));
+ static_assert(__is_same(decay_t<const volatile void>, void));
+ static_assert(__is_same(decay_t<int>, int));
+ static_assert(__is_same(decay_t<const int>, int));
+ static_assert(__is_same(decay_t<volatile int>, int));
+ static_assert(__is_same(decay_t<const volatile int>, int));
+ static_assert(__is_same(decay_t<int *>, int *));
+ static_assert(__is_same(decay_t<int *const volatile>, int *));
+ static_assert(__is_same(decay_t<int *const volatile __restrict>, int *));
+ static_assert(__is_same(decay_t<int const *const volatile>, int const *));
+ static_assert(__is_same(decay_t<int const *const volatile _Nonnull>, int const *));
+ static_assert(__is_same(decay_t<int &>, int));
+ static_assert(__is_same(decay_t<int const volatile &>, int));
+ static_assert(__is_same(decay_t<int &&>, int));
+ static_assert(__is_same(decay_t<int const volatile &&>, int));
+ static_assert(__is_same(decay_t<int()>, int (*)()));
+ static_assert(__is_same(decay_t<int (*)()>, int (*)()));
+ static_assert(__is_same(decay_t<int (*const)()>, int (*)()));
+ static_assert(__is_same(decay_t<int (*volatile)()>, int (*)()));
+ static_assert(__is_same(decay_t<int (*const volatile)()>, int (*)()));
+ static_assert(__is_same(decay_t<int (&)()>, int (*)()));
+ static_assert(__is_same(decay_t<IntAr>, int *));
+ static_assert(__is_same(decay_t<IntArNB>, int *));
+
+ static_assert(__is_same(decay_t<S>, S));
+ static_assert(__is_same(decay_t<S &>, S));
+ static_assert(__is_same(decay_t<S &&>, S));
+ static_assert(__is_same(decay_t<const S>, S));
+ static_assert(__is_same(decay_t<const S &>, S));
+ static_assert(__is_same(decay_t<const S &&>, S));
+ static_assert(__is_same(decay_t<volatile S>, S));
+ static_assert(__is_same(decay_t<volatile S &>, S));
+ static_assert(__is_same(decay_t<volatile S &&>, S));
+ static_assert(__is_same(decay_t<const volatile S>, S));
+ static_assert(__is_same(decay_t<const volatile S &>, S));
+ static_assert(__is_same(decay_t<const volatile S &&>, S));
+ static_assert(__is_same(decay_t<int S::*const volatile>, int S::*));
+ static_assert(__is_same(decay_t<int (S::*const volatile)()>, int(S::*)()));
+ static_assert(__is_same(decay_t<int S::*const volatile &>, int S::*));
+ static_assert(__is_same(decay_t<int (S::*const volatile &)()>, int(S::*)()));
+ static_assert(__is_same(decay_t<int S::*const volatile &&>, int S::*));
}
template <class T> struct CheckAbominableFunction {};
template <class M>
struct CheckAbominableFunction<M S::*> {
static void checks() {
- static_assert(__is_same(add_lvalue_reference_t<M>, M), "");
- static_assert(__is_same(add_pointer_t<M>, M), "");
- static_assert(__is_same(add_rvalue_reference_t<M>, M), "");
- static_assert(__is_same(decay_t<M>, M), "");
- static_assert(__is_same(remove_const_t<M>, M), "");
- static_assert(__is_same(remove_volatile_t<M>, M), "");
- static_assert(__is_same(remove_cv_t<M>, M), "");
- static_assert(__is_same(remove_cvref_t<M>, M), "");
- static_assert(__is_same(remove_pointer_t<M>, M), "");
- static_assert(__is_same(remove_reference_t<M>, M), "");
-
- static_assert(!__is_referenceable(M), "");
+ static_assert(__is_same(add_lvalue_reference_t<M>, M));
+ static_assert(__is_same(add_pointer_t<M>, M));
+ static_assert(__is_same(add_rvalue_reference_t<M>, M));
+ static_assert(__is_same(decay_t<M>, M));
+ static_assert(__is_same(remove_const_t<M>, M));
+ static_assert(__is_same(remove_volatile_t<M>, M));
+ static_assert(__is_same(remove_cv_t<M>, M));
+ static_assert(__is_same(remove_cvref_t<M>, M));
+ static_assert(__is_same(remove_pointer_t<M>, M));
+ static_assert(__is_same(remove_reference_t<M>, M));
+
+ static_assert(!__is_referenceable(M));
}
};
@@ -3961,10 +3961,10 @@ void check_abominable_function() {
template <class T> using make_signed_t = __make_signed(T);
template <class T, class Expected>
void check_make_signed() {
- static_assert(__is_same(make_signed_t<T>, Expected), "");
- static_assert(__is_same(make_signed_t<const T>, const Expected), "");
- static_assert(__is_same(make_signed_t<volatile T>, volatile Expected), "");
- static_assert(__is_same(make_signed_t<const volatile T>, const volatile Expected), "");
+ static_assert(__is_same(make_signed_t<T>, Expected));
+ static_assert(__is_same(make_signed_t<const T>, const Expected));
+ static_assert(__is_same(make_signed_t<volatile T>, volatile Expected));
+ static_assert(__is_same(make_signed_t<const volatile T>, const volatile Expected));
}
#if defined(__ILP32__) || defined(__LLP64__)
@@ -4074,10 +4074,10 @@ using make_unsigned_t = __make_unsigned(T);
template <class T, class Expected>
void check_make_unsigned() {
- static_assert(__is_same(make_unsigned_t<T>, Expected), "");
- static_assert(__is_same(make_unsigned_t<const T>, const Expected), "");
- static_assert(__is_same(make_unsigned_t<volatile T>, volatile Expected), "");
- static_assert(__is_same(make_unsigned_t<const volatile T>, const volatile Expected), "");
+ static_assert(__is_same(make_unsigned_t<T>, Expected));
+ static_assert(__is_same(make_unsigned_t<const T>, const Expected));
+ static_assert(__is_same(make_unsigned_t<volatile T>, volatile Expected));
+ static_assert(__is_same(make_unsigned_t<const volatile T>, const volatile Expected));
}
void make_unsigned() {
@@ -4160,74 +4160,74 @@ void make_unsigned() {
template <class T> using remove_extent_t = __remove_extent(T);
void remove_extent() {
- static_assert(__is_same(remove_extent_t<void>, void), "");
- static_assert(__is_same(remove_extent_t<int>, int), "");
- static_assert(__is_same(remove_extent_t<int[]>, int), "");
- static_assert(__is_same(remove_extent_t<int[1]>, int), "");
- static_assert(__is_same(remove_extent_t<int[1][2]>, int[2]), "");
- static_assert(__is_same(remove_extent_t<int[][2]>, int[2]), "");
- static_assert(__is_same(remove_extent_t<const int[]>, const int), "");
- static_assert(__is_same(remove_extent_t<const int[1]>, const int), "");
- static_assert(__is_same(remove_extent_t<const int[1][2]>, const int[2]), "");
- static_assert(__is_same(remove_extent_t<const int[][2]>, const int[2]), "");
- static_assert(__is_same(remove_extent_t<volatile int[]>, volatile int), "");
- static_assert(__is_same(remove_extent_t<volatile int[1]>, volatile int), "");
- static_assert(__is_same(remove_extent_t<volatile int[1][2]>, volatile int[2]), "");
- static_assert(__is_same(remove_extent_t<volatile int[][2]>, volatile int[2]), "");
- static_assert(__is_same(remove_extent_t<const volatile int[]>, const volatile int), "");
- static_assert(__is_same(remove_extent_t<const volatile int[1]>, const volatile int), "");
- static_assert(__is_same(remove_extent_t<const volatile int[1][2]>, const volatile int[2]), "");
- static_assert(__is_same(remove_extent_t<const volatile int[][2]>, const volatile int[2]), "");
- static_assert(__is_same(remove_extent_t<int *>, int *), "");
- static_assert(__is_same(remove_extent_t<int &>, int &), "");
- static_assert(__is_same(remove_extent_t<int &&>, int &&), "");
- static_assert(__is_same(remove_extent_t<int()>, int()), "");
- static_assert(__is_same(remove_extent_t<int (*)()>, int (*)()), "");
- static_assert(__is_same(remove_extent_t<int (&)()>, int (&)()), "");
-
- static_assert(__is_same(remove_extent_t<S>, S), "");
- static_assert(__is_same(remove_extent_t<int S::*>, int S::*), "");
- static_assert(__is_same(remove_extent_t<int (S::*)()>, int(S::*)()), "");
+ static_assert(__is_same(remove_extent_t<void>, void));
+ static_assert(__is_same(remove_extent_t<int>, int));
+ static_assert(__is_same(remove_extent_t<int[]>, int));
+ static_assert(__is_same(remove_extent_t<int[1]>, int));
+ static_assert(__is_same(remove_extent_t<int[1][2]>, int[2]));
+ static_assert(__is_same(remove_extent_t<int[][2]>, int[2]));
+ static_assert(__is_same(remove_extent_t<const int[]>, const int));
+ static_assert(__is_same(remove_extent_t<const int[1]>, const int));
+ static_assert(__is_same(remove_extent_t<const int[1][2]>, const int[2]));
+ static_assert(__is_same(remove_extent_t<const int[][2]>, const int[2]));
+ static_assert(__is_same(remove_extent_t<volatile int[]>, volatile int));
+ static_assert(__is_same(remove_extent_t<volatile int[1]>, volatile int));
+ static_assert(__is_same(remove_extent_t<volatile int[1][2]>, volatile int[2]));
+ static_assert(__is_same(remove_extent_t<volatile int[][2]>, volatile int[2]));
+ static_assert(__is_same(remove_extent_t<const volatile int[]>, const volatile int));
+ static_assert(__is_same(remove_extent_t<const volatile int[1]>, const volatile int));
+ static_assert(__is_same(remove_extent_t<const volatile int[1][2]>, const volatile int[2]));
+ static_assert(__is_same(remove_extent_t<const volatile int[][2]>, const volatile int[2]));
+ static_assert(__is_same(remove_extent_t<int *>, int *));
+ static_assert(__is_same(remove_extent_t<int &>, int &));
+ static_assert(__is_same(remove_extent_t<int &&>, int &&));
+ static_assert(__is_same(remove_extent_t<int()>, int()));
+ static_assert(__is_same(remove_extent_t<int (*)()>, int (*)()));
+ static_assert(__is_same(remove_extent_t<int (&)()>, int (&)()));
+
+ static_assert(__is_same(remove_extent_t<S>, S));
+ static_assert(__is_same(remove_extent_t<int S::*>, int S::*));
+ static_assert(__is_same(remove_extent_t<int (S::*)()>, int(S::*)()));
using SomeArray = int[1][2];
- static_assert(__is_same(remove_extent_t<const SomeArray>, const int[2]), "");
+ static_assert(__is_same(remove_extent_t<const SomeArray>, const int[2]));
}
template <class T> using remove_all_extents_t = __remove_all_extents(T);
void remove_all_extents() {
- static_assert(__is_same(remove_all_extents_t<void>, void), "");
- static_assert(__is_same(remove_all_extents_t<int>, int), "");
- static_assert(__is_same(remove_all_extents_t<const int>, const int), "");
- static_assert(__is_same(remove_all_extents_t<volatile int>, volatile int), "");
- static_assert(__is_same(remove_all_extents_t<const volatile int>, const volatile int), "");
- static_assert(__is_same(remove_all_extents_t<int[]>, int), "");
- static_assert(__is_same(remove_all_extents_t<int[1]>, int), "");
- static_assert(__is_same(remove_all_extents_t<int[1][2]>, int), "");
- static_assert(__is_same(remove_all_extents_t<int[][2]>, int), "");
- static_assert(__is_same(remove_all_extents_t<const int[]>, const int), "");
- static_assert(__is_same(remove_all_extents_t<const int[1]>, const int), "");
- static_assert(__is_same(remove_all_extents_t<const int[1][2]>, const int), "");
- static_assert(__is_same(remove_all_extents_t<const int[][2]>, const int), "");
- static_assert(__is_same(remove_all_extents_t<volatile int[]>, volatile int), "");
- static_assert(__is_same(remove_all_extents_t<volatile int[1]>, volatile int), "");
- static_assert(__is_same(remove_all_extents_t<volatile int[1][2]>, volatile int), "");
- static_assert(__is_same(remove_all_extents_t<volatile int[][2]>, volatile int), "");
- static_assert(__is_same(remove_all_extents_t<const volatile int[]>, const volatile int), "");
- static_assert(__is_same(remove_all_extents_t<const volatile int[1]>, const volatile int), "");
- static_assert(__is_same(remove_all_extents_t<const volatile int[1][2]>, const volatile int), "");
- static_assert(__is_same(remove_all_extents_t<const volatile int[][2]>, const volatile int), "");
- static_assert(__is_same(remove_all_extents_t<int *>, int *), "");
- static_assert(__is_same(remove_all_extents_t<int &>, int &), "");
- static_assert(__is_same(remove_all_extents_t<int &&>, int &&), "");
- static_assert(__is_same(remove_all_extents_t<int()>, int()), "");
- static_assert(__is_same(remove_all_extents_t<int (*)()>, int (*)()), "");
- static_assert(__is_same(remove_all_extents_t<int (&)()>, int (&)()), "");
-
- static_assert(__is_same(remove_all_extents_t<S>, S), "");
- static_assert(__is_same(remove_all_extents_t<int S::*>, int S::*), "");
- static_assert(__is_same(remove_all_extents_t<int (S::*)()>, int(S::*)()), "");
+ static_assert(__is_same(remove_all_extents_t<void>, void));
+ static_assert(__is_same(remove_all_extents_t<int>, int));
+ static_assert(__is_same(remove_all_extents_t<const int>, const int));
+ static_assert(__is_same(remove_all_extents_t<volatile int>, volatile int));
+ static_assert(__is_same(remove_all_extents_t<const volatile int>, const volatile int));
+ static_assert(__is_same(remove_all_extents_t<int[]>, int));
+ static_assert(__is_same(remove_all_extents_t<int[1]>, int));
+ static_assert(__is_same(remove_all_extents_t<int[1][2]>, int));
+ static_assert(__is_same(remove_all_extents_t<int[][2]>, int));
+ static_assert(__is_same(remove_all_extents_t<const int[]>, const int));
+ static_assert(__is_same(remove_all_extents_t<const int[1]>, const int));
+ static_assert(__is_same(remove_all_extents_t<const int[1][2]>, const int));
+ static_assert(__is_same(remove_all_extents_t<const int[][2]>, const int));
+ static_assert(__is_same(remove_all_extents_t<volatile int[]>, volatile int));
+ static_assert(__is_same(remove_all_extents_t<volatile int[1]>, volatile int));
+ static_assert(__is_same(remove_all_extents_t<volatile int[1][2]>, volatile int));
+ static_assert(__is_same(remove_all_extents_t<volatile int[][2]>, volatile int));
+ static_assert(__is_same(remove_all_extents_t<const volatile int[]>, const volatile int));
+ static_assert(__is_same(remove_all_extents_t<const volatile int[1]>, const volatile int));
+ static_assert(__is_same(remove_all_extents_t<const volatile int[1][2]>, const volatile int));
+ static_assert(__is_same(remove_all_extents_t<const volatile int[][2]>, const volatile int));
+ static_assert(__is_same(remove_all_extents_t<int *>, int *));
+ static_assert(__is_same(remove_all_extents_t<int &>, int &));
+ static_assert(__is_same(remove_all_extents_t<int &&>, int &&));
+ static_assert(__is_same(remove_all_extents_t<int()>, int()));
+ static_assert(__is_same(remove_all_extents_t<int (*)()>, int (*)()));
+ static_assert(__is_same(remove_all_extents_t<int (&)()>, int (&)()));
+
+ static_assert(__is_same(remove_all_extents_t<S>, S));
+ static_assert(__is_same(remove_all_extents_t<int S::*>, int S::*));
+ static_assert(__is_same(remove_all_extents_t<int (S::*)()>, int(S::*)()));
using SomeArray = int[1][2];
- static_assert(__is_same(remove_all_extents_t<const SomeArray>, const int), "");
+ static_assert(__is_same(remove_all_extents_t<const SomeArray>, const int));
}
>From 2018c5ad1837ddc86d06ebe751d884d09ecc33f4 Mon Sep 17 00:00:00 2001
From: Amirreza Ashouri <ar.ashouri999 at gmail.com>
Date: Tue, 5 Mar 2024 12:28:53 +0330
Subject: [PATCH 5/6] [Clang] Replace `has_unique_object_representations` with
the builtin for abominable types
With the #81298 being approved, as soon as it gets merged into the `main` branch,
we can completely remove the `has_unique_object_representations` struct and use the builtin instead.
---
clang/test/SemaCXX/type-traits.cpp | 50 +++++++++++++-----------------
1 file changed, 22 insertions(+), 28 deletions(-)
diff --git a/clang/test/SemaCXX/type-traits.cpp b/clang/test/SemaCXX/type-traits.cpp
index b6b06f3115def8..3170309cac4afc 100644
--- a/clang/test/SemaCXX/type-traits.cpp
+++ b/clang/test/SemaCXX/type-traits.cpp
@@ -2654,12 +2654,6 @@ void is_trivially_destructible_test() {
static_assert(!__is_trivially_destructible(const volatile void));
}
-// Instantiation of __has_unique_object_representations
-template <typename T>
-struct has_unique_object_representations {
- static const bool value = __has_unique_object_representations(T);
-};
-
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");
@@ -2879,30 +2873,30 @@ static_assert(__has_unique_object_representations(PackedNoPadding1), "Packed str
static_assert(__has_unique_object_representations(PackedNoPadding2), "Packed structs have no padding");
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");
-static_assert(!has_unique_object_representations<int(int) &>::value, "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");
-static_assert(!has_unique_object_representations<int(int) &&>::value, "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");
+static_assert(!__has_unique_object_representations(int(int) const), "Functions are not unique");
+static_assert(!__has_unique_object_representations(int(int) volatile), "Functions are not unique");
+static_assert(!__has_unique_object_representations(int(int) const volatile), "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 &), "Functions are not unique");
+static_assert(!__has_unique_object_representations(int(int) volatile &), "Functions are not unique");
+static_assert(!__has_unique_object_representations(int(int) const volatile &), "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 &&), "Functions are not unique");
+static_assert(!__has_unique_object_representations(int(int) volatile &&), "Functions are not unique");
+static_assert(!__has_unique_object_representations(int(int) const volatile &&), "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");
-static_assert(!has_unique_object_representations<int(int, ...) &>::value, "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");
-static_assert(!has_unique_object_representations<int(int, ...) &&>::value, "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");
+static_assert(!__has_unique_object_representations(int(int, ...) const), "Functions are not unique");
+static_assert(!__has_unique_object_representations(int(int, ...) volatile), "Functions are not unique");
+static_assert(!__has_unique_object_representations(int(int, ...) const volatile), "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 &), "Functions are not unique");
+static_assert(!__has_unique_object_representations(int(int, ...) volatile &), "Functions are not unique");
+static_assert(!__has_unique_object_representations(int(int, ...) const volatile &), "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 &&), "Functions are not unique");
+static_assert(!__has_unique_object_representations(int(int, ...) volatile &&), "Functions are not unique");
+static_assert(!__has_unique_object_representations(int(int, ...) const volatile &&), "Functions are not unique");
void foo(){
static auto lambda = []() {};
>From f03624165823e23c5abddf507858564f4b6683d6 Mon Sep 17 00:00:00 2001
From: Amirreza Ashouri <ar.ashouri999 at gmail.com>
Date: Thu, 7 Mar 2024 23:21:08 +0330
Subject: [PATCH 6/6] Eliminate remaining T/F structs
---
clang/test/SemaCXX/type-traits.cpp | 16 ++++++++--------
1 file changed, 8 insertions(+), 8 deletions(-)
diff --git a/clang/test/SemaCXX/type-traits.cpp b/clang/test/SemaCXX/type-traits.cpp
index 03eef478f9502a..dc636aa24965ad 100644
--- a/clang/test/SemaCXX/type-traits.cpp
+++ b/clang/test/SemaCXX/type-traits.cpp
@@ -2382,14 +2382,14 @@ void is_convertible()
void is_nothrow_convertible()
{
- int t01[T(__is_nothrow_convertible(IntWrapper, IntWrapper))];
- int t02[T(__is_nothrow_convertible(IntWrapper, const IntWrapper))];
- int t03[T(__is_nothrow_convertible(IntWrapper, int))];
- int t04[F(__is_nothrow_convertible(int, IntWrapper))];
- int t05[F(__is_nothrow_convertible(IntWrapper, FloatWrapper))];
- int t06[F(__is_nothrow_convertible(FloatWrapper, IntWrapper))];
- int t07[F(__is_nothrow_convertible(FloatWrapper, float))];
- int t08[T(__is_nothrow_convertible(float, FloatWrapper))];
+ static_assert(__is_nothrow_convertible(IntWrapper, IntWrapper));
+ static_assert(__is_nothrow_convertible(IntWrapper, const IntWrapper));
+ static_assert(__is_nothrow_convertible(IntWrapper, int));
+ static_assert(!__is_nothrow_convertible(int, IntWrapper));
+ static_assert(!__is_nothrow_convertible(IntWrapper, FloatWrapper));
+ static_assert(!__is_nothrow_convertible(FloatWrapper, IntWrapper));
+ static_assert(!__is_nothrow_convertible(FloatWrapper, float));
+ static_assert(__is_nothrow_convertible(float, FloatWrapper));
}
struct FromInt { FromInt(int); };
More information about the cfe-commits
mailing list