From: Thomas Schwinge <thomas@codesourcery.com>
To: Jakub Jelinek <jakub@redhat.com>,
Jason Merrill <jason@redhat.com>, <gcc-patches@gcc.gnu.org>
Subject: Fix 'g++.dg/cpp26/static_assert1.C' for '-fno-exceptions' configurations (was: [PATCH] c++, v4: Implement C++26 P2741R3 - user-generated static_assert messages [PR110348])
Date: Tue, 28 Nov 2023 18:08:33 +0100 [thread overview]
Message-ID: <87sf4p6c1a.fsf@euler.schwinge.homeip.net> (raw)
In-Reply-To: <ZV8OGMkGJFMG5urh@tucnak>
[-- Attachment #1: Type: text/plain, Size: 28643 bytes --]
Hi!
On 2023-11-23T09:32:24+0100, Jakub Jelinek <jakub@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
[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: 0001-Fix-g-.dg-cpp26-static_assert1.C-for-fno-exceptions-.patch --]
[-- Type: text/x-diff, Size: 4428 bytes --]
From b93caa5f0680f4c2c3c898373bc561bc54673765 Mon Sep 17 00:00:00 2001
From: Thomas Schwinge <thomas@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
next prev parent reply other threads:[~2023-11-28 17:08 UTC|newest]
Thread overview: 20+ messages / expand[flat|nested] mbox.gz Atom feed top
2023-08-24 14:30 [PATCH] c++: Implement C++26 P2741R3 - user-generated static_assert messages [PR110348] Jakub Jelinek
2023-09-18 17:21 ` [PATCH] c++, v2: " Jakub Jelinek
2023-10-27 1:21 ` Jason Merrill
2023-11-17 14:18 ` Jason Merrill
2023-11-17 14:22 ` Jakub Jelinek
2023-11-21 17:17 ` [PATCH] c++, v3: " Jakub Jelinek
2023-11-21 17:23 ` Jakub Jelinek
2023-11-21 21:44 ` Jason Merrill
2023-11-21 22:19 ` Jakub Jelinek
2023-11-21 22:51 ` Jakub Jelinek
2023-11-22 3:51 ` Jason Merrill
2023-11-22 10:00 ` [PATCH] c++, v4: " Jakub Jelinek
2023-11-22 21:53 ` Jason Merrill
2023-11-23 8:32 ` Jakub Jelinek
2023-11-28 16:31 ` Jason Merrill
2023-11-28 17:52 ` Jakub Jelinek
2023-11-28 21:33 ` Jason Merrill
2023-11-28 17:08 ` Thomas Schwinge [this message]
2023-11-28 17:11 ` Fix 'g++.dg/cpp26/static_assert1.C' for '-fno-exceptions' configurations Jason Merrill
2023-11-29 13:19 ` Thomas Schwinge
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=87sf4p6c1a.fsf@euler.schwinge.homeip.net \
--to=thomas@codesourcery.com \
--cc=gcc-patches@gcc.gnu.org \
--cc=jakub@redhat.com \
--cc=jason@redhat.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).