On Mon, 10 Oct 2022 at 15:05, Jonathan Wakely wrote: > > On Mon, 10 Oct 2022 at 14:50, Tim Song via Libstdc++ > <libstd...@gcc.gnu.org> wrote: > > > > On Mon, Oct 10, 2022 at 8:09 AM Patrick Palka via Libstdc++ > > <libstd...@gcc.gnu.org> wrote: > > > > > > On Mon, 10 Oct 2022, Jonathan Wakely via Libstdc++ wrote: > > > > > > > Tested powerpc64le-linux. Pushed to trunk. > > > > > > > > -- >8 -- > > > > > > > > Currently we only reject std::make_signed_t<bool> but not cv bool. > > > > Similarly for std::make_unsigned_t<cv bool>. > > > > > > > > As well as making those ill-formed, this adds a requires-clause to the > > > > make_signed and make_unsigned primary templates. This makes > > > > non-integral, non-enum cases fail immediately with a clear error, rather > > > > than giving an error about __make_signed_selector<T, false, false> being > > > > incomplete. > > > > > > IIUC the requires-clause turns what was once a hard error into a SFINAE > > > error, so e.g. for > > > > > > template<class T> typename make_signed<T>::type f(int); > > > template<class T> void f(...); > > > int main() { f<void>(0); } > > > > > > the call to f would previously be rejected due to an error outside the > > > immediate context about incomplete __make_signed_selector, and now with > > > the requires-clause resolves to the second overload. I wonder if this > > > new behavior is conforming -- the examples in [structure.specifications] > > > of how to implement 'Mandates' suggest that a failed 'Mandates' should > > > yield a hard error? > > > > I'm also concerned about the inability to name make_signed<X> in a > > context that doesn't require its instantiation (e.g., > > conditional_t<is_integral_v<T>, make_signed<T>, > > type_identity<T>>::type). That seems a plausible use case, and > > breaking it doesn't seem great to me (conformance aside). > > Ah yes, that's a problem. > > We could fix it like this: > > template<typename _Tp> > struct make_unsigned; > > template<typename _Tp> > #if __cpp_concepts > requires is_integral<_Tp>::value || __is_enum(_Tp) > struct make_unsigned<_Tp> > #else > struct make_unsigned > #endif > { typedef typename __make_unsigned_selector<_Tp>::__type type; }; > > But that doesn't really improve the diagnostic much. It's simpler > just to revert the addition of the constraints.
Reverted like so. Tested powerpc64le-linux, pushed to trunk.
commit 1d2f07ed4ce028a7c1f9b18f5d959f30213545ca Author: Jonathan Wakely <jwak...@redhat.com> Date: Mon Oct 10 15:06:53 2022 libstdc++: Revert addition of constraints to make_signed/make_unsigned Constraining the primary template makes it unusable in uninstantiated contexts. libstdc++-v3/ChangeLog: * include/std/type_traits (make_signed, make_unsigned): Remove constraints on primary template. * testsuite/20_util/make_signed/requirements/typedefs_neg.cc: Undo changes to expected error in C++20 mode. * testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc: Likewise. * testsuite/24_iterators/range_access/range_access_cpp20_neg.cc: Likewise. * testsuite/20_util/make_signed/requirements/uninstantiated.cc: New test. * testsuite/20_util/make_unsigned/requirements/uninstantiated.cc: New test. diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits index 6108b98aa6a..1d7c3b04a0e 100644 --- a/libstdc++-v3/include/std/type_traits +++ b/libstdc++-v3/include/std/type_traits @@ -1802,9 +1802,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // Primary template. /// make_unsigned template<typename _Tp> -#if __cpp_concepts - requires is_integral<_Tp>::value || __is_enum(_Tp) -#endif struct make_unsigned { typedef typename __make_unsigned_selector<_Tp>::__type type; }; @@ -1937,9 +1934,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // Primary template. /// make_signed template<typename _Tp> -#if __cpp_concepts - requires is_integral<_Tp>::value || __is_enum(_Tp) -#endif struct make_signed { typedef typename __make_signed_selector<_Tp>::__type type; }; diff --git a/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs_neg.cc b/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs_neg.cc index 88b8ae887ef..451eeb8c92d 100644 --- a/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs_neg.cc +++ b/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs_neg.cc @@ -43,5 +43,4 @@ void test01() using T8 = make_signed<float>::type; // { dg-error "here" } } -// { dg-error "invalid use of incomplete type" "" { target c++17_down } 0 } -// { dg-error "constraint failure" "" { target c++20 } 0 } +// { dg-error "invalid use of incomplete type" "" { target *-*-* } 0 } diff --git a/libstdc++-v3/testsuite/20_util/make_signed/requirements/uninstantiated.cc b/libstdc++-v3/testsuite/20_util/make_signed/requirements/uninstantiated.cc new file mode 100644 index 00000000000..3facf0c595a --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/make_signed/requirements/uninstantiated.cc @@ -0,0 +1,8 @@ +// { dg-do compile { target c++11 } } +#include <type_traits> + +// Check that we can name invalid specializations, just don't instantiate them. + +using X = std::make_signed<float>; +using Y = std::make_signed<bool>; +using Z = std::make_signed<void>; diff --git a/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc b/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc index 50f15e7037c..49d520936a3 100644 --- a/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc +++ b/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc @@ -43,5 +43,4 @@ void test01() using T8 = make_unsigned<float>::type; // { dg-error "here" } } -// { dg-error "invalid use of incomplete type" "" { target c++17_down } 0 } -// { dg-error "constraint failure" "" { target c++20 } 0 } +// { dg-error "invalid use of incomplete type" "" { target *-*-* } 0 } diff --git a/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/uninstantiated.cc b/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/uninstantiated.cc new file mode 100644 index 00000000000..9b860967379 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/uninstantiated.cc @@ -0,0 +1,8 @@ +// { dg-do compile { target c++11 } } +#include <type_traits> + +// Check that we can name invalid specializations, just don't instantiate them. + +using X = std::make_unsigned<float>; +using Y = std::make_unsigned<bool>; +using Z = std::make_unsigned<void>; diff --git a/libstdc++-v3/testsuite/24_iterators/range_access/range_access_cpp20_neg.cc b/libstdc++-v3/testsuite/24_iterators/range_access/range_access_cpp20_neg.cc index 26c8ae0ee1e..c0825a58587 100644 --- a/libstdc++-v3/testsuite/24_iterators/range_access/range_access_cpp20_neg.cc +++ b/libstdc++-v3/testsuite/24_iterators/range_access/range_access_cpp20_neg.cc @@ -46,5 +46,4 @@ test03() C c; std::ssize(c); // { dg-error "no matching function" } } -// { dg-error "incomplete type .*make_signed.*S" "" { target c++17_down } 0 } -// { dg-error "constraint failure" "" { target c++20 } 0 } +// { dg-error "incomplete type .*make_signed.*S" "" { target *-*-* } 0 }