Hi!
On 2023-11-23T09:32:24+0100, Jakub Jelinek <ja...@redhat.com> wrote:
> Here is what I've committed
> --- gcc/testsuite/g++.dg/cpp26/static_assert1.C.jj 2023-11-22
> 10:17:41.340064988 +0100
> +++ gcc/testsuite/g++.dg/cpp26/static_assert1.C 2023-11-22
> 10:47:45.045848504 +0100
> @@ -0,0 +1,309 @@
> +// C++26 P2741R3 - user-generated static_assert messages
OK to push the attached
"Fix 'g++.dg/cpp26/static_assert1.C' for '-fno-exceptions' configurations"?
Grüße
Thomas
> +// { dg-do compile { target c++11 } }
> +// { dg-options "" }
> +
> +static_assert (true, "");
> +static_assert (true, ("")); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "'static_assert' message must be
> a string literal or object with 'size' and 'data' members" "" { target *-*-*
> } .-1 }
> + // { dg-error "request for member 'size' in
> '\\\(\\\"\\\"\\\)', which is of non-class type 'const char \\\[1\\\]'" "" {
> target *-*-* } .-2 }
> +static_assert (true, "" + 0); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "'static_assert' message must be
> a string literal or object with 'size' and 'data' members" "" { target *-*-*
> } .-1 }
> + // { dg-error "request for member 'size' in
> '\\\(const char\\\*\\\)\\\"\\\"', which is of non-class type 'const
> char\\\*'" "" { target *-*-* } .-2 }
> +static_assert (true, 0); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "'static_assert' message must be
> a string literal or object with 'size' and 'data' members" "" { target *-*-*
> } .-1 }
> + // { dg-error "request for member 'size' in
> '0', which is of non-class type 'int'" "" { target *-*-* } .-2 }
> +struct A {};
> +static_assert (true, A {}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "'static_assert' message must be
> a string literal or object with 'size' and 'data' members" "" { target *-*-*
> } .-1 }
> + // { dg-error "'struct A' has no member named
> 'size'" "" { target *-*-* } .-2 }
> +struct B { int size; };
> +static_assert (true, B {}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "'static_assert' message must be
> a string literal or object with 'size' and 'data' members" "" { target *-*-*
> } .-1 }
> + // { dg-error "'struct B' has no member named
> 'data'" "" { target *-*-* } .-2 }
> +struct C { constexpr int size () const { return 0; } };
> +static_assert (true, C {}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "'static_assert' message must be
> a string literal or object with 'size' and 'data' members" "" { target *-*-*
> } .-1 }
> + // { dg-error "'struct C' has no member named
> 'data'" "" { target *-*-* } .-2 }
> +struct D { constexpr int size () const { return 0; } int data; };
> +static_assert (true, D {}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "'D\\\(\\\).D::data' cannot be
> used as a function" "" { target *-*-* } .-1 }
> +struct E { int size = 0;
> + constexpr const char *data () const { return ""; } };
> +static_assert (true, E {}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "'E\\\(\\\).E::size' cannot be
> used as a function" "" { target c++11_only } .-1 }
> + // { dg-error "'E\\\{0\\\}.E::size' cannot be
> used as a function" "" { target c++14 } .-2 }
> +struct F { constexpr const char *size () const { return ""; }
> + constexpr const char *data () const { return ""; } };
> +static_assert (true, F {}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "'static_assert' message
> 'size\\\(\\\)' must be implicitly convertible to 'std::size_t'" "" { target
> *-*-* } .-1 }
> + // { dg-error "could not convert
> 'F\\\(\\\).F::size\\\(\\\)' from 'const char\\\*' to '\[^']*'" "" { target
> *-*-* } .-2 }
> + // { dg-error "conversion from 'const char\\\*'
> to '\[^']*' in a converted constant expression" "" { target *-*-* } .-3 }
> +struct G { constexpr long size () const { return 0; }
> + constexpr float data () const { return 0.0f; } };
> +static_assert (true, G {}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "'static_assert' message
> 'data\\\(\\\)' must be implicitly convertible to 'const char\\\*'" "" {
> target *-*-* } .-1 }
> + // { dg-error "could not convert
> 'G\\\(\\\).G::data\\\(\\\)' from 'float' to 'const char\\\*'" "" { target
> *-*-* } .-2 }
> +struct H { short size () const { return 0; }
> + constexpr const char *data () const { return ""; } };
> +static_assert (true, H {}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> +struct I { constexpr signed char size () const { return 0; }
> + const char *data () const { return ""; } };
> +static_assert (true, I {}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> +struct J { constexpr int size () const { return j ? throw 1 : 0; } // {
> dg-error "expression '<throw-expression>' is not a constant expression" }
> + constexpr const char *data () const { return ""; };
> + constexpr J (int x) : j (x) {}
> + int j; };
> +static_assert (true, J (1)); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> +static_assert (false, J (0)); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "static assertion failed" "" {
> target *-*-* } .-1 }
> +static_assert (false, J (1)); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "'static_assert' message
> 'size\\\(\\\)' must be a constant expression" "" { target *-*-* } .-1 }
> +struct K { constexpr operator int () { return 4; } };
> +struct L { constexpr operator const char * () { return "test"; } };
> +struct M { constexpr K size () const { return {}; }
> + constexpr L data () const { return {}; } };
> +static_assert (true, M {}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> +static_assert (false, M {}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "static assertion failed: test"
> "" { target *-*-* } .-1 }
> +#if __cpp_constexpr_dynamic_alloc >= 201907L
> +struct N { constexpr int size () const { return 3; }
> + constexpr const char *data () const { return new char[3] { 'b', 'a',
> 'd' }; } }; // { dg-error "'\\\* N\\\(\\\).N::data\\\(\\\)' is not a constant
> expression because allocated storage has not been deallocated" "" { target
> c++20 } }
> +static_assert (true, N {}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target { c++20 && c++23_down } }
> }
> +static_assert (false, N {}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target { c++20 && c++23_down } }
> }
> + // { dg-error "'static_assert' message
> 'data\\\(\\\)\\\[0\\\]' must be a constant expression" "" { target c++20 }
> .-1 }
> +#endif
> +constexpr const char a[] = { 't', 'e', 's', 't' };
> +struct O { constexpr int size () const { return 4; }
> + constexpr const char *data () const { return a; } };
> +static_assert (false, O {}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "static assertion failed: test"
> "" { target *-*-* } .-1 }
> +struct P { constexpr int size () const { return 4 - p; }
> + constexpr const char *data () const { return &a[p]; }
> + constexpr P (int x) : p (x) {}
> + int p; };
> +static_assert (false, P (0)); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "static assertion failed: test"
> "" { target *-*-* } .-1 }
> +static_assert (false, P (2)); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "static assertion failed: st" ""
> { target *-*-* } .-1 }
> +struct Q { constexpr int size () const { return 4 - q; }
> + constexpr const char *data () const { return &"test"[q]; }
> + constexpr Q (int x) : q (x) {}
> + int q; };
> +static_assert (false, Q (0)); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "static assertion failed: test"
> "" { target *-*-* } .-1 }
> +static_assert (false, Q (1)); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "static assertion failed: est" ""
> { target *-*-* } .-1 }
> +struct R { constexpr int size () const { return 4 - r; }
> + constexpr const char *d () const { return "test"; }
> + constexpr const char *data () const { return d () + r; }
> + constexpr R (int x) : r (x) {}
> + int r; };
> +static_assert (false, R (0)); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "static assertion failed: test"
> "" { target *-*-* } .-1 }
> +static_assert (false, R (2)); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "static assertion failed: st" ""
> { target *-*-* } .-1 }
> +struct S { constexpr float size (float) const { return 42.0f; }
> + constexpr int size (void * = nullptr) const { return 4; }
> + constexpr double data (double) const { return 42.0; }
> + constexpr const char *data (int = 0) const { return "test"; } };
> +static_assert (true, S {}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> +static_assert (false, S {}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "static assertion failed: test"
> "" { target *-*-* } .-1 }
> +
> +using size_t = decltype (sizeof (0));
> +struct string_view {
> + size_t s;
> + const char *d;
> + constexpr string_view () : s (0), d (nullptr) {}
> + constexpr string_view (const char *p) : s (__builtin_strlen (p)), d (p) {}
> + constexpr string_view (size_t l, const char *p) : s (l), d (p) {}
> + constexpr size_t size () const noexcept { return s; }
> + constexpr const char *data () const noexcept { return d; }
> +};
> +static_assert (true, string_view{}); // { dg-warning
> "'static_assert' with non-string message only available with" "" { target
> c++23_down } }
> +static_assert (false, string_view ("test")); // { dg-warning
> "'static_assert' with non-string message only available with" "" { target
> c++23_down } }
> + // { dg-error
> "static assertion failed: test" "" { target *-*-* } .-1 }
> +static_assert (false, string_view ("א")); // { dg-warning
> "'static_assert' with non-string message only available with" "" { target
> c++23_down } }
> + // { dg-error
> "static assertion failed: א" "" { target *-*-* } .-1 }
> +static_assert (false, string_view (0, nullptr)); // { dg-warning
> "'static_assert' with non-string message only available with" "" { target
> c++23_down } }
> + // { dg-error
> "static assertion failed" "" { target *-*-* } .-1 }
> +static_assert (false, string_view (4, "testwithextrachars")); // {
> dg-warning "'static_assert' with non-string message only available with" "" {
> target c++23_down } }
> + // { dg-error
> "static assertion failed: test" "" { target *-*-* } .-1 }
> +static_assert (false, string_view (42, "test")); // { dg-warning
> "'static_assert' with non-string message only available with" "" { target
> c++23_down } }
> + // { dg-error
> "array subscript value '41' is outside the bounds of array type 'const char
> \\\[5\\\]'" "" { target *-*-* } .-1 }
> + // { dg-error
> "'static_assert' message 'data\\\(\\\)\\\[41\\\]' must be a constant
> expression" "" { target *-*-* } .-2 }
> +
> +template <typename T, size_t N>
> +struct array {
> + constexpr size_t size () const { return N; }
> + constexpr const T *data () const { return a; }
> + const T a[N];
> +};
> +static_assert (true, array<char, 2> { 'O', 'K' }); // { dg-warning
> "'static_assert' with non-string message only available with" "" { target
> c++23_down } }
> +static_assert (true, array<wchar_t, 2> { L'O', L'K' }); // {
> dg-warning "'static_assert' with non-string message only available with" "" {
> target c++23_down } }
> + // { dg-error
> "'static_assert' message 'data\\\(\\\)' must be implicitly convertible to
> 'const char\\\*'" "" { target *-*-* } .-1 }
> + // { dg-error
> "could not convert 'array<wchar_t, 2>{const wchar_t \\\[2\\\]{\[0-9]+,
> \[0-9]+}}.array<wchar_t, 2>::data\\\(\\\)' from 'const wchar_t\\\*' to 'const
> char\\\*'" "" { target *-*-* } .-2 }
> +static_assert (false, array<char, 4> { 't', 'e', 's', 't' }); // {
> dg-warning "'static_assert' with non-string message only available with" "" {
> target c++23_down } }
> + // { dg-error
> "static assertion failed: test" "" { target *-*-* } .-1 }
> +
> +void
> +foo ()
> +{
> + constexpr auto a = array<char, 4> { 't', 'e', 's', 't' };
> + static_assert (false, a); // { dg-warning
> "'static_assert' with non-string message only available with" "" { target
> c++23_down } }
> +} // { dg-error
> "static assertion failed: test" "" { target *-*-* } .-1 }
> +
> +#if __cpp_constexpr_dynamic_alloc >= 201907L
> +struct T {
> + const char *d = init ();
> + constexpr int size () const { return 4; }
> + constexpr const char *data () const { return d; }
> + constexpr const char *init () const { return new char[4] { 't', 'e', 's',
> 't' }; }
> + constexpr ~T () { delete[] d; }
> +};
> +static_assert (false, T{}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target { c++20 && c++23_down } }
> }
> + // { dg-error "static assertion failed:
> test" "" { target c++20 } .-1 }
> +#endif
> +struct U { constexpr operator const char * () const { return u; }
> + char u[5] = "test"; };
> +#if __cplusplus >= 201402L
> +struct V { constexpr auto size () const { return K{}; }
> + constexpr auto data () const { return U{}; } };
> +static_assert (false, V{}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target { c++14 && c++23_down } }
> }
> + // { dg-error "static assertion failed:
> test" "" { target c++14 } .-1 }
> +#endif
> +struct W { constexpr int size (int) const { return 4; }
> + constexpr const char *data () const { return "test"; } };
> +static_assert (true, W{}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "no matching function for
> call to 'W::size\\\(\\\)'" "" { target *-*-* } .-1 }
> +struct X { constexpr int size () const { return 4; }
> + constexpr const char *data (int) const { return "test"; } };
> +static_assert (true, X{}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "no matching function for
> call to 'X::data\\\(\\\)'" "" { target *-*-* } .-1 }
> +struct Y { constexpr int size () { return 4; }
> + constexpr const char *data (int) { return "test"; } };
> +static_assert (true, Y{}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "no matching function for
> call to 'Y::data\\\(\\\)'" "" { target *-*-* } .-1 }
> +#if __cpp_concepts >= 201907L
> +struct Z { constexpr int size (auto...) const { return 4; }
> + constexpr const char *data (auto...) const { return "test"; } };
> +static_assert (false, Z{}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target { c++20 && c++23_down } }
> }
> + // { dg-error "static assertion failed:
> test" "" { target c++20 } .-1 }
> +#endif
> +
> +namespace NN
> +{
> + template <typename T>
> + struct A {
> + constexpr int size () const = delete;
> + constexpr const char *data () const { return "test"; } };
> + static_assert (true, A<int>{}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "use of deleted function
> 'constexpr int NN::A<T>::size\\\(\\\) const \\\[with T = int\\\]'" "" {
> target *-*-* } .-1 }
> +#if __cpp_concepts >= 201907L
> + template <typename T>
> + struct B {
> + constexpr int size () const { return 4; }
> + constexpr const char *data () const requires false { return "test"; } };
> + static_assert (true, B<short>{}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target { c++20 && c++23_down } }
> }
> + // { dg-error "no matching function for
> call to 'NN::B<short int>::data\\\(\\\)'" "" { target c++20 } .-1 }
> +#endif
> + class C {
> + constexpr int size () const = delete;
> + constexpr const char *data () const { return "test"; } };
> + static_assert (true, C{}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "use of deleted function
> 'constexpr int NN::C::size\\\(\\\) const'" "" { target *-*-* } .-1 }
> + // { dg-error "'constexpr const
> char\\\* NN::C::data\\\(\\\) const' is private within this context" "" {
> target *-*-* } .-2 }
> +#if __cplusplus >= 201402L
> + struct D {
> + constexpr int size () { return 4; }
> + constexpr int size () const { return 3; }
> + constexpr const char *data () { return "test"; }
> + constexpr const char *data () const { return "ehlo"; } };
> + static_assert (true, D{}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target { c++14 && c++23_down } }
> }
> + static_assert (false, D{}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target { c++14 && c++23_down } }
> }
> + // { dg-error "static assertion failed: test"
> "" { target c++14 } .-1 }
> +#endif
> + struct E {
> + constexpr int size () const { return 4; }
> + constexpr const char *data () const { return "test"; } };
> + template <typename T>
> + struct F {
> + static_assert (false, T{}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + }; // { dg-error "static assertion failed: test"
> "" { target *-*-* } .-1 }
> + template <typename T>
> + struct G {
> + static_assert (false, T{}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + }; // { dg-error "'static_assert' message must be
> a string literal or object with 'size' and 'data' members" "" { target *-*-*
> } .-1 }
> + // { dg-error "request for member 'size' in
> '0', which is of non-class type 'long int'" "" { target *-*-* } .-2 }
> + F<E> fe;
> + G<long> gl;
> + constexpr E operator ""_myd (const char *, size_t) { return E{}; }
> + static_assert (false, "foo"_myd); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "static assertion failed:
> test" "" { target *-*-* } .-1 }
> + constexpr E operator + (const char *, const E &) { return E{}; }
> + static_assert (false, "foo" + E{}); // { dg-warning
> "'static_assert' with non-string message only available with" "" { target
> c++23_down } }
> + // { dg-error "static assertion failed:
> test" "" { target *-*-* } .-1 }
> + struct H {
> + static constexpr int size () { return 7; }
> + static constexpr const char *data () { return "message"; } };
> + static_assert (true, H{}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + static_assert (false, H{}); // { dg-warning
> "'static_assert' with non-string message only available with" "" { target
> c++23_down } }
> + // { dg-error "static assertion failed:
> message" "" { target *-*-* } .-1 }
> + struct I {
> + static constexpr int size () { return 0; }
> + static constexpr const char *data () { return nullptr; } };
> + static_assert (true, I{}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + static_assert (false, I{}); // { dg-warning
> "'static_assert' with non-string message only available with" "" { target
> c++23_down } }
> + // { dg-error "static assertion failed"
> "" { target *-*-* } .-1 }
> +#if __cplusplus >= 201402L
> + struct J {
> + static constexpr int size () { return 0; }
> + static constexpr const char *data (int x = 0) { if (x) return nullptr;
> else throw 1; } }; // { dg-error "expression '<throw-expression>' is not a
> constant expression" "" { target c++14 } }
> + static_assert (true, J{}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target { c++14 && c++23_down } }
> }
> + static_assert (false, J{}); // { dg-warning
> "'static_assert' with non-string message only available with" "" { target {
> c++14 && c++23_down } } }
> + // { dg-error "'static_assert' message
> 'data\\\(\\\)' must be a core constant expression" "" { target c++14 } .-1 }
> +#endif
> +#if __cpp_if_consteval >= 202106L
> + struct K {
> + static constexpr int size () { if consteval { return 4; } else { throw
> 1; } }
> + static constexpr const char *data () { return "test"; }
> + };
> + static_assert (true, K{}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_only } }
> + static_assert (false, K{}); // { dg-warning
> "'static_assert' with non-string message only available with" "" { target
> c++23_only } }
> + // { dg-error "static assertion failed:
> test" "" { target c++23 } .-1 }
> + struct L {
> + static constexpr int size () { return 4; }
> + static constexpr const char *data () { if consteval { return "test"; }
> else { throw 1; } }
> + };
> + static_assert (true, L{}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_only } }
> + static_assert (false, L{}); // { dg-warning
> "'static_assert' with non-string message only available with" "" { target
> c++23_only } }
> + // { dg-error "static assertion failed:
> test" "" { target c++23 } .-1 }
> + struct M {
> + static constexpr int size () { if consteval { throw 1; } else { return
> 4; } } // { dg-error "expression '<throw-expression>' is not a constant
> expression" "" { target c++23 } }
> + static constexpr const char *data () { return "test"; }
> + };
> + static_assert (true, M{}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_only } }
> + static_assert (false, M{}); // { dg-warning
> "'static_assert' with non-string message only available with" "" { target
> c++23_only } }
> + // { dg-error "'static_assert' message
> 'size\\\(\\\)' must be a constant expression" "" { target c++23 } .-1 }
> + struct N {
> + static constexpr int size () { return 4; }
> + static constexpr const char *data () { if consteval { throw 1; } else {
> return "test"; } } // { dg-error "expression '<throw-expression>' is not a
> constant expression" "" { target c++23 } }
> + };
> + static_assert (true, N{}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_only } }
> + static_assert (false, N{}); // { dg-warning
> "'static_assert' with non-string message only available with" "" { target
> c++23_only } }
> + // { dg-error "'static_assert' message
> 'data\\\(\\\)\\\[0\\\]' must be a constant expression" "" { target c++23 }
> .-1 }
> +#endif
> + struct O { constexpr int operator () () const { return 12; } };
> + struct P { constexpr const char *operator () () const { return "another
> test"; } };
> + struct Q { O size; P data; };
> + static_assert (true, Q ()); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + static_assert (false, Q {}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "static assertion failed: another
> test" "" { target *-*-* } .-1 }
> + constexpr int get_size () { return 16; }
> + constexpr const char *get_data () { return "yet another test"; }
> + struct R { int (*size) () = NN::get_size;
> + const char *(*data) () = NN::get_data; };
> + static_assert (true, R ()); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + static_assert (false, R {}); // { dg-warning "'static_assert' with
> non-string message only available with" "" { target c++23_down } }
> + // { dg-error "static assertion failed: yet
> another test" "" { target *-*-* } .-1 }
> +}
-----------------
Siemens Electronic Design Automation GmbH; Anschrift: Arnulfstraße 201, 80634
München; Gesellschaft mit beschränkter Haftung; Geschäftsführer: Thomas
Heurung, Frank Thürauf; Sitz der Gesellschaft: München; Registergericht
München, HRB 106955
>From b93caa5f0680f4c2c3c898373bc561bc54673765 Mon Sep 17 00:00:00 2001
From: Thomas Schwinge <tho...@codesourcery.com>
Date: Tue, 28 Nov 2023 17:52:34 +0100
Subject: [PATCH] Fix 'g++.dg/cpp26/static_assert1.C' for '-fno-exceptions'
configurations
This test case, added in recent commit 6ce952188ab39e303e4f63e474b5cba83b5b12fd
"c++: Implement C++26 P2741R3 - user-generated static_assert messages [PR110348]",
expectedly runs into 'UNSUPPORTED: [...]: exception handling disabled', but
along the way also FAILs a few tests:
UNSUPPORTED: g++.dg/cpp26/static_assert1.C -std=gnu++98
PASS: g++.dg/cpp26/static_assert1.C -std=gnu++11 (test for warnings, line 6)
[...]
PASS: g++.dg/cpp26/static_assert1.C -std=gnu++11 (test for warnings, line 51)
FAIL: g++.dg/cpp26/static_assert1.C -std=gnu++11 (test for errors, line 52)
PASS: g++.dg/cpp26/static_assert1.C -std=gnu++11 (test for warnings, line 56)
PASS: g++.dg/cpp26/static_assert1.C -std=gnu++11 (test for warnings, line 57)
FAIL: g++.dg/cpp26/static_assert1.C -std=gnu++11 at line 58 (test for errors, line 57)
PASS: g++.dg/cpp26/static_assert1.C -std=gnu++11 (test for warnings, line 59)
[...]
PASS: g++.dg/cpp26/static_assert1.C -std=gnu++11 at line 308 (test for errors, line 307)
UNSUPPORTED: g++.dg/cpp26/static_assert1.C -std=gnu++11: exception handling disabled
PASS: g++.dg/cpp26/static_assert1.C -std=gnu++14 (test for warnings, line 6)
[...]
PASS: g++.dg/cpp26/static_assert1.C -std=gnu++14 (test for warnings, line 51)
FAIL: g++.dg/cpp26/static_assert1.C -std=gnu++14 (test for errors, line 52)
PASS: g++.dg/cpp26/static_assert1.C -std=gnu++14 (test for warnings, line 56)
PASS: g++.dg/cpp26/static_assert1.C -std=gnu++14 (test for warnings, line 57)
FAIL: g++.dg/cpp26/static_assert1.C -std=gnu++14 at line 58 (test for errors, line 57)
PASS: g++.dg/cpp26/static_assert1.C -std=gnu++14 (test for warnings, line 59)
[...]
PASS: g++.dg/cpp26/static_assert1.C -std=gnu++14 at line 257 (test for errors, line 256)
FAIL: g++.dg/cpp26/static_assert1.C -std=gnu++14 (test for errors, line 261)
PASS: g++.dg/cpp26/static_assert1.C -std=gnu++14 (test for warnings, line 262)
[...]
PASS: g++.dg/cpp26/static_assert1.C -std=gnu++14 at line 308 (test for errors, line 307)
UNSUPPORTED: g++.dg/cpp26/static_assert1.C -std=gnu++14: exception handling disabled
PASS: g++.dg/cpp26/static_assert1.C -std=gnu++20 (test for warnings, line 6)
[...]
PASS: g++.dg/cpp26/static_assert1.C -std=gnu++20 (test for warnings, line 51)
FAIL: g++.dg/cpp26/static_assert1.C -std=gnu++20 (test for errors, line 52)
PASS: g++.dg/cpp26/static_assert1.C -std=gnu++20 (test for warnings, line 56)
PASS: g++.dg/cpp26/static_assert1.C -std=gnu++20 (test for warnings, line 57)
FAIL: g++.dg/cpp26/static_assert1.C -std=gnu++20 at line 58 (test for errors, line 57)
PASS: g++.dg/cpp26/static_assert1.C -std=gnu++20 (test for warnings, line 59)
[...]
PASS: g++.dg/cpp26/static_assert1.C -std=gnu++20 at line 257 (test for errors, line 256)
FAIL: g++.dg/cpp26/static_assert1.C -std=gnu++20 (test for errors, line 261)
PASS: g++.dg/cpp26/static_assert1.C -std=gnu++20 (test for warnings, line 262)
[...]
PASS: g++.dg/cpp26/static_assert1.C -std=gnu++20 at line 308 (test for errors, line 307)
UNSUPPORTED: g++.dg/cpp26/static_assert1.C -std=gnu++20: exception handling disabled
Use an explicit '-fexceptions' to turn this front end test case all-PASS.
gcc/testsuite/
* g++.dg/cpp26/static_assert1.C: Fix for '-fno-exceptions'
configurations.
---
gcc/testsuite/g++.dg/cpp26/static_assert1.C | 2 ++
1 file changed, 2 insertions(+)
diff --git a/gcc/testsuite/g++.dg/cpp26/static_assert1.C b/gcc/testsuite/g++.dg/cpp26/static_assert1.C
index 9dec52b90d6..59724ae32ce 100644
--- a/gcc/testsuite/g++.dg/cpp26/static_assert1.C
+++ b/gcc/testsuite/g++.dg/cpp26/static_assert1.C
@@ -1,6 +1,8 @@
// C++26 P2741R3 - user-generated static_assert messages
// { dg-do compile { target c++11 } }
// { dg-options "" }
+// Override any default-'-fno-exceptions':
+// { dg-additional-options -fexceptions }
static_assert (true, "");
static_assert (true, ("")); // { dg-warning "'static_assert' with non-string message only available with" "" { target c++23_down } }
--
2.34.1
