diff mbox series

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])

Message ID 87sf4p6c1a.fsf@euler.schwinge.homeip.net
State Committed
Headers
Series 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]) |

Checks

Context Check Description
linaro-tcwg-bot/tcwg_gcc_build--master-arm success Testing passed
linaro-tcwg-bot/tcwg_gcc_build--master-aarch64 success Testing passed
linaro-tcwg-bot/tcwg_gcc_check--master-aarch64 success Testing passed
linaro-tcwg-bot/tcwg_gcc_check--master-arm warning Patch is already merged

Commit Message

Thomas Schwinge Nov. 28, 2023, 5:08 p.m. UTC 
  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

Comments

Jason Merrill Nov. 28, 2023, 5:11 p.m. UTC | #1 
On 11/28/23 12:08, Thomas Schwinge wrote:
> 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"?

>  // { dg-options "" }
> +// Override any default-'-fno-exceptions':
> +// { dg-additional-options -fexceptions }

Might as well put the -fexceptions into the dg-options instead of having 
two separate lines?  OK either way.

Jason
Thomas Schwinge Nov. 29, 2023, 1:19 p.m. UTC | #2 
Hi!

On 2023-11-28T12:11:22-0500, Jason Merrill <jason@redhat.com> wrote:
> On 11/28/23 12:08, Thomas Schwinge wrote:
>>  // { dg-options "" }
>> +// Override any default-'-fno-exceptions':
>> +// { dg-additional-options -fexceptions }
>
> Might as well put the -fexceptions into the dg-options instead of having
> two separate lines?

The net effect is the same, but in my opinion, the intentions are clearer
in the "separate" form: 'dg-options ""' cancels the standard options, and
then 'dg-additional-options -fexceptions' adds an additional option, with
rationale.


Grüße
 Thomas


> OK either way.


-----------------
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
diff mbox series

Patch

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