diff --git a/libstdc++-v3/doc/html/manual/api.html b/libstdc++-v3/doc/html/manual/api.html index 2ccfc07b83e5..7a4c7d9fe620 100644 --- a/libstdc++-v3/doc/html/manual/api.html +++ b/libstdc++-v3/doc/html/manual/api.html @@ -506,4 +506,7 @@ and removed in C++20: <cstdalign>, <cstdbool>, and <ctgmath>. +

+Nested result_type and argument_type removed from +std::hash specializations for C++20.

Prev Up Next
ABI Policy and Guidelines Home Backwards Compatibility
\ No newline at end of file diff --git a/libstdc++-v3/doc/xml/manual/evolution.xml b/libstdc++-v3/doc/xml/manual/evolution.xml index 6b134de0e71f..84f8ab9d2981 100644 --- a/libstdc++-v3/doc/xml/manual/evolution.xml +++ b/libstdc++-v3/doc/xml/manual/evolution.xml @@ -1145,6 +1145,11 @@ and removed in C++20: <ctgmath>. + +Nested result_type and argument_type removed from +std::hash specializations for C++20. + + diff --git a/libstdc++-v3/include/bits/functional_hash.h b/libstdc++-v3/include/bits/functional_hash.h index e7d8c6c20545..6815edeb8333 100644 --- a/libstdc++-v3/include/bits/functional_hash.h +++ b/libstdc++-v3/include/bits/functional_hash.h @@ -52,43 +52,44 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct __hash_base { +#if __cplusplus < 202002L typedef _Result result_type _GLIBCXX17_DEPRECATED; typedef _Arg argument_type _GLIBCXX17_DEPRECATED; +#endif }; +#if ! _GLIBCXX_INLINE_VERSION + // Some std::hash specializations inherit this for ABI compatibility reasons. + template struct __hash_empty_base { }; +#endif + /// Primary class template hash. template struct hash; +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc++14-extensions" template - struct __poison_hash - { - static constexpr bool __enable_hash_call = false; - private: - // Private rather than deleted to be non-trivially-copyable. - __poison_hash(__poison_hash&&); - ~__poison_hash(); - }; + constexpr bool __is_hash_enabled_for = false; template - struct __poison_hash<_Tp, __void_t()(declval<_Tp>()))>> - { - static constexpr bool __enable_hash_call = true; - }; + constexpr bool + __is_hash_enabled_for<_Tp, + __void_t()(declval<_Tp>()))>> + = true; +#pragma GCC diagnostic pop - // Helper struct for SFINAE-poisoning non-enum types. - template::value> - struct __hash_enum + // Helper struct for defining disabled specializations of std::hash. + template + struct __hash_not_enabled { - private: - // Private rather than deleted to be non-trivially-copyable. - __hash_enum(__hash_enum&&); - ~__hash_enum(); + __hash_not_enabled(__hash_not_enabled&&) = delete; + ~__hash_not_enabled() = delete; }; // Helper struct for hash with enum types. - template - struct __hash_enum<_Tp, true> : public __hash_base + template + struct __hash_enum : public __hash_base { size_t operator()(_Tp __val) const noexcept @@ -99,9 +100,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION }; /// Primary class template hash, usable for enum types only. - // Use with non-enum types still SFINAES. template - struct hash : __hash_enum<_Tp> + struct hash + : __conditional_t<__is_enum(_Tp), __hash_enum<_Tp>, __hash_not_enabled<_Tp>> { }; /// Partial specializations for pointer types. diff --git a/libstdc++-v3/include/bits/unique_ptr.h b/libstdc++-v3/include/bits/unique_ptr.h index 182173aa8571..cf24ba80a61e 100644 --- a/libstdc++-v3/include/bits/unique_ptr.h +++ b/libstdc++-v3/include/bits/unique_ptr.h @@ -1012,11 +1012,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// @} relates unique_ptr /// @cond undocumented - template::__enable_hash_call> + template struct __uniq_ptr_hash + : public __hash_base #if ! _GLIBCXX_INLINE_VERSION - : private __poison_hash<_Ptr> + , private __hash_empty_base<_Ptr> #endif { size_t @@ -1025,17 +1025,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { return hash<_Ptr>()(__u.get()); } }; - template - struct __uniq_ptr_hash<_Up, _Ptr, false> - : private __poison_hash<_Ptr> - { }; + template + using __uniq_ptr_hash_base + = __conditional_t<__is_hash_enabled_for, + __uniq_ptr_hash<_Up>, + __hash_not_enabled>; /// @endcond /// std::hash specialization for unique_ptr. template struct hash> - : public __hash_base>, - public __uniq_ptr_hash> + : public __uniq_ptr_hash_base> { }; #ifdef __glibcxx_make_unique // C++ >= 14 && HOSTED diff --git a/libstdc++-v3/include/std/optional b/libstdc++-v3/include/std/optional index 2e663d13f86a..b8eedeec7817 100644 --- a/libstdc++-v3/include/std/optional +++ b/libstdc++-v3/include/std/optional @@ -1732,10 +1732,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // Hash. - template, - bool = __poison_hash<_Up>::__enable_hash_call> - struct __optional_hash_call_base + template> + struct __optional_hash +#if ! _GLIBCXX_INLINE_VERSION + : public __hash_empty_base<_Up> +#endif { +#if __cplusplus < 202002L + using result_type [[__deprecated__]] = size_t; + using argument_type [[__deprecated__]] = optional<_Tp>; +#endif + size_t operator()(const optional<_Tp>& __t) const noexcept(noexcept(hash<_Up>{}(*__t))) @@ -1747,17 +1754,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } }; - template - struct __optional_hash_call_base<_Tp, _Up, false> {}; - template struct hash> - : private __poison_hash>, - public __optional_hash_call_base<_Tp> - { - using result_type [[__deprecated__]] = size_t; - using argument_type [[__deprecated__]] = optional<_Tp>; - }; + : public __conditional_t<__is_hash_enabled_for>, + __optional_hash<_Tp>, + __hash_not_enabled<_Tp>> + { }; template struct __is_fast_hash>> : __is_fast_hash> diff --git a/libstdc++-v3/include/std/variant b/libstdc++-v3/include/std/variant index bd0f9c3252a5..32e539980839 100644 --- a/libstdc++-v3/include/std/variant +++ b/libstdc++-v3/include/std/variant @@ -1094,7 +1094,8 @@ namespace __variant = __gen_vtable_impl<_Array_type, std::index_sequence<>>::_S_apply(); }; - template +#if ! _GLIBCXX_INLINE_VERSION + template struct _Base_dedup : public _Tp { }; template @@ -1103,7 +1104,9 @@ namespace __variant template struct _Variant_hash_base, std::index_sequence<__indices...>> - : _Base_dedup<__indices, __poison_hash>>... { }; + : _Base_dedup<__indices, __hash_empty_base>>... + { }; +#endif // Equivalent to decltype(get<_Np>(as-variant(declval<_Variant>()))) template - struct __variant_hash_call_base_impl + template + struct __variant_hash { +#if __cplusplus < 202002L + using result_type [[__deprecated__]] = size_t; + using argument_type [[__deprecated__]] = variant<_Types...>; +#endif + size_t operator()(const variant<_Types...>& __t) const noexcept((is_nothrow_invocable_v>, _Types> && ...)) @@ -2009,31 +2017,26 @@ namespace __detail::__variant return __ret; } }; - - template - struct __variant_hash_call_base_impl {}; - - template - using __variant_hash_call_base = - __variant_hash_call_base_impl<(__poison_hash>:: - __enable_hash_call &&...), _Types...>; /// @endcond template struct hash> - : private __detail::__variant::_Variant_hash_base< - variant<_Types...>, std::index_sequence_for<_Types...>>, - public __variant_hash_call_base<_Types...> - { - using result_type [[__deprecated__]] = size_t; - using argument_type [[__deprecated__]] = variant<_Types...>; - }; + : __conditional_t<(__is_hash_enabled_for> && ...), + __variant_hash<_Types...>, + __hash_not_enabled>> +#if ! _GLIBCXX_INLINE_VERSION + , __detail::__variant::_Variant_hash_base, + index_sequence_for<_Types...>> +#endif + { }; template<> struct hash { +#if __cplusplus < 202002L using result_type [[__deprecated__]] = size_t; using argument_type [[__deprecated__]] = monostate; +#endif size_t operator()(const monostate&) const noexcept diff --git a/libstdc++-v3/testsuite/20_util/optional/hash.cc b/libstdc++-v3/testsuite/20_util/optional/hash.cc index e441c87e0c95..607f56459aba 100644 --- a/libstdc++-v3/testsuite/20_util/optional/hash.cc +++ b/libstdc++-v3/testsuite/20_util/optional/hash.cc @@ -49,3 +49,36 @@ int main() std::optional x3 = x2; VERIFY(std::hash()(x) == std::hash>()(x3)); } + +// Check for presence/absence of nested types. + +template using res_type = typename std::hash::result_type; +template using arg_type = typename std::hash::argument_type; + +template +constexpr bool has_res_type = false; +template +constexpr bool has_res_type>> = true; +template +constexpr bool has_arg_type = false; +template +constexpr bool has_arg_type>> = true; + +template +constexpr bool has_no_types + = ! has_res_type> && ! has_arg_type>; + +#if __cplusplus >= 202002L +// Nested types result_type and argument_type are not present in C++20 +static_assert( has_no_types ); +static_assert( has_no_types ); +#else +// Nested types result_type and argument_type are deprecated in C++17. +using R1 = std::hash>::result_type; // { dg-warning "deprecated" "" { target c++17_only } } +using A1 = std::hash>::argument_type; // { dg-warning "deprecated" "" { target c++17_only } } +using R2 = std::hash>::result_type; // { dg-warning "deprecated" "" { target c++17_only } } +using A2 = std::hash>::argument_type; // { dg-warning "deprecated" "" { target c++17_only } } +#endif + +// Disabled specializations do not have the nested types. +static_assert( has_no_types ); diff --git a/libstdc++-v3/testsuite/20_util/optional/hash_abi.cc b/libstdc++-v3/testsuite/20_util/optional/hash_abi.cc new file mode 100644 index 000000000000..78e992c4e41d --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/optional/hash_abi.cc @@ -0,0 +1,35 @@ +// { dg-do compile { target c++17 } } + +#include + +struct S { }; // std::hash is a disabled specialization. + +template +constexpr std::size_t hash_size = sizeof(std::hash>); + +template +struct MultiHash : std::hash>... +{ }; + +#if _GLIBCXX_INLINE_VERSION +// For the unstable ABI the size should always be one. +template +constexpr bool check_hash_size = sizeof(MultiHash) == 1; +#else +// For the default ABI, each std::hash> specialization has +// a base class of type __hash_empty_base> and if +// the same type occurs more than once they must have unique addresses. +template +constexpr bool check_hash_size = sizeof(MultiHash) == Size; +#endif + +static_assert( check_hash_size<1, int> ); +static_assert( check_hash_size<1, int, long, double> ); +static_assert( check_hash_size<2, int, const int> ); +static_assert( check_hash_size<2, int, long, const int> ); + +static_assert( check_hash_size<1, S> ); +static_assert( check_hash_size<1, int, S> ); +static_assert( check_hash_size<2, int, S, const int> ); +static_assert( check_hash_size<2, int, S, const int, const S> ); +static_assert( check_hash_size<2, int, S, const S, const int> ); diff --git a/libstdc++-v3/testsuite/20_util/unique_ptr/hash/abi.cc b/libstdc++-v3/testsuite/20_util/unique_ptr/hash/abi.cc new file mode 100644 index 000000000000..9c0a32c49c92 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/unique_ptr/hash/abi.cc @@ -0,0 +1,64 @@ +// { dg-do compile { target c++17 } } + +#include + +struct S { }; // std::hash is a disabled specialization. + +template> +constexpr std::size_t hash_size = sizeof(std::hash>); + +template +struct MultiHash : std::hash>... +{ }; + +#if _GLIBCXX_INLINE_VERSION +// For the unstable ABI the size should always be one. +template +constexpr bool check_hash_size = sizeof(MultiHash) == 1; +#else +// For the default ABI, each std::hash> specialization +// has a base class of type __hash_empty_base and if +// the same type occurs more than once they must have unique addresses. +template +constexpr bool check_hash_size = sizeof(MultiHash) == Size; +#endif + +// All these types have distinct D::pointer types, so no duplicate base classes +static_assert( check_hash_size<1, int>, "" ); +static_assert( check_hash_size<1, int, long, double>, "" ); +static_assert( check_hash_size<1, int, const int>, "" ); +static_assert( check_hash_size<1, int, long, const int>, "" ); +// Likewise for these disabled specializations: +static_assert( check_hash_size<1, S>, "" ); +static_assert( check_hash_size<1, int, S>, "" ); +static_assert( check_hash_size<1, int, S, const int>, "" ); +static_assert( check_hash_size<1, int, S, const int, const S>, "" ); +static_assert( check_hash_size<1, int, S, const S, const int>, "" ); + +// But this has two base classes of type __hash_empty_base: +static_assert( check_hash_size<2, int, int[]>, "" ); +static_assert( check_hash_size<2, int, int[], const int>, "" ); +// And this has two base classes of type __hash_not_enabled: +static_assert( check_hash_size<2, S, S[]>, "" ); +static_assert( check_hash_size<2, S, S[], const S>, "" ); + +struct Del : std::default_delete { }; +using P = std::unique_ptr; +using PD = std::unique_ptr; +using PC = std::unique_ptr>; +using PA = std::unique_ptr; +struct HashClash +: std::hash

, std::hash, std::hash, std::hash +{ }; +#if _GLIBCXX_INLINE_VERSION +static_assert(sizeof(HashClash) == 1, "No duplicate bases for unstable ABI"); +#else +static_assert(sizeof(HashClash) == 4, "four __hash_empty_base bases"); +#endif + +struct Del2 : std::default_delete { using pointer = const int*; }; +using PD2 = std::unique_ptr; +struct Hash2 +: std::hash, std::hash +{ }; +static_assert(sizeof(Hash2) == 1, "No duplicate bases"); diff --git a/libstdc++-v3/testsuite/20_util/unique_ptr/hash/types.cc b/libstdc++-v3/testsuite/20_util/unique_ptr/hash/types.cc new file mode 100644 index 000000000000..dbe3d8084fe8 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/unique_ptr/hash/types.cc @@ -0,0 +1,53 @@ +// { dg-do compile { target c++11 } } + +#include + + +// Check for presence/absence of nested types. + +template using res_type = typename std::hash::result_type; +template using arg_type = typename std::hash::argument_type; + +template +constexpr bool +has_res_type(...) +{ return false; } + +template +constexpr typename std::is_void>::value_type // i.e. bool +has_res_type() +{ return true; } + +template +constexpr bool +has_arg_type(...) +{ return false; } + +template +constexpr typename std::is_void>::value_type // i.e. bool +has_arg_type() +{ return true; } + +template +constexpr bool +has_no_types() +{ return ! has_res_type() && ! has_arg_type(); } + +#if __cplusplus >= 202002L +// Nested types result_type and argument_type are not present in C++20 +static_assert( has_no_types>() ); +static_assert( has_no_types>() ); +#else +// Nested types result_type and argument_type are deprecated in C++17. +using R1 = std::hash>::result_type; // { dg-warning "deprecated" "" { target c++17_only } } +using A1 = std::hash>::argument_type; // { dg-warning "deprecated" "" { target c++17_only } } +#endif + +struct S { }; +template<> struct std::hash // disabled specialization +{ + hash(hash&&) = delete; + ~hash() = delete; +}; +// Disabled specializations do not have the nested types. +static_assert( has_no_types>(), "disabled specialization" ); diff --git a/libstdc++-v3/testsuite/20_util/variant/hash.cc b/libstdc++-v3/testsuite/20_util/variant/hash.cc index f3ab4e0d9cab..52fc759fc34e 100644 --- a/libstdc++-v3/testsuite/20_util/variant/hash.cc +++ b/libstdc++-v3/testsuite/20_util/variant/hash.cc @@ -48,3 +48,37 @@ int main() std::variant x2 = 42; VERIFY(std::hash()(x) == std::hash>()(x2)); } + +// Check for presence/absence of nested types. + +template using res_type = typename std::hash::result_type; +template using arg_type = typename std::hash::argument_type; + +template +constexpr bool has_res_type = false; +template +constexpr bool has_res_type>> = true; +template +constexpr bool has_arg_type = false; +template +constexpr bool has_arg_type>> = true; + +template +constexpr bool has_no_types + = ! has_res_type> && ! has_arg_type>; + +#if __cplusplus >= 202002L +// Nested types result_type and argument_type are not present in C++20 +static_assert( has_no_types ); +static_assert( has_no_types ); +#else +// Nested types result_type and argument_type are deprecated in C++17. +using R1 = std::hash>::result_type; // { dg-warning "deprecated" "" { target c++17_only } } +using A1 = std::hash>::argument_type; // { dg-warning "deprecated" "" { target c++17_only } } +using R2 = std::hash>::result_type; // { dg-warning "deprecated" "" { target c++17_only } } +using A2 = std::hash>::argument_type; // { dg-warning "deprecated" "" { target c++17_only } } +#endif + +// Disabled specializations do not have the nested types. +static_assert( has_no_types ); +static_assert( has_no_types ); diff --git a/libstdc++-v3/testsuite/20_util/variant/hash_abi.cc b/libstdc++-v3/testsuite/20_util/variant/hash_abi.cc new file mode 100644 index 000000000000..19cf72b54de6 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/variant/hash_abi.cc @@ -0,0 +1,48 @@ +// { dg-options "-Wdeprecated" } +// { dg-do compile { target c++17 } } + +#include + +struct S { }; // std::hash is a disabled specialization. + +// Test std::hash size + +template +constexpr std::size_t hash_size = sizeof(std::hash>); + +#if _GLIBCXX_INLINE_VERSION +// For the unstable ABI the size should always be one. +template +constexpr bool check_hash_size = hash_size == 1; +#else +// For the default ABI, the std::hash specialization has sizeof...(Ts) +// base classes of types __hash_empty_base>... and if +// the same type occurs more than once they must have unique addresses. +template +constexpr bool check_hash_size = hash_size == Size; +#endif + +static_assert( check_hash_size<1, int> ); +static_assert( check_hash_size<1, int, long, double> ); +static_assert( check_hash_size<2, int, long, int> ); +static_assert( check_hash_size<2, int, long, const int> ); +static_assert( check_hash_size<3, int, int, const int> ); + +static_assert( check_hash_size<1, S> ); +static_assert( check_hash_size<1, int, S> ); +static_assert( check_hash_size<2, int, S, int> ); +static_assert( check_hash_size<2, int, S, int, S> ); +static_assert( check_hash_size<2, int, S, S, int> ); +static_assert( check_hash_size<3, int, S, S, int, S> ); + +// For the default ABI this has two __hash_empty_base base classes, +// for the unstable ABI it does not. +struct H +: std::hash>, std::hash> +{ }; +static_assert( sizeof(H) == hash_size ); +// Likewise, even though one of the base classes is a disabled specialization. +struct HX +: std::hash>, std::hash> +{ }; +static_assert( sizeof(HX) == hash_size );