From: Jonathan Wakely Date: Wed, 3 Nov 2021 00:21:38 +0000 (+0000) Subject: libstdc++: Optimize std::variant traits and improve diagnostics X-Git-Tag: basepoints/gcc-13~3424 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=30ab6d9e435dd3158d971cf9353eec8009955cb3;p=thirdparty%2Fgcc.git libstdc++: Optimize std::variant traits and improve diagnostics By defining additional partial specializations of _Nth_type we can reduce the number of recursive instantiations needed to get from N to 0. We can also use _Nth_type in variant_alternative, to take advantage of that new optimization. By adding a static_assert to variant_alternative we get a nicer error than 'invalid use of incomplete type'. By defining partial specializations of std::variant_size_v for the common case we can avoid instantiating the std::variant_size class template. The __tuple_count class template and __tuple_count_v variable template can be simplified to a single variable template, __count. By adding a deleted constructor to the _Variant_union primary template we can (very slightly) improve diagnostics for invalid attempts to construct a std::variant with an out-of-range index. Instead of a confusing error about "too many initializers for ..." we get a call to a deleted function. By using _Nth_type instead of variant_alternative (for cv-unqualified variant types) we avoid instantiating variant_alternative. By adding deleted overloads of variant::emplace we get better diagnostics for emplace or emplace. Instead of getting errors explaining why each of the four overloads wasn't valid, we just get one error about calling a deleted function. libstdc++-v3/ChangeLog: * include/std/variant (_Nth_type): Define partial specializations to reduce number of instantiations. (variant_size_v): Define partial specializations to avoid instantiations. (variant_alternative): Use _Nth_type. Add static assert. (__tuple_count, __tuple_count_v): Replace with ... (__count): New variable template. (_Variant_union): Add deleted constructor. (variant::__to_type): Use _Nth_type. (variant::emplace): Use _Nth_type. Add deleted overloads for invalid types and indices. --- diff --git a/libstdc++-v3/include/std/variant b/libstdc++-v3/include/std/variant index 63468af7012f..dc3d032c543a 100644 --- a/libstdc++-v3/include/std/variant +++ b/libstdc++-v3/include/std/variant @@ -61,13 +61,40 @@ namespace __variant template struct _Nth_type; - template - struct _Nth_type<_Np, _First, _Rest...> - : _Nth_type<_Np-1, _Rest...> { }; + template + struct _Nth_type<0, _Tp0, _Rest...> + { using type = _Tp0; }; + + template + struct _Nth_type<1, _Tp0, _Tp1, _Rest...> + { using type = _Tp1; }; + + template + struct _Nth_type<2, _Tp0, _Tp1, _Tp2, _Rest...> + { using type = _Tp2; }; + + template +#if __cpp_concepts + requires (_Np >= 3) +#endif + struct _Nth_type<_Np, _Tp0, _Tp1, _Tp2, _Rest...> + : _Nth_type<_Np - 3, _Rest...> + { }; - template - struct _Nth_type<0, _First, _Rest...> - { using type = _First; }; +#if ! __cpp_concepts // Need additional specializations to avoid ambiguities. + template + struct _Nth_type<0, _Tp0, _Tp1, _Rest...> + { using type = _Tp0; }; + + template + struct _Nth_type<0, _Tp0, _Tp1, _Tp2, _Rest...> + { using type = _Tp0; }; + + template + struct _Nth_type<1, _Tp0, _Tp1, _Tp2, _Rest...> + { using type = _Tp1; }; +#endif } // namespace __variant } // namespace __detail @@ -102,16 +129,25 @@ namespace __variant template inline constexpr size_t variant_size_v = variant_size<_Variant>::value; + template + inline constexpr size_t + variant_size_v> = sizeof...(_Types); + + template + inline constexpr size_t + variant_size_v> = sizeof...(_Types); + template struct variant_alternative; - template - struct variant_alternative<_Np, variant<_First, _Rest...>> - : variant_alternative<_Np-1, variant<_Rest...>> {}; + template + struct variant_alternative<_Np, variant<_Types...>> + { + static_assert(_Np < sizeof...(_Types)); - template - struct variant_alternative<0, variant<_First, _Rest...>> - { using type = _First; }; + using type + = typename __detail::__variant::_Nth_type<_Np, _Types...>::type; + }; template using variant_alternative_t = @@ -390,7 +426,13 @@ namespace __variant // Defines members and ctors. template - union _Variadic_union { }; + union _Variadic_union + { + _Variadic_union() = default; + + template + _Variadic_union(in_place_index_t<_Np>, _Args&&...) = delete; + }; template union _Variadic_union<_First, _Rest...> @@ -758,28 +800,21 @@ namespace __variant _Variant_base& operator=(_Variant_base&&) = default; }; - // For how many times does _Tp appear in _Tuple? - template - struct __tuple_count; + // How many times does _Tp appear in _Types? + template + inline constexpr size_t __count = 0; - template - inline constexpr size_t __tuple_count_v = - __tuple_count<_Tp, _Tuple>::value; + template + inline constexpr size_t __count<_Tp, _Up, _Types...> + = __count<_Tp, _Types...>; template - struct __tuple_count<_Tp, tuple<_Types...>> - : integral_constant { }; - - template - struct __tuple_count<_Tp, tuple<_First, _Rest...>> - : integral_constant< - size_t, - __tuple_count_v<_Tp, tuple<_Rest...>> + is_same_v<_Tp, _First>> { }; + inline constexpr size_t __count<_Tp, _Tp, _Types...> + = 1 + __count<_Tp, _Types...>; // TODO: Reuse this in ? template - inline constexpr bool __exactly_once = - __tuple_count_v<_Tp, tuple<_Types...>> == 1; + inline constexpr bool __exactly_once = __count<_Tp, _Types...> == 1; // Helper used to check for valid conversions that don't involve narrowing. template struct _Arr { _Ti _M_x[1]; }; @@ -1411,7 +1446,8 @@ namespace __variant = __detail::__variant::__accepted_index<_Tp, variant>::value; template> - using __to_type = variant_alternative_t<_Np, variant>; + using __to_type + = typename __detail::__variant::_Nth_type<_Np, _Types...>::type; template>> using __accepted_type = __to_type<__accepted_index<_Tp>>; @@ -1543,15 +1579,12 @@ namespace __variant template _GLIBCXX20_CONSTEXPR - enable_if_t, - _Args...>, - variant_alternative_t<_Np, variant>&> + enable_if_t, _Args...>, + __to_type<_Np>&> emplace(_Args&&... __args) { - static_assert(_Np < sizeof...(_Types), - "The index must be in [0, number of alternatives)"); - using type = variant_alternative_t<_Np, variant>; namespace __variant = std::__detail::__variant; + using type = typename __variant::_Nth_type<_Np, _Types...>::type; // Provide the strong exception-safety guarantee when possible, // to avoid becoming valueless. if constexpr (is_nothrow_constructible_v) @@ -1590,15 +1623,13 @@ namespace __variant template _GLIBCXX20_CONSTEXPR - enable_if_t, + enable_if_t, initializer_list<_Up>&, _Args...>, - variant_alternative_t<_Np, variant>&> + __to_type<_Np>&> emplace(initializer_list<_Up> __il, _Args&&... __args) { - static_assert(_Np < sizeof...(_Types), - "The index must be in [0, number of alternatives)"); - using type = variant_alternative_t<_Np, variant>; namespace __variant = std::__detail::__variant; + using type = typename __variant::_Nth_type<_Np, _Types...>::type; // Provide the strong exception-safety guarantee when possible, // to avoid becoming valueless. if constexpr (is_nothrow_constructible_v(*this); } + template + enable_if_t emplace(_Args&&...) = delete; + + template + enable_if_t> emplace(_Args&&...) = delete; + constexpr bool valueless_by_exception() const noexcept { return !this->_M_valid(); }