[clang] aefff77 - [clang] Migrate DR tests to `static_assert` (#88611)
via cfe-commits
cfe-commits at lists.llvm.org
Tue Apr 16 10:50:25 PDT 2024
Author: Vlad Serebrennikov
Date: 2024-04-16T21:50:22+04:00
New Revision: aefff774a0d6f75565243263555f2513ac3c9fdf
URL: https://github.com/llvm/llvm-project/commit/aefff774a0d6f75565243263555f2513ac3c9fdf
DIFF: https://github.com/llvm/llvm-project/commit/aefff774a0d6f75565243263555f2513ac3c9fdf.diff
LOG: [clang] Migrate DR tests to `static_assert` (#88611)
This patch touches a number of tests that run in C++98 mode that have
been using array size as a context that requires a constant expression,
replacing it with a `static_assert` backported via a macro. This reduces
noise in expected directives that comes from diagnostics around VLAs.
This patch also showcases that DR tests would benefit from folding in
constant expressions in C++98 mode, but I'm not sure it's even on the
table. If it is, I'd be happy to prepare a PR for that, and rebase this
PR on top of it.
CC @AaronBallman
Added:
Modified:
clang/test/CXX/drs/dr0xx.cpp
clang/test/CXX/drs/dr16xx.cpp
clang/test/CXX/drs/dr1xx.cpp
clang/test/CXX/drs/dr2xx.cpp
clang/test/CXX/drs/dr3xx.cpp
clang/test/CXX/drs/dr4xx.cpp
clang/test/CXX/drs/dr5xx.cpp
clang/test/CXX/drs/dr6xx.cpp
Removed:
################################################################################
diff --git a/clang/test/CXX/drs/dr0xx.cpp b/clang/test/CXX/drs/dr0xx.cpp
index a304862885c640..6c600bbc7c3f6e 100644
--- a/clang/test/CXX/drs/dr0xx.cpp
+++ b/clang/test/CXX/drs/dr0xx.cpp
@@ -5,6 +5,11 @@
// RUN: %clang_cc1 -std=c++20 %s -verify=expected,since-cxx11,since-cxx17 -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
// RUN: %clang_cc1 -std=c++23 %s -verify=expected,since-cxx11,since-cxx17 -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
+#if __cplusplus == 199711L
+#define static_assert(...) __extension__ _Static_assert(__VA_ARGS__)
+// cxx98-error at -1 {{variadic macros are a C99 feature}}
+#endif
+
namespace cwg1 { // cwg1: no
namespace X { extern "C" void cwg1_f(int a = 1); }
namespace Y { extern "C" void cwg1_f(int a = 1); }
@@ -897,7 +902,7 @@ namespace cwg54 { // cwg54: 2.8
namespace cwg55 { // cwg55: yes
enum E { e = 5 };
- int test[(e + 1 == 6) ? 1 : -1];
+ static_assert(e + 1 == 6, "");
}
namespace cwg56 { // cwg56: yes
@@ -1163,10 +1168,9 @@ namespace cwg75 { // cwg75: yes
namespace cwg76 { // cwg76: yes
const volatile int n = 1;
- int arr[n]; // #cwg76-vla
- // expected-error@#cwg76-vla {{variable length arrays in C++ are a Clang extension}}
- // expected-note@#cwg76-vla {{read of volatile-qualified type 'const volatile int' is not allowed in a constant expression}}
- // expected-error@#cwg76-vla {{variable length array declaration not allowed at file scope}}
+ static_assert(n, "");
+ // expected-error at -1 {{static assertion expression is not an integral constant expression}}
+ // expected-note at -2 {{read of volatile-qualified type 'const volatile int' is not allowed in a constant expression}}
}
namespace cwg77 { // cwg77: yes
diff --git a/clang/test/CXX/drs/dr16xx.cpp b/clang/test/CXX/drs/dr16xx.cpp
index 6d7bb7619f8b8b..cf6b45ceabf2cc 100644
--- a/clang/test/CXX/drs/dr16xx.cpp
+++ b/clang/test/CXX/drs/dr16xx.cpp
@@ -153,10 +153,9 @@ namespace cwg1645 { // cwg1645: 3.9
namespace cwg1652 { // cwg1652: 3.6
int a, b;
- int arr[&a + 1 == &b ? 1 : 2];
- // expected-error at -1 {{variable length arrays in C++ are a Clang extension}}
+ static_assert(&a + 1 == &b, "");
+ // expected-error at -1 {{static assertion expression is not an integral constant expression}}
// expected-note at -2 {{comparison against pointer '&a + 1' that points past the end of a complete object has unspecified value}}
- // expected-error at -3 {{variable length array declaration not allowed at file scope}}
}
namespace cwg1653 { // cwg1653: 4 c++17
diff --git a/clang/test/CXX/drs/dr1xx.cpp b/clang/test/CXX/drs/dr1xx.cpp
index 5b497dda047d6a..a8f9b705a98660 100644
--- a/clang/test/CXX/drs/dr1xx.cpp
+++ b/clang/test/CXX/drs/dr1xx.cpp
@@ -5,6 +5,17 @@
// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx11,since-cxx17 -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++23 -triple x86_64-unknown-unknown %s -verify=expected,since-cxx11,since-cxx17 -fexceptions -fcxx-exceptions -pedantic-errors
+#if __cplusplus == 199711L
+#define static_assert(...) __extension__ _Static_assert(__VA_ARGS__)
+// cxx98-error at -1 {{variadic macros are a C99 feature}}
+#endif
+
+#if __cplusplus == 199711L
+#define __enable_constant_folding(x) (__builtin_constant_p(x) ? (x) : (x))
+#else
+#define __enable_constant_folding
+#endif
+
namespace cwg100 { // cwg100: yes
template<const char (*)[4]> struct A {}; // #cwg100-A
template<const char (&)[4]> struct B {}; // #cwg100-B
@@ -736,8 +747,8 @@ namespace cwg147 { // cwg147: yes
namespace cwg148 { // cwg148: yes
struct A { int A::*p; };
- int check1[__is_pod(int(A::*)) ? 1 : -1];
- int check2[__is_pod(A) ? 1 : -1];
+ static_assert(__is_pod(int(A::*)), "");
+ static_assert(__is_pod(A), "");
}
// cwg149: na
@@ -745,13 +756,7 @@ namespace cwg148 { // cwg148: yes
namespace cwg151 { // cwg151: 3.1
struct X {};
typedef int X::*p;
-#if __cplusplus < 201103L
-#define fold(x) (__builtin_constant_p(0) ? (x) : (x))
-#else
-#define fold
-#endif
- int check[fold(p() == 0) ? 1 : -1];
-#undef fold
+ static_assert(__enable_constant_folding(p() == 0), "");
}
namespace cwg152 { // cwg152: yes
@@ -956,42 +961,42 @@ namespace cwg171 {
namespace cwg172 { // cwg172: yes
enum { zero };
- int check1[-1 < zero ? 1 : -1];
+ static_assert(-1 < zero, "");
enum { x = -1, y = (unsigned int)-1 };
- int check2[sizeof(x) > sizeof(int) ? 1 : -1];
+ static_assert(sizeof(x) > sizeof(int), "");
enum { a = (unsigned int)-1 / 2 };
- int check3a[sizeof(a) == sizeof(int) ? 1 : -1];
- int check3b[-a < 0 ? 1 : -1];
+ static_assert(sizeof(a) == sizeof(int), "");
+ static_assert(-a < 0, "");
enum { b = (unsigned int)-1 / 2 + 1 };
- int check4a[sizeof(b) == sizeof(unsigned int) ? 1 : -1];
- int check4b[-b > 0 ? 1 : -1];
+ static_assert(sizeof(b) == sizeof(unsigned int), "");
+ static_assert(-b > 0, "");
enum { c = (unsigned long)-1 / 2 };
- int check5a[sizeof(c) == sizeof(long) ? 1 : -1];
- int check5b[-c < 0 ? 1 : -1];
+ static_assert(sizeof(c) == sizeof(long), "");
+ static_assert(-c < 0, "");
enum { d = (unsigned long)-1 / 2 + 1 };
- int check6a[sizeof(d) == sizeof(unsigned long) ? 1 : -1];
- int check6b[-d > 0 ? 1 : -1];
+ static_assert(sizeof(d) == sizeof(unsigned long), "");
+ static_assert(-d > 0, "");
enum { e = (unsigned long long)-1 / 2 };
// cxx98-error at -1 {{'long long' is a C++11 extension}}
- int check7a[sizeof(e) == sizeof(long) ? 1 : -1];
- int check7b[-e < 0 ? 1 : -1];
+ static_assert(sizeof(e) == sizeof(long), "");
+ static_assert(-e < 0, "");
enum { f = (unsigned long long)-1 / 2 + 1 };
// cxx98-error at -1 {{'long long' is a C++11 extension}}
- int check8a[sizeof(f) == sizeof(unsigned long) ? 1 : -1];
- int check8b[-f > 0 ? 1 : -1];
+ static_assert(sizeof(f) == sizeof(unsigned long), "");
+ static_assert(-f > 0, "");
}
namespace cwg173 { // cwg173: yes
- int check[('0' + 1 == '1' && '0' + 2 == '2' && '0' + 3 == '3' &&
- '0' + 4 == '4' && '0' + 5 == '5' && '0' + 6 == '6' &&
- '0' + 7 == '7' && '0' + 8 == '8' && '0' + 9 == '9') ? 1 : -1];
+ static_assert('0' + 1 == '1' && '0' + 2 == '2' && '0' + 3 == '3' &&
+ '0' + 4 == '4' && '0' + 5 == '5' && '0' + 6 == '6' &&
+ '0' + 7 == '7' && '0' + 8 == '8' && '0' + 9 == '9', "");
}
// cwg174: sup 1012
@@ -1070,7 +1075,7 @@ namespace cwg177 { // cwg177: yes
}
namespace cwg178 { // cwg178: yes
- int check[int() == 0 ? 1 : -1];
+ static_assert(int() == 0, "");
#if __cplusplus >= 201103L
static_assert(int{} == 0, "");
struct S { int a, b; };
@@ -1180,7 +1185,7 @@ namespace cwg187 { // cwg187: sup 481
namespace cwg188 { // cwg188: yes
char c[10];
- int check[sizeof(0, c) == 10 ? 1 : -1];
+ static_assert(sizeof(0, c) == 10, "");
}
// cwg190 FIXME: add codegen test for tbaa
diff --git a/clang/test/CXX/drs/dr2xx.cpp b/clang/test/CXX/drs/dr2xx.cpp
index e655e7226d51d6..5d3e8ce4bea3bc 100644
--- a/clang/test/CXX/drs/dr2xx.cpp
+++ b/clang/test/CXX/drs/dr2xx.cpp
@@ -10,10 +10,15 @@
typedef __SIZE_TYPE__ size_t;
// cxx98-error at -1 0-1 {{'long long' is a C++11 extension}}
-#if __cplusplus < 201103L
-#define fold(x) (__builtin_constant_p(x) ? (x) : (x))
+#if __cplusplus == 199711L
+#define static_assert(...) __extension__ _Static_assert(__VA_ARGS__)
+// cxx98-error at -1 {{variadic macros are a C99 feature}}
+#endif
+
+#if __cplusplus == 199711L
+#define __enable_constant_folding(x) (__builtin_constant_p(x) ? (x) : (x))
#else
-#define fold
+#define __enable_constant_folding
#endif
namespace cwg200 { // cwg200: dup 214
@@ -31,7 +36,7 @@ namespace cwg200 { // cwg200: dup 214
namespace cwg202 { // cwg202: 3.1
template<typename T> T f();
template<int (*g)()> struct X {
- int arr[fold(g == &f<int>) ? 1 : -1];
+ static_assert(__enable_constant_folding(g == &f<int>), "");
};
template struct X<f>;
}
@@ -1024,7 +1029,7 @@ namespace cwg275 { // cwg275: no
namespace cwg277 { // cwg277: 3.1
typedef int *intp;
int *p = intp();
- int a[fold(intp() ? -1 : 1)];
+ static_assert(__enable_constant_folding(!intp()), "");
}
namespace cwg280 { // cwg280: 2.9
diff --git a/clang/test/CXX/drs/dr3xx.cpp b/clang/test/CXX/drs/dr3xx.cpp
index 6d1c6958ac8eb6..3e9228fe21fb64 100644
--- a/clang/test/CXX/drs/dr3xx.cpp
+++ b/clang/test/CXX/drs/dr3xx.cpp
@@ -5,6 +5,17 @@
// RUN: %clang_cc1 -std=c++11 -verify=expected,cxx98-14,cxx98-17,cxx98-20,cxx11-14,since-cxx11 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++98 -verify=expected,cxx98-14,cxx98-17,cxx98-20,cxx98 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
+#if __cplusplus == 199711L
+#define static_assert(...) __extension__ _Static_assert(__VA_ARGS__)
+// cxx98-error at -1 {{variadic macros are a C99 feature}}
+#endif
+
+#if __cplusplus == 199711L
+#define __enable_constant_folding(x) (__builtin_constant_p(x) ? (x) : (x))
+#else
+#define __enable_constant_folding
+#endif
+
namespace cwg300 { // cwg300: yes
template<typename R, typename A> void f(R (&)(A)) {}
int g(int);
@@ -396,7 +407,7 @@ namespace cwg324 { // cwg324: 3.6
namespace cwg326 { // cwg326: 3.1
struct S {};
- int test[__is_trivially_constructible(S, const S&) ? 1 : -1];
+ static_assert(__is_trivially_constructible(S, const S&), "");
}
namespace cwg327 { // cwg327: dup 538
@@ -653,7 +664,7 @@ namespace cwg339 { // cwg339: 2.8
template<typename T> A<sizeof(f(T()))> make_A();
- int a[conv_int<char>::value ? 1 : -1];
+ static_assert(conv_int<char>::value, "");
bool b = conv_int2<char>(A<1>());
A<1> c = make_A<char>();
}
@@ -1099,21 +1110,14 @@ namespace cwg364 { // cwg364: yes
#endif
namespace cwg367 { // cwg367: yes
- // FIXME: These diagnostics are terrible. Don't diagnose an ill-formed global
- // array as being a VLA!
- int a[true ? throw 0 : 4];
- // expected-error at -1 {{variable length arrays in C++ are a Clang extension}}
- // expected-error at -2 {{variable length array declaration not allowed at file scope}}
- int b[true ? 4 : throw 0];
- // cxx98-error at -1 {{variable length arrays in C++ are a Clang extension}}
- // cxx98-error at -2 {{variable length array folded to constant array as an extension}}
- int c[true ? *new int : 4];
- // expected-error at -1 {{variable length arrays in C++ are a Clang extension}}
+ static_assert(__enable_constant_folding(true ? throw 0 : 4), "");
+ // expected-error at -1 {{expression is not an integral constant expression}}
+ static_assert(__enable_constant_folding(true ? 4 : throw 0), "");
+ static_assert(__enable_constant_folding(true ? *new int : 4), "");
+ // expected-error at -1 {{expression is not an integral constant expression}}
// expected-note at -2 {{read of uninitialized object is not allowed in a constant expression}}
- // expected-error at -3 {{variable length array declaration not allowed at file scope}}
- int d[true ? 4 : *new int];
- // cxx98-error at -1 {{variable length arrays in C++ are a Clang extension}}
- // cxx98-error at -2 {{variable length array folded to constant array as an extension}}
+ static_assert(__enable_constant_folding(true ? 4 : *new int), "");
+
}
namespace cwg368 { // cwg368: 3.6
@@ -1325,7 +1329,7 @@ namespace cwg383 { // cwg383: yes
struct B { ~B(); };
union C { C &operator=(const C&); };
union D { ~D(); };
- int check[(__is_pod(A) || __is_pod(B) || __is_pod(C) || __is_pod(D)) ? -1 : 1];
+ static_assert(!__is_pod(A) && !__is_pod(B) && !__is_pod(C) && !__is_pod(D), "");
}
namespace cwg384 { // cwg384: yes
diff --git a/clang/test/CXX/drs/dr4xx.cpp b/clang/test/CXX/drs/dr4xx.cpp
index 611b791470785d..07162cc28f6b60 100644
--- a/clang/test/CXX/drs/dr4xx.cpp
+++ b/clang/test/CXX/drs/dr4xx.cpp
@@ -6,6 +6,11 @@
// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++23 %s -verify=expected,since-cxx20,since-cxx17,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++2c %s -verify=expected,since-cxx20,since-cxx17,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+#if __cplusplus == 199711L
+#define static_assert(...) __extension__ _Static_assert(__VA_ARGS__)
+// cxx98-error at -1 {{variadic macros are a C99 feature}}
+#endif
+
// FIXME: __SIZE_TYPE__ expands to 'long long' on some targets.
__extension__ typedef __SIZE_TYPE__ size_t;
@@ -217,7 +222,7 @@ namespace cwg407 { // cwg407: 3.8
}
namespace cwg408 { // cwg408: 3.4
- template<int N> void g() { int arr[N != 1 ? 1 : -1]; }
+ template<int N> void g() { static_assert(N != 1, ""); }
template<> void g<2>() { }
template<typename T> struct S {
@@ -239,7 +244,7 @@ namespace cwg408 { // cwg408: 3.4
};
template<typename T> int R<T>::arr[1];
template<typename T> void R<T>::f() {
- int arr[sizeof(arr) != sizeof(int) ? 1 : -1];
+ static_assert(sizeof(arr) != sizeof(int), "");
}
template<> int R<int>::arr[2];
template void R<int>::f();
@@ -842,11 +847,10 @@ namespace cwg451 { // cwg451: yes
// expected-warning at -1 {{division by zero is undefined}}
const int b = 1 / 0; // #cwg451-b
// expected-warning at -1 {{division by zero is undefined}}
- int arr[b]; // #cwg451-arr
- // expected-error at -1 {{variable length arrays in C++ are a Clang extension}}
+ static_assert(b, "");
+ // expected-error at -1 {{expression is not an integral constant expression}}
// expected-note at -2 {{initializer of 'b' is not a constant expression}}
// expected-note@#cwg451-b {{declared here}}
- // expected-error@#cwg451-arr {{variable length array declaration not allowed at file scope}}
}
namespace cwg452 { // cwg452: yes
@@ -876,11 +880,10 @@ namespace cwg456 { // cwg456: yes
namespace cwg457 { // cwg457: yes
const int a = 1;
const volatile int b = 1;
- int ax[a];
- int bx[b];
- // expected-error at -1 {{variable length arrays in C++ are a Clang extension}}
+ static_assert(a, "");
+ static_assert(b, "");
+ // expected-error at -1 {{expression is not an integral constant expression}}
// expected-note at -2 {{read of volatile-qualified type 'const volatile int' is not allowed in a constant expression}}
- // expected-error at -3 {{variable length array declaration not allowed at file scope}}
enum E {
ea = a,
@@ -1276,20 +1279,18 @@ namespace cwg482 { // cwg482: 3.5
namespace cwg483 { // cwg483: yes
namespace climits {
- int check1[__SCHAR_MAX__ >= 127 ? 1 : -1];
- int check2[__SHRT_MAX__ >= 32767 ? 1 : -1];
- int check3[__INT_MAX__ >= 32767 ? 1 : -1];
- int check4[__LONG_MAX__ >= 2147483647 ? 1 : -1];
- int check5[__LONG_LONG_MAX__ >= 9223372036854775807 ? 1 : -1];
- // cxx98-error at -1 {{'long long' is a C++11 extension}}
- // cxx98-error at -2 0-1{{'long long' is a C++11 extension}}
+ static_assert(__SCHAR_MAX__ >= 127, "");
+ static_assert(__SHRT_MAX__ >= 32767, "");
+ static_assert(__INT_MAX__ >= 32767, "");
+ static_assert(__LONG_MAX__ >= 2147483647, "");
+ static_assert(__LONG_LONG_MAX__ >= 9223372036854775807, "");
}
namespace cstdint {
- int check1[__PTRDIFF_WIDTH__ >= 16 ? 1 : -1];
- int check2[__SIG_ATOMIC_WIDTH__ >= 8 ? 1 : -1];
- int check3[__SIZE_WIDTH__ >= 16 ? 1 : -1];
- int check4[__WCHAR_WIDTH__ >= 8 ? 1 : -1];
- int check5[__WINT_WIDTH__ >= 16 ? 1 : -1];
+ static_assert(__PTRDIFF_WIDTH__ >= 16, "");
+ static_assert(__SIG_ATOMIC_WIDTH__ >= 8, "");
+ static_assert(__SIZE_WIDTH__ >= 16, "");
+ static_assert(__WCHAR_WIDTH__ >= 8, "");
+ static_assert(__WINT_WIDTH__ >= 16, "");
}
}
@@ -1366,11 +1367,10 @@ namespace cwg486 { // cwg486: yes
namespace cwg487 { // cwg487: yes
enum E { e };
int operator+(int, E); // #cwg487-operator-plus
- int i[4 + e]; // #cwg487-i
- // expected-error at -1 {{variable length arrays in C++ are a Clang extension}}
+ static_assert(4 + e, "");
+ // expected-error at -1 {{expression is not an integral constant expression}}
// since-cxx11-note at -2 {{non-constexpr function 'operator+' cannot be used in a constant expression}}
// since-cxx11-note@#cwg487-operator-plus {{declared here}}
- // expected-error@#cwg487-i {{variable length array declaration not allowed at file scope}}
}
namespace cwg488 { // cwg488: yes c++11
@@ -1485,13 +1485,13 @@ namespace cwg495 { // cwg495: 3.5
namespace cwg496 { // cwg496: sup 2094
struct A { int n; };
struct B { volatile int n; };
- int check1[ __is_trivially_copyable(const int) ? 1 : -1];
+ static_assert(__is_trivially_copyable(const int), "");
// This checks the cwg2094 behavior, not cwg496
- int check2[ __is_trivially_copyable(volatile int) ? 1 : -1];
- int check3[ __is_trivially_constructible(A, const A&) ? 1 : -1];
- int check4[ __is_trivially_constructible(B, const B&) ? 1 : -1];
- int check5[ __is_trivially_assignable(A, const A&) ? 1 : -1];
- int check6[ __is_trivially_assignable(B, const B&) ? 1 : -1];
+ static_assert(__is_trivially_copyable(volatile int), "");
+ static_assert(__is_trivially_constructible(A, const A&), "");
+ static_assert(__is_trivially_constructible(B, const B&), "");
+ static_assert(__is_trivially_assignable(A, const A&), "");
+ static_assert(__is_trivially_assignable(B, const B&), "");
}
namespace cwg497 { // cwg497: sup 253
diff --git a/clang/test/CXX/drs/dr5xx.cpp b/clang/test/CXX/drs/dr5xx.cpp
index 0fe64102d70b00..9d890f981348a7 100644
--- a/clang/test/CXX/drs/dr5xx.cpp
+++ b/clang/test/CXX/drs/dr5xx.cpp
@@ -5,6 +5,11 @@
// RUN: %clang_cc1 -std=c++20 %s -verify=expected,since-cxx20,since-cxx17,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++23 %s -verify=expected,since-cxx23,since-cxx20,since-cxx17,since-cxx11 -fexceptions -fcxx-exceptions -pedantic-errors
+#if __cplusplus == 199711L
+#define static_assert(...) __extension__ _Static_assert(__VA_ARGS__)
+// cxx98-error at -1 {{variadic macros are a C99 feature}}
+#endif
+
// FIXME: This is included to avoid a diagnostic with no source location
// pointing at the implicit operator new. We can't match such a diagnostic
// with -verify.
@@ -819,7 +824,7 @@ namespace cwg565 { // cwg565: yes
namespace cwg566 { // cwg566: yes
#if __cplusplus >= 201103L
- int check[int(-3.99) == -3 ? 1 : -1];
+ static_assert(int(-3.99) == -3, "");
#endif
}
@@ -834,7 +839,7 @@ namespace cwg568 { // cwg568: 3.0 c++11
public:
int n;
};
- int check_trivial[__is_trivial(trivial) ? 1 : -1];
+ static_assert(__is_trivial(trivial), "");
struct std_layout {
std_layout();
@@ -843,7 +848,7 @@ namespace cwg568 { // cwg568: 3.0 c++11
private:
int n;
};
- int check_std_layout[__is_standard_layout(std_layout) ? 1 : -1];
+ static_assert(__is_standard_layout(std_layout), "");
struct aggregate {
int x;
@@ -885,7 +890,7 @@ namespace cwg570 { // cwg570: dup 633
namespace cwg572 { // cwg572: yes
enum E { a = 1, b = 2 };
- int check[a + b == 3 ? 1 : -1];
+ static_assert(a + b == 3, "");
}
namespace cwg573 { // cwg573: no
diff --git a/clang/test/CXX/drs/dr6xx.cpp b/clang/test/CXX/drs/dr6xx.cpp
index 9d3613ae8589ea..069102d9c59750 100644
--- a/clang/test/CXX/drs/dr6xx.cpp
+++ b/clang/test/CXX/drs/dr6xx.cpp
@@ -144,7 +144,7 @@ namespace cwg608 { // cwg608: yes
struct D : B, C {};
}
-int cwg610[-0u == 0u ? 1 : -1]; // cwg610: yes
+static_assert(-0u == 0u, ""); // cwg610: yes
namespace cwg611 { // cwg611: yes
int k;
@@ -190,8 +190,8 @@ namespace cwg613 { // cwg613: yes c++11
}
}
-int cwg614_a[(-1) / 2 == 0 ? 1 : -1]; // cwg614: yes
-int cwg614_b[(-1) % 2 == -1 ? 1 : -1];
+static_assert((-1) / 2 == 0, ""); // cwg614: yes
+static_assert((-1) % 2 == -1, "");
namespace cwg615 { // cwg615: yes
int f();
More information about the cfe-commits
mailing list