aboutsummaryrefslogtreecommitdiff
path: root/libstdc++-v3/include/std/variant
AgeCommit message (Collapse)AuthorFilesLines
2025-07-14libstdc++: Add comments to deleted std::swap overloads for LWG 2766Jonathan Wakely1-0/+2
We pre-emptively implemented part of LWG 2766, which still hasn't been approved. Add comments to the deleted swap overloads saying why they're there, because the standard doesn't require them. libstdc++-v3/ChangeLog: * include/bits/stl_pair.h (swap): Add comment to deleted overload. * include/bits/unique_ptr.h (swap): Likewise. * include/std/array (swap): Likewise. * include/std/optional (swap): Likewise. * include/std/tuple (swap): Likewise. * include/std/variant (swap): Likewise. * testsuite/23_containers/array/tuple_interface/get_neg.cc: Adjust dg-error line numbers.
2025-01-02Update copyright years.Jakub Jelinek1-1/+1
2024-11-30libstdc++: Move std::monostate to <utility> for C++26 (P0472R2)Jonathan Wakely1-30/+1
Another C++26 paper just approved in Wrocław. The std::monostate class is defined in <variant> since C++17, but for C++26 it should also be available in <utility>. libstdc++-v3/ChangeLog: * include/Makefile.am: Add bits/monostate.h. * include/Makefile.in: Regenerate. * include/std/utility: Include <bits/monostate.h>. * include/std/variant (monostate, hash<monostate>): Move definitions to ... * include/bits/monostate.h: New file. * testsuite/20_util/headers/utility/synopsis.cc: Add monostate and hash<monostate> declarations. * testsuite/20_util/monostate/requirements.cc: New test.
2024-11-13libstdc++: Refactor std::hash specializationsJonathan Wakely1-19/+22
This attempts to simplify and clean up our std::hash code. The primary benefit is improved diagnostics for users when they do something wrong involving std::hash or unordered containers. An additional benefit is that for the unstable ABI (--enable-symvers=gnu-versioned-namespace) we can reduce the memory footprint of several std::hash specializations. In the current design, __hash_enum is a base class of the std::hash primary template, but the partial specialization of __hash_enum for non-enum types is disabled. This means that if a user forgets to specialize std::hash for their class type (or forgets to use a custom hash function for unordered containers) they get error messages about std::__hash_enum not being constructible. This is confusing when there is no enum type involved: why should users care about __hash_enum not being constructible if they're not trying to hash enums? This change makes the std::hash primary template only derive from __hash_enum when the template argument type is an enum. Otherwise, it derives directly from a new class template, __hash_not_enabled. This new class template defines the deleted members that cause a given std::hash specialization to be a disabled specialization (as per P0513R0). Now when users try to use a disabled specialization, they get more descriptive errors that mention __hash_not_enabled instead of __hash_enum. Additionally, adjust __hash_base to remove the deprecated result_type and argument_type typedefs for C++20 and later. In the current code we use a __poison_hash base class in the std::hash specializations for std::unique_ptr, std::optional, and std::variant. The primary template of __poison_hash has deleted special members, which is used to conditionally disable the derived std::hash specialization. This can also result in confusing diagnostics, because seeing "poison" in an enabled specialization is misleading. Only some uses of __poison_hash actually "poison" anything, i.e. cause a specialization to be disabled. In other cases it's just an empty base class that does nothing. This change removes __poison_hash and changes the std::hash specializations that were using it to conditionally derive from __hash_not_enabled instead. When the std::hash specialization is enabled, there is no more __poison_hash base class. However, to preserve the ABI properties of those std::hash specializations, we need to replace __poison_hash with some other empty base class. This is needed because in the current code std::hash<std::variant<int, const int>> has two __poison_hash<int> base classes, which must have unique addresses, so sizeof(std::hash<std::variant<int, const int>>) == 2. To preserve this unfortunate property, a new __hash_empty_base class is used as a base class to re-introduce du0plicate base classes that increase the class size. For the unstable ABI we don't use __hash_empty_base so the std::hash<std::variant<T...>> specializations are always size 1, and the class hierarchy is much simpler so will compile faster. Additionally, remove the result_type and argument_type typedefs from all disabled specializations of std::hash for std::unique_ptr, std::optional, and std::variant. Those typedefs are useless for disabled specializations, and although the standard doesn't say they must *not* be present for disabled specializations, it certainly only requires them for enabled specializations. Finally, for C++20 the typedefs are also removed from enabled specializations of std::hash for std::unique_ptr, std::optional, and std::variant. libstdc++-v3/ChangeLog: * doc/xml/manual/evolution.xml: Document removal of nested types from std::hash specializations. * doc/html/manual/api.html: Regenerate. * include/bits/functional_hash.h (__hash_base): Remove deprecated nested types for C++20. (__hash_empty_base): Define new class template. (__is_hash_enabled_for): Define new variable template. (__poison_hash): Remove. (__hash_not_enabled): Define new class template. (__hash_enum): Remove partial specialization for non-enums. (hash): Derive from __hash_not_enabled for non-enums, instead of __hash_enum. * include/bits/unique_ptr.h (__uniq_ptr_hash): Derive from __hash_base. Conditionally derive from __hash_empty_base. (__uniq_ptr_hash<>): Remove disabled specialization. (hash): Do not derive from __hash_base unconditionally. Conditionally derive from either __uniq_ptr_hash or __hash_not_enabled. * include/std/optional (__optional_hash_call_base): Remove. (__optional_hash): Define new class template. (hash): Derive from either (hash): Conditionally derive from either __optional_hash or __hash_not_enabled. Remove nested typedefs. * include/std/variant (_Base_dedup): Replace __poison_hash with __hash_empty_base. (__variant_hash_call_base_impl): Remove. (__variant_hash): Define new class template. (hash): Conditionally derive from either __variant_hash or __hash_not_enabled. Remove nested typedefs. * testsuite/20_util/optional/hash.cc: Check whether nested types are present. * testsuite/20_util/variant/hash.cc: Likewise. * testsuite/20_util/optional/hash_abi.cc: New test. * testsuite/20_util/unique_ptr/hash/abi.cc: New test. * testsuite/20_util/unique_ptr/hash/types.cc: New test. * testsuite/20_util/variant/hash_abi.cc: New test.
2024-10-24libstdc++: Simplify std::__throw_bad_variant_accessJonathan Wakely1-17/+15
This removes the overload of __throw_bad_variant_access that must be called with a string literal. This avoids a potential source of undefined behaviour if that function got misused. The other overload that takes a bool parameter can be adjusted to take an integer index selecting one of the four possible string literals to use, ensuring that the std::bad_variant_access constructor is only called with those literals. Passing an index outside the range [0,3] is bogus, but will still select a valid string literal and avoid undefined behaviour. libstdc++-v3/ChangeLog: * include/std/variant (__throw_bad_variant_access(unsigned)): Define new function as inline friend, with namespace-scope declaration using noreturn attribute. (__throw_bad_variant_access(const char*)): Remove. (__throw_bad_variant_access(bool)): Remove. (visit, visit<R>): Adjust calls to __throw_bad_variant_access. Reviewed-by: Patrick Palka <ppalka@redhat.com>
2024-09-25libstdc++: #ifdef out #pragma GCC system_headerJason Merrill1-0/+2
In r15-3714-gd3a7302ec5985a I added -Wsystem-headers to the libstdc++ build flags to help catch problems in the library. This patch takes a different approach, of disabling the #pragma system_header unless _GLIBCXX_SYSHDR is defined. As a result, the testsuites will treat them as non-system-headers to get better warning coverage during regression testing of both gcc and libstdc++, not just when building the library. My rationale for the #ifdef instead of just removing the #pragma is the three G++ tests that want to test libstdc++ system header behavior, so we need a way to select it. This doesn't affect installed libraries, as they get their system-header status from the lookup path. But testsuite_flags --build-includes gives -I directives rather than -isystem. This patch doesn't change the headers in config/ because I'm not compiling with most of them, so won't see any warnings that need fixing. Adjusting them could happen later, or we can not bother. libstdc++-v3/ChangeLog: * acinclude.m4 (WARN_FLAGS): Remove -Wsystem-headers. * configure: Regenerate. * include/bits/algorithmfwd.h: #ifdef out #pragma GCC system_header. * include/bits/atomic_base.h * include/bits/atomic_futex.h * include/bits/atomic_timed_wait.h * include/bits/atomic_wait.h * include/bits/basic_ios.h * include/bits/basic_string.h * include/bits/boost_concept_check.h * include/bits/char_traits.h * include/bits/charconv.h * include/bits/chrono.h * include/bits/chrono_io.h * include/bits/codecvt.h * include/bits/concept_check.h * include/bits/cpp_type_traits.h * include/bits/elements_of.h * include/bits/enable_special_members.h * include/bits/erase_if.h * include/bits/forward_list.h * include/bits/functional_hash.h * include/bits/gslice.h * include/bits/gslice_array.h * include/bits/hashtable.h * include/bits/indirect_array.h * include/bits/invoke.h * include/bits/ios_base.h * include/bits/iterator_concepts.h * include/bits/locale_classes.h * include/bits/locale_facets.h * include/bits/locale_facets_nonio.h * include/bits/localefwd.h * include/bits/mask_array.h * include/bits/max_size_type.h * include/bits/memory_resource.h * include/bits/memoryfwd.h * include/bits/move_only_function.h * include/bits/node_handle.h * include/bits/ostream_insert.h * include/bits/out_ptr.h * include/bits/parse_numbers.h * include/bits/postypes.h * include/bits/quoted_string.h * include/bits/range_access.h * include/bits/ranges_base.h * include/bits/refwrap.h * include/bits/sat_arith.h * include/bits/semaphore_base.h * include/bits/slice_array.h * include/bits/std_abs.h * include/bits/std_function.h * include/bits/std_mutex.h * include/bits/std_thread.h * include/bits/stl_iterator_base_funcs.h * include/bits/stl_iterator_base_types.h * include/bits/stl_tree.h * include/bits/stream_iterator.h * include/bits/streambuf_iterator.h * include/bits/stringfwd.h * include/bits/this_thread_sleep.h * include/bits/unique_lock.h * include/bits/uses_allocator_args.h * include/bits/utility.h * include/bits/valarray_after.h * include/bits/valarray_array.h * include/bits/valarray_before.h * include/bits/version.h * include/c_compatibility/fenv.h * include/c_compatibility/inttypes.h * include/c_compatibility/stdint.h * include/decimal/decimal.h * include/experimental/bits/net.h * include/experimental/bits/shared_ptr.h * include/ext/aligned_buffer.h * include/ext/alloc_traits.h * include/ext/atomicity.h * include/ext/concurrence.h * include/ext/numeric_traits.h * include/ext/pod_char_traits.h * include/ext/pointer.h * include/ext/stdio_filebuf.h * include/ext/stdio_sync_filebuf.h * include/ext/string_conversions.h * include/ext/type_traits.h * include/ext/vstring.h * include/ext/vstring_fwd.h * include/ext/vstring_util.h * include/parallel/algorithmfwd.h * include/parallel/numericfwd.h * include/tr1/functional_hash.h * include/tr1/hashtable.h * include/tr1/random.h * libsupc++/exception.h * libsupc++/hash_bytes.h * include/bits/basic_ios.tcc * include/bits/basic_string.tcc * include/bits/fstream.tcc * include/bits/istream.tcc * include/bits/locale_classes.tcc * include/bits/locale_facets.tcc * include/bits/locale_facets_nonio.tcc * include/bits/ostream.tcc * include/bits/sstream.tcc * include/bits/streambuf.tcc * include/bits/string_view.tcc * include/bits/version.tpl * include/experimental/bits/string_view.tcc * include/ext/pb_ds/detail/resize_policy/hash_prime_size_policy_imp.hpp * include/ext/random.tcc * include/ext/vstring.tcc * include/tr2/bool_set.tcc * include/tr2/dynamic_bitset.tcc * include/bits/c++config * include/c/cassert * include/c/cctype * include/c/cerrno * include/c/cfloat * include/c/ciso646 * include/c/climits * include/c/clocale * include/c/cmath * include/c/csetjmp * include/c/csignal * include/c/cstdarg * include/c/cstddef * include/c/cstdio * include/c/cstdlib * include/c/cstring * include/c/ctime * include/c/cuchar * include/c/cwchar * include/c/cwctype * include/c_global/cassert * include/c_global/ccomplex * include/c_global/cctype * include/c_global/cerrno * include/c_global/cfenv * include/c_global/cfloat * include/c_global/cinttypes * include/c_global/ciso646 * include/c_global/climits * include/c_global/clocale * include/c_global/cmath * include/c_global/csetjmp * include/c_global/csignal * include/c_global/cstdalign * include/c_global/cstdarg * include/c_global/cstdbool * include/c_global/cstddef * include/c_global/cstdint * include/c_global/cstdio * include/c_global/cstdlib * include/c_global/cstring * include/c_global/ctgmath * include/c_global/ctime * include/c_global/cuchar * include/c_global/cwchar * include/c_global/cwctype * include/c_std/cassert * include/c_std/cctype * include/c_std/cerrno * include/c_std/cfloat * include/c_std/ciso646 * include/c_std/climits * include/c_std/clocale * include/c_std/cmath * include/c_std/csetjmp * include/c_std/csignal * include/c_std/cstdarg * include/c_std/cstddef * include/c_std/cstdio * include/c_std/cstdlib * include/c_std/cstring * include/c_std/ctime * include/c_std/cuchar * include/c_std/cwchar * include/c_std/cwctype * include/debug/array * include/debug/bitset * include/debug/deque * include/debug/forward_list * include/debug/list * include/debug/map * include/debug/set * include/debug/string * include/debug/unordered_map * include/debug/unordered_set * include/debug/vector * include/decimal/decimal * include/experimental/algorithm * include/experimental/any * include/experimental/array * include/experimental/buffer * include/experimental/chrono * include/experimental/contract * include/experimental/deque * include/experimental/executor * include/experimental/filesystem * include/experimental/forward_list * include/experimental/functional * include/experimental/internet * include/experimental/io_context * include/experimental/iterator * include/experimental/list * include/experimental/map * include/experimental/memory * include/experimental/memory_resource * include/experimental/net * include/experimental/netfwd * include/experimental/numeric * include/experimental/propagate_const * include/experimental/ratio * include/experimental/regex * include/experimental/scope * include/experimental/set * include/experimental/socket * include/experimental/string * include/experimental/string_view * include/experimental/synchronized_value * include/experimental/system_error * include/experimental/timer * include/experimental/tuple * include/experimental/type_traits * include/experimental/unordered_map * include/experimental/unordered_set * include/experimental/vector * include/ext/algorithm * include/ext/cmath * include/ext/functional * include/ext/iterator * include/ext/memory * include/ext/numeric * include/ext/random * include/ext/rb_tree * include/ext/rope * include/parallel/algorithm * include/std/algorithm * include/std/any * include/std/array * include/std/atomic * include/std/barrier * include/std/bit * include/std/bitset * include/std/charconv * include/std/chrono * include/std/codecvt * include/std/complex * include/std/concepts * include/std/condition_variable * include/std/coroutine * include/std/deque * include/std/execution * include/std/expected * include/std/filesystem * include/std/format * include/std/forward_list * include/std/fstream * include/std/functional * include/std/future * include/std/generator * include/std/iomanip * include/std/ios * include/std/iosfwd * include/std/iostream * include/std/istream * include/std/iterator * include/std/latch * include/std/limits * include/std/list * include/std/locale * include/std/map * include/std/memory * include/std/memory_resource * include/std/mutex * include/std/numbers * include/std/numeric * include/std/optional * include/std/ostream * include/std/print * include/std/queue * include/std/random * include/std/ranges * include/std/ratio * include/std/regex * include/std/scoped_allocator * include/std/semaphore * include/std/set * include/std/shared_mutex * include/std/span * include/std/spanstream * include/std/sstream * include/std/stack * include/std/stacktrace * include/std/stdexcept * include/std/streambuf * include/std/string * include/std/string_view * include/std/syncstream * include/std/system_error * include/std/text_encoding * include/std/thread * include/std/tuple * include/std/type_traits * include/std/typeindex * include/std/unordered_map * include/std/unordered_set * include/std/utility * include/std/valarray * include/std/variant * include/std/vector * include/std/version * include/tr1/array * include/tr1/cfenv * include/tr1/cinttypes * include/tr1/cmath * include/tr1/complex * include/tr1/cstdbool * include/tr1/cstdint * include/tr1/cstdio * include/tr1/cstdlib * include/tr1/cwchar * include/tr1/cwctype * include/tr1/functional * include/tr1/memory * include/tr1/random * include/tr1/regex * include/tr1/tuple * include/tr1/type_traits * include/tr1/unordered_map * include/tr1/unordered_set * include/tr1/utility * include/tr2/bool_set * include/tr2/dynamic_bitset * include/tr2/type_traits * libsupc++/atomic_lockfree_defines.h * libsupc++/compare * libsupc++/cxxabi.h * libsupc++/cxxabi_forced.h * libsupc++/cxxabi_init_exception.h * libsupc++/exception * libsupc++/initializer_list * libsupc++/new * libsupc++/typeinfo: Likewise. * testsuite/20_util/ratio/operations/ops_overflow_neg.cc * testsuite/23_containers/array/tuple_interface/get_neg.cc * testsuite/23_containers/vector/cons/destructible_debug_neg.cc * testsuite/24_iterators/operations/prev_neg.cc * testsuite/ext/type_traits/add_unsigned_floating_neg.cc * testsuite/ext/type_traits/add_unsigned_integer_neg.cc * testsuite/ext/type_traits/remove_unsigned_floating_neg.cc * testsuite/ext/type_traits/remove_unsigned_integer_neg.cc: Adjust line numbers. gcc/testsuite/ChangeLog * g++.dg/analyzer/fanalyzer-show-events-in-system-headers-default.C * g++.dg/analyzer/fanalyzer-show-events-in-system-headers-no.C * g++.dg/diagnostic/disable.C: #define _GLIBCXX_SYSHDR.
2024-08-23libstdc++: Simplify C++20 implementation of std::variantJonathan Wakely1-46/+37
For C++20 the __detail::__variant::_Uninitialized primary template can be used for all types, because _Variant_union can have a non-trivially destructible union member in C++20, and the constrained user-provided destructor will ensure we don't destroy inactive objects. Since we always use the primary template for C++20, we don't need the _Uninitialized::_M_get accessors to abstract the difference between the primary template and the partial specialization. That allows us to simplify __get_n for C++20 too. Also improve the comments that explain the uses of _Uninitialized and when/why _Variant_union needs a user-provided destructor. libstdc++-v3/ChangeLog: * include/std/variant [C++20] (_Uninitialized): Always use the primary template. [C++20] (__get_n): Access the _M_storage member directly.
2024-08-21libstdc++: Fix std::variant to reject array types [PR116381]Jonathan Wakely1-4/+2
libstdc++-v3/ChangeLog: PR libstdc++/116381 * include/std/variant (variant): Fix conditions for static_assert to match the spec. * testsuite/20_util/variant/types_neg.cc: New test.
2024-08-01libstdc++: Remove unused helper traitsJonathan Wakely1-7/+0
These are not used anywhere, we have more efficient variable templates for them instead. They're not documented as extensions, and are easy for users to write if they need them. libstdc++-v3/ChangeLog: * include/bits/utility.h (__is_in_place_type): Remove. * include/std/variant (__is_in_place_tag): Remove.
2024-07-31libstdc++: Define C++26 member visit for std::variant [PR110356]Jonathan Wakely1-0/+46
Implement the std::variant changes from P2637R3. libstdc++-v3/ChangeLog: PR libstdc++/110356 * include/bits/version.def (variant): Update for C++26. * include/bits/version.h: Regenerate. * include/std/variant (variant::visit): New member functions. * testsuite/20_util/variant/visit.cc: Check second alternative. * testsuite/20_util/variant/visit_member.cc: New test.
2024-07-06libstdc++: Use reserved form of [[__likely__]] in <variant>Jonathan Wakely1-1/+1
We should not use [[unlikely]] before C++20, so use [[__unlikely__]] instead. libstdc++-v3/ChangeLog: * include/std/variant (_Variant_storage::_M_reset): Use __unlikely__ form of attribute instead of unlikely.
2024-06-07[libstdc++] drop workaround for clang<=7Alexandre Oliva1-5/+0
In response to a request in the review of the patch that introduced _GLIBCXX_CLANG, this patch removes from std/variant an obsolete workaround for clang 7-. for libstdc++-v3/ChangeLog * include/std/variant: Drop obsolete workaround.
2024-06-05[libstdc++] add _GLIBCXX_CLANG to workaround predefined __clang__Alexandre Oliva1-1/+1
A proprietary embedded operating system that uses clang as its primary compiler ships headers that require __clang__ to be defined. Defining that macro causes libstdc++ to adopt workarounds that work for clang but that break for GCC. So, introduce a _GLIBCXX_CLANG macro, and a convention to test for it rather than for __clang__, so that a GCC variant that adds -D__clang__ to satisfy system headers can also -D_GLIBCXX_CLANG=0 to avoid workarounds that are not meant for GCC. I've left fast_float and ryu files alone, their tests for __clang__ don't seem to be harmful for GCC, they don't include bits/c++config, and patching such third-party files would just make trouble for updating them without visible benefit. pstl_config.h, though also imported, required adjustment. for libstdc++-v3/ChangeLog * include/bits/c++config (_GLIBCXX_CLANG): Define or undefine. * include/bits/locale_facets_nonio.tcc: Test for it. * include/bits/stl_bvector.h: Likewise. * include/c_compatibility/stdatomic.h: Likewise. * include/experimental/bits/simd.h: Likewise. * include/experimental/bits/simd_builtin.h: Likewise. * include/experimental/bits/simd_detail.h: Likewise. * include/experimental/bits/simd_x86.h: Likewise. * include/experimental/simd: Likewise. * include/std/complex: Likewise. * include/std/ranges: Likewise. * include/std/variant: Likewise. * include/pstl/pstl_config.h: Likewise.
2024-05-22libstdc++: Ensure std::variant relops convert to bool [PR115145]Jonathan Wakely1-28/+35
Ensure that the result of comparing the variant alternatives is converted to bool immediately rather than copied. libstdc++-v3/ChangeLog: PR libstdc++/115145 * include/std/variant (operator==, operator!=, operator<) (operator<=, operator>, operator>=): Add trailing-return-type to lambda expressions to trigger conversion to bool. * testsuite/20_util/variant/relops/115145.cc: New test.
2024-05-15libstdc++: Rewrite std::variant comparisons without macrosJonathan Wakely1-51/+112
libstdc++-v3/ChangeLog: * include/std/variant (__detail::__variant::__compare): New function template. (operator==, operator!=, operator<, operator>, operator<=) (operator>=): Replace macro definition with handwritten function calling __detail::__variant::__compare. (operator<=>): Call __detail::__variant::__compare.
2024-05-07libstdc++: Simplify std::variant comparison operatorsJonathan Wakely1-11/+9
libstdc++-v3/ChangeLog: * include/std/variant (_VARIANT_RELATION_FUNCTION_TEMPLATE): Simplify.
2024-05-07libstdc++: Constrain equality ops for std::pair, std::tuple, std::variantJonathan Wakely1-16/+12
Implement the changes from P2944R3 which add constraints to the comparison operators of std::pair, std::tuple, and std::variant. The paper also changes std::optional, but we already constrain its comparisons using SFINAE on the return type. However, we need some additional constraints on the [optional.comp.with.t] operators that compare an optional with a value. The paper doesn't say to do that, but I think it's needed because otherwise when the comparison for two optional objects fails its constraints, the two overloads that are supposed to be for comparing to a non-optional become the best overload candidates, but are ambiguous (and we don't even get as far as checking the constraints for satisfaction). I reported LWG 4072 for this. The paper does not change std::expected, but probably should have done. I'll submit an LWG issue about that and implement it separately. Also add [[nodiscard]] to all these comparison operators. libstdc++-v3/ChangeLog: * include/bits/stl_pair.h (operator==): Add constraint. * include/bits/version.def (constrained_equality): Define. * include/bits/version.h: Regenerate. * include/std/optional: Define feature test macro. (__optional_rep_op_t): Use is_convertible_v instead of is_convertible. * include/std/tuple: Define feature test macro. (operator==, __tuple_cmp, operator<=>): Reimplement C++20 comparisons using lambdas. Add constraints. * include/std/utility: Define feature test macro. * include/std/variant: Define feature test macro. (_VARIANT_RELATION_FUNCTION_TEMPLATE): Add constraints. (variant): Remove unnecessary friend declarations for comparison operators. * testsuite/20_util/optional/relops/constrained.cc: New test. * testsuite/20_util/pair/comparison_operators/constrained.cc: New test. * testsuite/20_util/tuple/comparison_operators/constrained.cc: New test. * testsuite/20_util/variant/relops/constrained.cc: New test. * testsuite/20_util/tuple/comparison_operators/overloaded.cc: Disable for C++20 and later. * testsuite/20_util/tuple/comparison_operators/overloaded2.cc: Remove dg-error line for target c++20.
2024-04-25libstdc++: Add comment to #include in <variant>Jonathan Wakely1-1/+1
It's not obvious why <variant> needs <bits/parse_numbers.h> so add a comment to it. libstdc++-v3/ChangeLog: * include/std/variant: Add comment to #include.
2024-03-23libstdc++: Add __is_in_place_index_v helper and use it in <variant>Jonathan Wakely1-1/+2
We already have __is_in_place_type_v for in_place_type_t so adding an equivalent for in_place_index_t allows us avoid a class template instantiation for the __not_in_place_tag constraint on the most commonly-used std::variant::variant(T&&) constructor. For in_place_type_t we also have a __is_in_place_type class template defined in terms of the variable template, but that isn't actually used anywhere. I'm not adding an equivalent for the new variable template, because that wouldn't be used either. For GCC 15 we should remove the unused __is_in_place_tag and __is_in_place_type class templates. libstdc++-v3/ChangeLog: * include/bits/utility.h (__is_in_place_index_v): New variable template. * include/std/variant (__not_in_place_tag): Define in terms of variable templates not a class template.
2024-01-15libstdc++: Reduce std::variant template instantiation depthPatrick Palka1-8/+7
The recursively defined constraints on _Variadic_union's user-defined destructor (used for maintaining trivial destructibility of the variant iff all of its alternatives are) turn out to require a template instantiation depth of 3x the number of variants in C++20 mode, with the instantiation stack looking like ... _Variadic_union<B, C, ...> std::is_trivially_destructible_v<_Variadic_union<B, C, ...>> _Variadic_union<A, B, C, ...>::~_Variadic_union() _Variadic_union<A, B, C, ...> ... Ideally the template depth should be ~equal to the number of variants (plus a constant). Luckily it seems we don't need to compute trivial destructibility of the alternatives at all from _Variadic_union, since its only user _Variant_storage already has that information. To that end this patch removes these recursive constraints and instead passes this information down from _Variant_storage. After this patch, the template instantiation depth for 87619.cc in C++20 mode is ~270 instead of ~780. libstdc++-v3/ChangeLog: * include/std/variant (__detail::__variant::_Variadic_union): Add bool __trivially_destructible template parameter. (__detail::__variant::_Variadic_union::~_Variadic_union): Use __trivially_destructible in constraints instead. (__detail::__variant::_Variant_storage): Pass __trivially_destructible value to _Variadic_union. Reviewed-by: Jonathan Wakely <jwakely@redhat.com>
2024-01-03Update copyright years.Jakub Jelinek1-1/+1
2023-12-01c++: mangle function template constraintsJason Merrill1-2/+2
Per https://github.com/itanium-cxx-abi/cxx-abi/issues/24 and https://github.com/itanium-cxx-abi/cxx-abi/pull/166 We need to mangle constraints to be able to distinguish between function templates that only differ in constraints. From the latter link, we want to use the template parameter mangling previously specified for lambdas to also make explicit the form of a template parameter where the argument is not a "natural" fit for it, such as when the parameter is constrained or deduced. I'm concerned about how the latter link changes the mangling for some C++98 and C++11 patterns, so I've limited template_parm_natural_p to avoid two cases found by running the testsuite with -Wabi forced on: template <class T, T V> T f() { return V; } int main() { return f<int,42>(); } template <int i> int max() { return i; } template <int i, int j, int... rest> int max() { int sub = max<j, rest...>(); return i > sub ? i : sub; } int main() { return max<1,2,3>(); } A third C++11 pattern is changed by this patch: template <template <typename...> class TT, typename... Ts> TT<Ts...> f(); template <typename> struct A { }; int main() { f<A,int>(); } I aim to resolve these with the ABI committee before GCC 14.1. We also need to resolve https://github.com/itanium-cxx-abi/cxx-abi/issues/38 (mangling references to dependent template-ids where the name is fully resolved) as references to concepts in std:: will consistently run into this area. This is why mangle-concepts1.C only refers to concepts in the global namespace so far. The library changes are to avoid trying to mangle builtins, which fails. Demangler support and test coverage is not complete yet. gcc/cp/ChangeLog: * cp-tree.h (TEMPLATE_ARGS_TYPE_CONSTRAINT_P): New. (get_concept_check_template): Declare. * constraint.cc (combine_constraint_expressions) (finish_shorthand_constraint): Use UNKNOWN_LOCATION. * pt.cc (convert_generic_types_to_packs): Likewise. * mangle.cc (write_constraint_expression) (write_tparms_constraints, write_type_constraint) (template_parm_natural_p, write_requirement) (write_requires_expr): New. (write_encoding): Mangle trailing requires-clause. (write_name): Pass parms to write_template_args. (write_template_param_decl): Factor out from... (write_closure_template_head): ...here. (write_template_args): Mangle non-natural parms and requires-clause. (write_expression): Handle REQUIRES_EXPR. include/ChangeLog: * demangle.h (enum demangle_component_type): Add DEMANGLE_COMPONENT_CONSTRAINTS. libiberty/ChangeLog: * cp-demangle.c (d_make_comp): Handle DEMANGLE_COMPONENT_CONSTRAINTS. (d_count_templates_scopes): Likewise. (d_print_comp_inner): Likewise. (d_maybe_constraints): New. (d_encoding, d_template_args_1): Call it. (d_parmlist): Handle 'Q'. * testsuite/demangle-expected: Add some constraint tests. libstdc++-v3/ChangeLog: * include/std/bit: Avoid builtins in requires-clauses. * include/std/variant: Likewise. gcc/testsuite/ChangeLog: * g++.dg/abi/mangle10.C: Disable compat aliases. * g++.dg/abi/mangle52.C: Specify ABI 18. * g++.dg/cpp2a/class-deduction-alias3.C * g++.dg/cpp2a/class-deduction-alias8.C: Avoid builtins in requires-clauses. * g++.dg/abi/mangle-concepts1.C: New test. * g++.dg/abi/mangle-ttp1.C: New test.
2023-11-21libstdc++: Add freestanding feature test macros (P2407R5)Jonathan Wakely1-0/+1
This C++26 change makes several classes "partially freestanding", but we already fully supported them in freestanding mode. All we need to do is define the new feature test macros and add tests for them. libstdc++-v3/ChangeLog: * include/bits/version.def (freestanding_algorithm) (freestanding_array, freestanding_optional) (freestanding_string_view, freestanding_variant): Add. * include/bits/version.h: Regenerate. * include/std/algorithm (__glibcxx_want_freestanding_algorithm): Define. * include/std/array (__glibcxx_want_freestanding_array): Define. * include/std/optional (__glibcxx_want_freestanding_optional): Define. * include/std/string_view (__glibcxx_want_freestanding_string_view): Define. * include/std/variant (__glibcxx_want_freestanding_variant): Define. * testsuite/20_util/optional/version.cc: Add checks for __cpp_lib_freestanding_optional. * testsuite/20_util/variant/version.cc: Add checks for __cpp_lib_freestanding_variant. * testsuite/23_containers/array/tuple_interface/get_neg.cc: Adjust dg-error line numbers. * testsuite/21_strings/basic_string_view/requirements/version.cc: New test. * testsuite/23_containers/array/requirements/version.cc: New test. * testsuite/25_algorithms/fill_n/requirements/version.cc: New test. * testsuite/25_algorithms/swap_ranges/requirements/version.cc: New test.
2023-09-29libstdc++: Ensure active union member is correctly setNathaniel Shead1-2/+30
This patch ensures that the union members for std::string and std::variant are always properly set when a change occurs. libstdc++-v3/ChangeLog: * include/bits/basic_string.h: (basic_string(basic_string&&)): Activate _M_local_buf when needed. (basic_string(basic_string&&, const _Alloc&)): Likewise. * include/bits/basic_string.tcc: (basic_string::swap): Likewise. * include/std/variant: (__detail::__variant::__construct_n): New. (__detail::__variant::__emplace): Use __construct_n. Signed-off-by: Nathaniel Shead <nathanieloshead@gmail.com>
2023-09-15libstdc++: Fix constraints for std::variant default constructorJonathan Wakely1-12/+12
The standard says the default ctor should be constrained, not deleted. Our use of a defaulted default ctor and _Enable_default_constructor base class results in it being deleted. libstdc++-v3/ChangeLog: * include/std/variant (variant): Remove derivation from _Enable_default_constructor base class. (variant::variant()): Constrain. * testsuite/20_util/variant/default_ctor.cc: New test.
2023-09-15libstdc++: Remove non-void static assertions in variant's std::get [PR111172]Jonathan Wakely1-4/+0
A void template argument would cause a substitution failure when trying to form a reference for the return type, so the function body would never be instantiated. libstdc++-v3/ChangeLog: PR libstdc++/111172 * include/std/variant (get<T>): Remove !is_void static assertions.
2023-08-16libstdc++: Replace all manual FTM definitions and useArsen Arsenović1-8/+7
libstdc++-v3/ChangeLog: * libsupc++/typeinfo: Switch to bits/version.h for __cpp_lib_constexpr_typeinfo. * libsupc++/new: Switch to bits/version.h for __cpp_lib_{launder,hardware_interference_size,destroying_delete}. (launder): Guard behind __cpp_lib_launder. (hardware_destructive_interference_size) (hardware_constructive_interference_size): Guard behind __cpp_lib_hardware_interference_size. * libsupc++/exception: Switch to bits/version.h for __cpp_lib_uncaught_exceptions. (uncaught_exceptions): Guard behind __cpp_lib_uncaught_exceptions. * libsupc++/compare: Switch to bits/version.h for __cpp_lib_three_way_comparison. (three_way_comparable, three_way_comparable_with) (compare_three_way, weak_order, strong_order, partial_order): Guard behind __cpp_lib_three_way_comparison >= 201907L. * include/std/chrono: Drop __cpp_lib_chrono definition. * include/std/vector: Switch to bits/version.h for __cpp_lib_erase_if. (erase, erase_if): Guard behind __cpp_lib_erase_if. * include/std/variant: Switch to bits/version.h for __cpp_lib_variant. Guard whole header behind that FTM. * include/std/utility: Switch to bits/version.h for __cpp_lib_{exchange_function,constexpr_algorithms,as_const}, __cpp_lib_{integer_comparison_functions,to_underlying}, and __cpp_lib_unreachable. (exchange): Guard behind __cpp_lib_exchange_function. (cmp_equal, cmp_not_equal, cmp_less, cmp_greater, cmp_less_equal) (cmp_greater_equal, in_range): Guard behind __cpp_lib_integer_comparison_functions. (to_underlying): Guard behind __cpp_lib_to_underlying. (unreachable): Guard behind __cpp_lib_unreachable. * include/std/type_traits: Switch to bits/version.h for __cpp_lib_is_{null_pointer,final,nothrow_convertible,aggregate}, __cpp_lib_is_{constant_evaluated,invocable,layout_compatible}, __cpp_lib_is_{pointer_interconvertible,scoped_enum,swappable}, __cpp_lib_{logical_traits,reference_from_temporary,remove_cvref}, __cpp_lib_{result_of_sfinae,transformation_trait_aliases}, __cpp_lib_{type_identity,type_trait_variable_templates}, __cpp_lib_{unwrap_ref,void_t,integral_constant_callable}, __cpp_lib_{bool_constant,bounded_array_traits}, and __cpp_lib_has_unique_object_representations. (integral_constant::operator()): Guard behind __cpp_lib_integral_constant_callable. (bool_constant): Guard behind __cpp_lib_bool_constant. (conjunction, disjunction, negation, conjunction_v, disjunction_v) (negation_v): Guard behind __cpp_lib_logical_traits. (is_null_pointer): Guard behind __cpp_lib_is_null_pointer. (is_final): Guard behind __cpp_lib_is_final. (is_nothrow_convertible, is_nothrow_convertible_v): Guard behind __cpp_lib_is_nothrow_convertible. (remove_const_t, remove_volatile_t, remove_cv_t) (add_const_t, add_volatile_t, add_cv_t): Guard behind __cpp_lib_transformation_trait_aliases. (void_t): Guard behind __cpp_lib_void_t. (is_swappable_with_v, is_nothrow_swappable_with_v) (is_swappable_with, is_nothrow_swappable_with): Guard behind __cpp_lib_is_swappable. (is_nothrow_invocable_r, is_invocable_r, invoke_result) (is_invocable, invoke_result_t): Guard behind __cpp_lib_is_invocable. (alignment_of_v, extent_v, has_virtual_destructor_v) (is_abstract_v, is_arithmetic_v, is_array_v) (is_assignable_v, is_base_of_v, is_class_v, is_compound_v) (is_constructible_v, is_const_v, is_convertible_v) (is_copy_assignable_v, is_copy_constructible_v) (is_default_constructible_v, is_destructible_v) (is_empty_v, is_enum_v, is_final_v, is_floating_point_v) (is_function_v, is_fundamental_v, is_integral_v) (is_invocable_r_v, is_invocable_v, is_literal_type_v) (is_lvalue_reference_v, is_member_function_pointer_v) (is_member_object_pointer_v, is_member_pointer_v) (is_move_assignable_v, is_move_constructible_v) (is_nothrow_assignable_v, is_nothrow_constructible_v) (is_nothrow_copy_assignable_v, is_nothrow_copy_constructible_v) (is_nothrow_default_constructible_v, is_nothrow_destructible_v) (is_nothrow_invocable_r_v, is_nothrow_invocable_v) (is_nothrow_move_assignable_v, is_nothrow_move_constructible_v) (is_null_pointer_v, is_object_v, is_pod_v, is_pointer_v) (is_polymorphic_v, is_reference_v, is_rvalue_reference_v) (is_same_v, is_scalar_v, is_signed_v, is_standard_layout_v) (is_trivially_assignable_v, is_trivially_constructible_v) (is_trivially_copyable_v, is_trivially_copy_assignable_v) (is_trivially_copy_constructible_v) (is_trivially_default_constructible_v) (is_trivially_destructible_v, is_trivially_move_assignable_v) (is_trivially_move_constructible_v, is_trivial_v, is_union_v) (is_unsigned_v, is_void_v, is_volatile_v, rank_v, as variadic): Guard behind __cpp_lib_type_trait_variable_templates. (has_unique_object_representations) (has_unique_object_representations_v): Guard behind __cpp_lib_has_unique_object_representation. (is_aggregate): Guard behind __cpp_lib_is_aggregate. (remove_cvref, remove_cvref_t): Guard behind __cpp_lib_remove_cvref. (type_identity, type_identity_t): Guard behind __cpp_lib_type_identity. (unwrap_reference, unwrap_reference_t, unwrap_ref_decay) (unwrap_ref_decay_t): Guard behind __cpp_lib_unwrap_ref. (is_bounded_array_v, is_unbounded_array_v, is_bounded_array) (is_unbounded_array): Guard behind __cpp_lib_bounded_array_traits. (is_scoped_enum, is_scoped_enum_v): Guard behind __cpp_lib_is_scoped_enum. (reference_constructs_from_temporary) (reference_constructs_from_temporary_v): Guard behind __cpp_lib_reference_from_temporary. * include/std/tuple: Switch to bits/version.h for __cpp_lib_{constexpr_tuple,tuple_by_type,apply_make_from_tuple}. (get<T>): Guard behind __cpp_lib_tuple_by_type. (apply): Guard behind __cpp_lib_apply. (make_from_tuple): Guard behind __cpp_lib_make_from_tuple. * include/std/syncstream: Switch to bits/version.h for __cpp_lib_syncbuf. Guard header behind that FTM. * include/std/string_view: Switch to bits/version.h for __cpp_lib_{string_{view,contains},constexpr_string_view} and __cpp_lib_starts_ends_with. (basic_string_view::starts_with, basic_string_view::ends_with): Guard behind __cpp_lib_starts_ends_with. [C++23 && _GLIBCXX_HOSTED && !defined(__cpp_lib_string_contains)]: Assert as impossible ithout a bug in C++23. * include/std/string: Switch to bits/version.h for __cpp_lib_erase_if. (erase, erase_if): Guard behind __cpp_lib_erase_if. * include/std/thread: Switch to bits/version.h for __cpp_lib_jthread. * include/std/stop_token: Switch to bits/version.h for __cpp_lib_jthread. * include/std/spanstream: Switch to bits/version.h for __cpp_lib_spanstream. Guard header behind that FTM. * include/std/span: Switch to bits/version.h for __cpp_lib_span. Guard header behind that FTM. * include/std/source_location: Switch to bits/version.h for __cpp_lib_source_location. Guard header with that FTM. * include/std/shared_mutex: Switch to bits/version.h for __cpp_lib_shared{,_timed}_mutex. (shared_mutex): Guard behind __cpp_lib_shared_mutex. * include/std/semaphore: Switch to bits/version.h for __cpp_lib_semaphore. Guard header behind that FTM. * include/std/ranges: Switch to bits/version.h for __cpp_lib_ranges_{zip,chunk{,_by},slide,join_with}, __cpp_lib_ranges_{repeat_stride,cartesian_product,as_rvalue}, and __cpp_lib_ranges_{as_const,enumerate,iota}. (ranges::zip et al, ranges::chunk et al, ranges::slide et al) (ranges::chunk_by et al, ranges::join_with et al) (ranges::stride et al, ranges::cartesian_product et al) (ranges::as_rvalue et al, ranges::as_const et al) (ranges::enumerate et al): Guard behind appropriate FTM. * include/std/optional: Switch to bits/version.h for __cpp_lib_optional. Guard header behind that FTM. * include/std/numeric: Switch to bits/version.h for __cpp_lib_{gcd{,_lcm},lcm,constexpr_numeric,interpolate} and __cpp_lib_parallel_algorithm. (gcd, lcm): Guard behind __cpp_lib_gcd_lcm. (midpoint): Guard behind __cpp_lib_interpolate. * include/std/numbers: Switch to bits/version.h for __cpp_lib_math_constants. Guard header behind that FTM. * include/std/mutex: Switch to bits/version.h for __cpp_lib_scoped_lock. (scoped_Lock): Guard behind __cpp_lib_scoped_lock. * include/std/memory_resource: Switch to bits/version.h for __cpp_lib_{polymorphic_allocator,memory_resource}. (synchronized_pool_resource): Guard behind __cpp_lib_memory_resource >= 201603L. (polymorphic_allocator): Guard behind __cpp_lib_polymorphic_allocator. * include/std/memory: Switch to bits/version.h for __cpp_lib_{parallel_algorithm,atomic_value_initialization}. * include/std/list: Switch to bits/version.h for __cpp_lib_erase_if. (erase, erase_if): Guard behind __cpp_lib_erase_if. * include/std/latch: Switch to bits/version.h for __cpp_lib_latch. Guard header behind that FTM. * include/std/iterator: Switch to bits/version.h for __cpp_lib_null_iterators. * include/std/iomanip: Switch to bits/version.h for __cpp_lib_quoted_string_io. (quoted): Guard behind __cpp_lib_quoted_string_io. * include/std/functional: Switch to bits/version.h for __cpp_lib_{invoke{,_r},constexpr_functional,bind_front} and __cpp_lib_{not_fn,booyer_moore_searcher}. (invoke): Guard behind __cpp_lib_invoke. (invoke_r): Guard behind __cpp_lib_invoke_r. (bind_front): Guard behind __cpp_lib_bind_front. (not_fn): Guard behind __cpp_lib_not_fn. (boyer_moore_searcher, boyer_moore_horspool_searcher): Guard definition behind __cpp_lib_boyer_moore_searcher. * include/std/forward_list: Switch to bits/version.h for __cpp_lib_erase_if. (erase, erase_if): Guard behind __cpp_lib_erase_if. * include/std/format: Switch to bits/version.h for __cpp_lib_format. Guard header behind that FTM. * include/std/filesystem: Switch to bits/version.h for __cpp_lib_filesystem. Guard header behind that FTM. * include/std/expected: Switch to bits/version.h for __cpp_lib_expected. Guard header behind it. * include/std/execution: Switch to bits/version.h for __cpp_lib_{execution,parallel_algorithm}. Guard header behind either. * include/std/deque: Switch to bits/version.h for __cpp_lib_erase_if. (erase, erase_if): Guard behind __cpp_lib_erase_if. * include/std/coroutine: Switch to bits/version.h for __cpp_lib_coroutine. Guard header behind that FTM. * include/std/concepts: Switch to bits/version.h for __cpp_lib_concepts. Guard header behind that FTM. * include/std/complex: Switch to bits/version.h for __cpp_lib_{complex_udls,constexpr_complex}. (operator""if, operator""i, operator""il): Guard behind __cpp_lib_complex_udls. * include/std/charconv: Swtich to bits/version.h for __cpp_lib_{to_chars,constexpr_charconv}. * include/std/bitset: Switch to bits/version.h for __cpp_lib_constexpr_bitset. * include/std/bit: Switch to bits/version.h for __cpp_lib_{bit_cast,byteswap,bitops,int_pow2,endian}. (bit_cast): Guard behind __cpp_lib_bit_cast. (byteswap): Guard behind __cpp_lib_byteswap. (rotl, rotr, countl_zero, countl_one, countr_zero, countr_one) (popcount): Guard behind __cpp_lib_bitops. (has_single_bit, bit_ceil, bit_floor, bit_width): Guard behind __cpp_lib_int_pow2. (endian): Guard behind __cpp_lib_endian. * include/std/barrier: Switch to bits/version.h for __cpp_lib_barrier. Guard header behind that FTM. * include/std/atomic: Switch to bits/version.h for __cpp_lib_atomic_{is_always_lock_free,float,ref} and __cpp_lib_lock_free_type_aliases. (*::is_always_lock_free): Guard behind __cpp_lib_atomic_is_always_lock_free. (atomic<float>): Guard behind __cpp_lib_atomic_float. (atomic_ref): Guard behind __cpp_lib_atomic_ref. (atomic_signed_lock_free, atomic_unsigned_lock_free): Guard behind __cpp_lib_atomic_lock_free_type_aliases. * include/std/array: Switch to bits/version.h for __cpp_lib_to_array. (to_array): Guard behind __cpp_lib_to_array. * include/std/any: Switch to bits/version.h for __cpp_lib_any. Guard header behind that FTM. * include/std/algorithm: Switch to bits/version.h for __cpp_lib_parallel_algorithm. * include/c_global/cstddef: Switch to bits/version.h for __cpp_lib_byte. (byte): Guard behind __cpp_lib_byte. * include/c_global/cmath: Switch to bits/version.h for __cpp_lib_{hypot,interpolate}. (hypot3): Guard behind __cpp_lib_hypot. (lerp): Guard behind __cpp_lib_interpolate. * include/c_compatibility/stdatomic.h: Switch to bits/stl_version.h for __cpp_lib_atomic. Guard header behind that FTM. * include/bits/utility.h: Switch to bits/version.h for __cpp_lib_{tuple_element_t,integer_sequence,ranges_zip}. (tuple_element_t): Guard behind __cpp_lib_tuple_element_t. (integer_sequence et al): Guard behind __cpp_lib_integer_sequence. * include/bits/uses_allocator_args.h: Switch to bits/version.h for __cpp_lib_make_obj_using_allocator. Guard header behind that FTM. * include/bits/unordered_map.h: Switch to bits/version.h for __cpp_lib_unordered_map_try_emplace. (try_emplace): Guard behind __cpp_lib_unordered_map_try_emplace. * include/bits/unique_ptr.h: Switch to bits/version.h for __cpp_lib_{constexpr_memory,make_unique}. (make_unique): Guard behind __cpp_lib_make_unique. * include/bits/stl_vector.h: Switch to bits/version.h for __cpp_lib_constexpr_vector. * include/bits/stl_uninitialized.h: Switch to bits/version.h for __cpp_lib_raw_memory_algorithms. (uninitialized_default_construct) (uninitialized_default_construct_n, uninitialized_move) (uninitialized_move_n, uninitialized_value_construct) (uninitialized_value_construct_n): Guard behind __cpp_lib_raw_memory_algorithms. * include/bits/stl_tree.h: Switch to bits/version.h for __cpp_lib_generic_associative_lookup. * include/bits/stl_stack.h: Switch to bits/version.h for __cpp_lib_adaptor_iterator_pair_constructor. (stack): Guard iterator-pair constructor behind __cpp_lib_adaptor_iterator_pair_constructor. * include/bits/stl_queue.h: Switch to bits/version.h for __cpp_lib_adaptor_iterator_pair_constructor. (queue): Guard iterator-pair constructor behind __cpp_lib_adaptor_iterator_pair_constructor. * include/bits/stl_pair.h: Switch to bits/version.h for __cpp_lib_{concepts,tuples_by_type}. (get): Guard type-getting overloads behind __cpp_lib_tuples_by_type. * include/bits/stl_map.h: Switch to bits/version.h for __cpp_lib_map_try_emplace. (map<>::try_emplace): Guard behind __cpp_lib_map_try_emplace. * include/bits/stl_list.h: Switch to bits/version.h for __cpp_lib_list_remove_return_type. (__remove_return_type, _GLIBCXX_LIST_REMOVE_RETURN_TYPE_TAG) [C++20]: guard behind __cpp_lib_list_remove_return_type instead. * include/bits/stl_iterator.h: Switch to bits/version.h for __cpp_lib_{constexpr_iterator,array_constexpr} and __cpp_lib_{make_reverse_iterator,move_iterator_concept}. (make_reverse_iterator): Guard behind __cpp_lib_make_reverse_iterator. (iterator_concept et al): Guard __cpp_lib_move_iterator_concept changes behind that FTM. * include/bits/stl_function.h: Switch to bits/version.h for __cpp_lib_transparent_operators. (equal_to, not_equal_to, greater, less, greater_equal) (less_equal, bit_and, bit_or, bit_xor, bit_not, logical_and) (logical_or, logical_not, plus, minus, multiplies, divides) (modulus, negate): Guard '= void' fwdecls behind __cpp_lib_transparent_operators. (plus<void>, minus<void>, multiplies<void>, divides<void>) (modulus<void>, negate<void>, logical_and<void>, logical_or<void>) (logical_not<void>, bit_and<void>, bit_or<void>, bit_xor<void>) (equal_to<void>, not_equal_to<void>, greater<void>, less<void>) (greater_equal<void>, less_equal<void>, bit_not<void>) (__has_is_transparent): Guard behind __cpp_lib_transparent_operators. * include/bits/stl_algobase.h: Switch to bits/version.h for __cpp_lib_robust_nonmodifying_seq_ops. (robust equal, mismatch): Guard behind __cpp_lib_nonmember_container_access. * include/bits/stl_algo.h: Swtich to bits/version.h for __cpp_lib_{clamp,sample}. (clamp): Guard behind __cpp_lib_clamp. (sample): Guard behind __cpp_lib_sample. * include/bits/specfun.h: Switch to bits/version.h for __cpp_lib_math_special_functions and __STDCPP_MATH_SPEC_FUNCS__. * include/bits/shared_ptr_base.h: Switch to bits/version.h for __cpp_lib_{smart_ptr_for_overwrite,shared_ptr_arrays}. (_Sp_overwrite_tag): Guard behind __cpp_lib_smart_ptr_for_overwrite. * include/bits/shared_ptr_atomic.h: Switch to bits/version.h for __cpp_lib_atomic_shared_ptr. * include/bits/shared_ptr.h: Switch to bits/version.h for __cpp_lib_{enable_shared_from_this,shared_ptr_weak_type}. (shared_ptr<T>::weak_type): Guard behind __cpp_lib_shared_ptr_weak_type. (enable_shared_from_this<T>::weak_from_this): Guard behind __cpp_lib_enable_shared_from_this. * include/bits/ranges_cmp.h: Switch to bits/version.h for __cpp_lib_ranges. * include/bits/ranges_algo.h: Switch to bits/version.h for __cpp_lib_{shift,ranges_{contains,find_last,fold,iota}}. * include/bits/range_access.h: Switch to bits/version.h for __cpp_lib_nonmember_container_access (size, empty, data): Guard behind __cpp_lib_nonmember_container_access. (ssize): Guard behind __cpp_lib_ssize. * include/bits/ptr_traits.h: Switch to bits/version.h. for __cpp_lib_{constexpr_memory,to_address}. (to_address): Guard behind __cpp_lib_to_address. * include/bits/node_handle.h: Switch to bits/version.h for __cpp_lib_node_extract. Guard header behind that FTM. * include/bits/move_only_function.h: Switch to bits/version.h for __cpp_lib_move_only_function. Guard header behind that FTM. * include/bits/move.h: Switch to bits/version.h for __cpp_lib_addressof_constexpr. * include/bits/ios_base.h: Switch to bits/version.h for __cpp_lib_ios_noreplace. (noreplace): Guard with __cpp_lib_ios_noreplace. * include/bits/hashtable.h: Switch to bits/version.h for __cpp_lib_generic_unordered_lookup. (_M_equal_range_tr, _M_count_tr, _M_find_tr): Guard behind __cpp_lib_generic_unordered_lookup. * include/bits/forward_list.h: Switch to bits/version.h for __cpp_lib_list_remove_return_type. (__remove_return_type): Guard behind __cpp_lib_list_remove_return_type. * include/bits/erase_if.h: Switch to bits/version.h for __cpp_lib_erase_if. * include/bits/cow_string.h: Switch to bits/version.h for __cpp_lib_constexpr_string. * include/bits/chrono.h: Swtich to bits/version.h for __cpp_lib_chrono{,_udls}. (ceil): Guard behind __cpp_lib_chrono. (operator""ns et al): Guard behind __cpp_lib_chrono_udls. * include/bits/char_traits.h: Switch to bits/version.h for __cpp_lib_constexpr_char_traits. * include/bits/basic_string.h: Switch to bits/version.h for __cpp_lib_{constexpr_string,string_{resize_and_overwrite,udls}}. (resize_and_overwrite): Guard behind __cpp_lib_string_resize_and_overwrite. (operator""s): Guard behind __cpp_lib_string_udls. * include/bits/atomic_wait.h: Switch to bits/version.h for __cpp_lib_atomic_wait. Guard header behind that FTM. * include/bits/atomic_base.h: Switch to bits/version.h for __cpp_lib_atomic_value_initialization and __cpp_lib_atomic_flag_test. (atomic_flag::test): Guard behind __cpp_lib_atomic_flag_test, rather than C++20. * include/bits/allocator.h: Switch to bits/version.h for __cpp_lib_incomplete_container_elements. * include/bits/alloc_traits.h: Switch to using bits/version.h for __cpp_lib_constexpr_dynamic_alloc and __cpp_lib_allocator_traits_is_always_equal. * include/bits/align.h: Switch to bits/version.h for defining __cpp_lib_assume_aligned. (assume_aligned): Guard with __cpp_lib_assume_aligned. * include/bits/algorithmfwd.h: Switch to bits/version.h for defining __cpp_lib_constexpr_algorithms. * include/std/stacktrace: Switch to bits/version.h for __cpp_lib_stacktrace. Guard header behind that FTM. * testsuite/23_containers/array/tuple_interface/get_neg.cc: Update line numbers.
2023-02-02libstdc++: Use emplace in std::variant::operator=(T&&) as per LWG 3585Jonathan Wakely1-1/+3
This was approved at the October 2021 plenary. libstdc++-v3/ChangeLog: * include/std/variant (variant::operator=): Implement resolution of LWG 3585. * testsuite/20_util/variant/lwg3585.cc: New test.
2023-01-16Update copyright years.Jakub Jelinek1-1/+1
2022-11-02libstdc++: Ignore -Wignored-qualifiers warning in <variant>Jonathan Wakely1-0/+3
The warning is wrong here, the qualifier serves a purpose and is not ignored (c.f. PR c++/107492). libstdc++-v3/ChangeLog: * include/std/variant (__variant::_Multi_array::__untag_result): Use pragma to suppress warning.
2022-08-23libstdc++: Fix visit<void>(v) for non-void visitors [PR106589]Jonathan Wakely1-1/+6
The optimization for the common case of std::visit forgot to handle the edge case of passing zero variants to a non-void visitor and converting the result to void. libstdc++-v3/ChangeLog: PR libstdc++/106589 * include/std/variant (__do_visit): Handle is_void<R> for zero argument case. * testsuite/20_util/variant/visit_r.cc: Check std::visit<void>(v).
2022-07-12libstdc++: Prefer const T to std::add_const_t<T>Jonathan Wakely1-3/+3
For any typedef-name or template parameter, T, add_const_t<T> is equivalent to T const, so we can avoid instantiating the std::add_const class template and just say T const (or const T). This isn't true for a non-typedef like int&, where int& const would be ill-formed, but we shouldn't be using add_const_t<int&> anyway, because we know what that type is. The only place we need to continue using std::add_const is in the std::bind implementation where it's used as a template template parameter to be applied as a metafunction elsewhere. libstdc++-v3/ChangeLog: * include/bits/stl_iterator.h (__iter_to_alloc_t): Replace add_const_t with const-qualifier. * include/bits/utility.h (tuple_element<N, cv T>): Likewise for all cv-qualifiers. * include/std/type_traits (add_const, add_volatile): Replace typedef-declaration with using-declaration. (add_cv): Replace add_const and add_volatile with cv-qualifiers. * include/std/variant (variant_alternative<N, cv T>): Replace add_const_t, add_volatile_t and add_cv_t etc. with cv-qualifiers.
2022-06-27libstdc++: Simplify std::variant construction using variable templatesJonathan Wakely1-22/+21
libstdc++-v3/ChangeLog: * include/std/variant (_Build_FUN::_S_fun): Define fallback case as deleted. (__accepted_index, _Extra_visit_slot_needed): Replace class templates with variable templates.
2022-05-26libstdc++: Remove some unnecessary includesJonathan Wakely1-1/+0
These headers do not use anything in <bits/stl_iterator_base_types.h> directly, and it's included by <bits/stl_iterator_base_funcs.h> and <bits/stl_iterator.h> anyway, because they do need it. libstdc++-v3/ChangeLog: * include/bits/ranges_algobase.h: Do not include <bits/stl_iterator_base_types.h>. * include/std/string: Likewise. * include/std/variant: Likewise.
2022-02-14libstdc++: Use __cpp_concepts instead of custom macro [PR103891]Jonathan Wakely1-8/+6
With the new value of __cpp_concepts required by P2493, we can test whether the compiler supports conditionally trivial special members. This allows us to remove the workaround that disables fully-constexpr std::variant for Clang. Now it should work for non-GCC compilers (such as future releases of Clang) that support conditionally trivial destructors and define the new value of __cpp_concepts. libstdc++-v3/ChangeLog: PR libstdc++/103891 * include/bits/c++config (_GLIBCXX_HAVE_COND_TRIVIAL_SPECIAL_MEMBERS): Remove. * include/std/variant: Check feature test macros instead. * include/std/version: Likewise.
2022-01-11libstdc++: Make std::variant work with Clang in C++20 mode [PR103891]Jonathan Wakely1-3/+4
Clang has some bugs with destructors that use constraints to be conditionally trivial, so disable the P2231R1 constexpr changes to std::variant unless the compiler is GCC 12 or later. If/when P2493R0 gets accepted and implemented by G++ we can remove the __GNUC__ check and use __cpp_concepts >= 202002 instead. libstdc++-v3/ChangeLog: PR libstdc++/103891 * include/bits/c++config (_GLIBCXX_HAVE_COND_TRIVIAL_SPECIAL_MEMBERS): Define. * include/std/variant (__cpp_lib_variant): Only define C++20 value when the compiler is known to support conditionally trivial destructors. * include/std/version (__cpp_lib_variant): Likewise.
2022-01-03Update copyright years.Jakub Jelinek1-1/+1
2021-11-04libstdc++: Consolidate duplicate metaprogramming utilitiesJonathan Wakely1-44/+25
Currently std::variant uses __index_of<T, Types...> to find the first occurence of a type in a pack, and __exactly_once<T, Types...> to check that there is no other occurrence. We can reuse the __find_uniq_type_in_pack<T, Types...>() function for both tasks, and remove the recursive templates used to implement __index_of and __exactly_once. libstdc++-v3/ChangeLog: * include/bits/utility.h (__find_uniq_type_in_pack): Move definition to here, ... * include/std/tuple (__find_uniq_type_in_pack): ... from here. * include/std/variant (__detail__variant::__index_of): Remove. (__detail::__variant::__exactly_once): Define using __find_uniq_type_in_pack instead of __index_of. (get<T>, get_if<T>, variant::__index_of): Likewise.
2021-11-04libstdc++: Optimize std::tuple_element and std::tuple_size_vJonathan Wakely1-53/+5
This reduces the number of class template instantiations needed for code using tuples, by reusing _Nth_type in tuple_element and specializing tuple_size_v for tuple, pair and array (and const-qualified versions of them). Also define the _Nth_type primary template as a complete type (but with no nested 'type' member). This avoids "invalid use of incomplete type" errors for out-of-range specializations of tuple_element. Those errors would probably be confusing and unhelpful for users. We already have a user-friendly static assert in tuple_element itself. Also ensure that tuple_size_v is available whenever tuple_size is (as proposed by LWG 3387). We already do that for tuple_element_t. libstdc++-v3/ChangeLog: * include/bits/stl_pair.h (tuple_size_v): Define partial specializations for std::pair. * include/bits/utility.h (_Nth_type): Move definition here and define primary template. (tuple_size_v): Move definition here. * include/std/array (tuple_size_v): Define partial specializations for std::array. * include/std/tuple (tuple_size_v): Move primary template to <bits/utility.h>. Define partial specializations for std::tuple. (tuple_element): Change definition to use _Nth_type. * include/std/variant (_Nth_type): Move to <bits/utility.h>. (variant_alternative, variant): Adjust qualification of _Nth_type. * testsuite/20_util/tuple/element_access/get_neg.cc: Prune additional errors from _Nth_type.
2021-11-04libstdc++: Refactor emplace-like functions in std::variantJonathan Wakely1-97/+82
libstdc++-v3/ChangeLog: * include/std/variant (__detail::__variant::__emplace): New function template. (_Copy_assign_base::operator=): Reorder conditions to match bulleted list of effects in the standard. Use __emplace instead of _M_reset followed by _Construct. (_Move_assign_base::operator=): Likewise. (__construct_by_index): Remove. (variant::emplace): Use __emplace instead of _M_reset followed by __construct_by_index. (variant::swap): Hoist valueless cases out of visitor. Use __emplace to replace _M_reset followed by _Construct.
2021-11-04libstdc++: Optimize std::variant traits and improve diagnosticsJonathan Wakely1-41/+78
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<invalid-index> or emplace<invalid-type>. 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.
2021-11-04libstdc++: Fix handling of const types in std::variant [PR102912]Jonathan Wakely1-88/+43
Prior to r12-4447 (implementing P2231R1 constexpr changes) we didn't construct the correct member of the union in __variant_construct_single, we just plopped an object in the memory occupied by the union: void* __storage = std::addressof(__lhs._M_u); using _Type = remove_reference_t<decltype(__rhs_mem)>; ::new (__storage) _Type(std::forward<decltype(__rhs_mem)>(__rhs_mem)); We didn't care whether we had variant<int, const int>, we would just place an int (or const int) into the storage, and then set the _M_index to say which one it was. In the new constexpr-friendly code we use std::construct_at to construct the union object, which constructs the active member of the right type. But now we need to know exactly the right type. We have to distinguish between alternatives of type int and const int, and we have to be able to find a const int (or const std::string, as in the OP) among the alternatives. So my change from remove_reference_t<decltype(__rhs_mem)> to remove_cvref_t<_Up> was wrong. It strips the const from const int, and then we can't find the index of the const int alternative. But just using remove_reference_t doesn't work either. When the copy assignment operator of std::variant<int> uses __variant_construct_single it passes a const int& as __rhs_mem, but if we don't strip the const then we try to find const int among the alternatives, and *that* fails. Similarly for the copy constructor, which also uses a const int& as the initializer for a non-const int alternative. The root cause of the problem is that __variant_construct_single doesn't know the index of the type it's supposed to construct, and the new _Variant_storage::__index_of<_Type> helper doesn't work if __rhs_mem and the alternative being constructed have different const-qualification. We need to replace __variant_construct_single with something that knows the index of the alternative being constructed. All uses of that function do actually know the index, but that context is lost by the time we call __variant_construct_single. This patch replaces that function and __variant_construct, inlining their effects directly into the callers. libstdc++-v3/ChangeLog: PR libstdc++/102912 * include/std/variant (_Variant_storage::__index_of): Remove. (__variant_construct_single): Remove. (__variant_construct): Remove. (_Copy_ctor_base::_Copy_ctor_base(const _Copy_ctor_base&)): Do construction directly instead of using __variant_construct. (_Move_ctor_base::_Move_ctor_base(_Move_ctor_base&&)): Likewise. (_Move_ctor_base::_M_destructive_move()): Remove. (_Move_ctor_base::_M_destructive_copy()): Remove. (_Copy_assign_base::operator=(const _Copy_assign_base&)): Do construction directly instead of using _M_destructive_copy. (variant::swap): Do construction directly instead of using _M_destructive_move. * testsuite/20_util/variant/102912.cc: New test.
2021-10-19libstdc++: Change std::variant union member to empty structJonathan Wakely1-1/+3
This more clearly expresses the intent (a completely unused, trivial type) than using char. It's also consistent with the unions in std::optional. libstdc++-v3/ChangeLog: * include/std/variant (_Uninitialized): Use an empty struct for the unused union member, instead of char.
2021-10-15libstdc++: Add missing constexpr to std::variant (P2231R1)Jonathan Wakely1-22/+115
This implements the changes in P2231R1 which make std::variant fully constexpr in C++20. We need to replace placement new with std::construct_at, but that isn't defined for C++17. Use std::_Construct instead, which forwards to std::construct_at in C++20 mode (since the related changes to make std::optional fully constexpr, in r12-4389). We also need to replace the untyped char buffer in _Uninitialized with a union, which can be accessed in constexpr functions. But the union needs to have a non-trivial destructor if its variant type is non-trivial, which means that the _Variadic_union also needs a non-trivial destructor. This adds a constrained partial specialization of _Variadic_union for the C++20-only case where a non-trivial destructor is needed. We can't use concepts to constrain the specialization (or the primary template's destructor) in C++17, so retain the untyped char buffer solution for C++17 mode. libstdc++-v3/ChangeLog: * include/std/variant (__cpp_lib_variant): Update value for C++20. (__variant_cast, __variant_construct): Add constexpr for C++20. (__variant_construct_single, __construct_by_index) Likewise. Use std::_Construct instead of placement new. (_Uninitialized<T, false>) [__cplusplus >= 202002]: Replace buffer with a union and define a destructor. (_Variadic_union) [__cplusplus >= 202002]: Add a specialization for non-trivial destruction. (_Variant_storage::__index_of): New helper variable template. (_Variant_storage::~_Variant_storage()): Add constexpr. (_Variant_storage::_M_reset()): Likewise. (_Copy_ctor_base, _Move_ctor_base): Likewise. (_Copy_assign_base, _Move_assign_base): Likewise. (variant, swap): Likewise. * include/std/version (__cpp_lib_variant): Update value for C++20. * testsuite/20_util/optional/version.cc: Check for exact value in C++17. * testsuite/20_util/variant/87619.cc: Increase timeout for C++20 mode. * testsuite/20_util/variant/constexpr.cc: New test. * testsuite/20_util/variant/version.cc: New test.
2021-10-15libstdc++: Remove try/catch overhead in std::variant::emplaceJonathan Wakely1-34/+21
The __variant_construct_by_index helper function sets the new index before constructing the new object. This means that if the construction throws then the exception needs to be caught, so the index can be reset to variant_npos, and then the exception rethrown. This means callers are responsible for restoring the variant's invariants and they need the overhead of a catch handler and a rethrow. If we don't set the index until after construction completes then the invariant is never broken, and callers can ignore the exception and let it propagate. The callers all call _M_reset() first, which sets index to variant_npos as required while the variant is valueless. We need to be slightly careful here, because changing the order of operations in __variant_construct_by_index and removing the try-block from variant::emplace<I> changes an implicit ABI contract between those two functions. If the linker were to create an executable containing an instantiation of the old __variant_construct_by_index and an instantiation of the new variant::emplace<I> code then we would have a combination that breaks the invariant and doesn't have the exception handling to restore it. To avoid this problem, we can rename the __variant_construct_by_index function so that the new emplace<I> code calls a new symbol, and is unaffected by the behaviour of the old symbol. libstdc++-v3/ChangeLog: * include/std/variant (__detail::__variant::__get_storage): Remove unused function. (__variant_construct_by_index): Set index after construction is complete. Rename to ... (__detail::__variant::__construct_by_index): ... this. (variant): Use new name for __variant_construct_by_index friend declaration. Remove __get_storage friend declaration. (variant::emplace): Use new name and remove try-blocks.
2021-10-15libstdc++: Remove unused functions in std::variant implementationJonathan Wakely1-23/+0
These functions aren't used, and accessing the storage as a void* isn't compatible with C++20 constexpr requirements anyway, so we're unlikely to ever start using them in future. libstdc++-v3/ChangeLog: * include/std/variant (_Variant_storage::_M_storage()): Remove. (__detail::__variant::__get_storage): Remove. (variant): Remove friend declaration of __get_storage.
2021-10-14libstdc++: Simplify variant access functionsJonathan Wakely1-12/+11
libstdc++-v3/ChangeLog: * include/std/variant (__variant::__get(in_place_index_t<N>, U&&)): Rename to __get_n and remove first argument. Replace pair of overloads with a single function using 'if constexpr'. (__variant::__get(Variant&&)): Adjust to use __get_n.
2021-10-04libstdc++: Add missing noexcept to std::variant helperJonathan Wakely1-1/+1
libstdc++-v3/ChangeLog: * include/std/variant (__detail::__variant::__as): Add missing noexcept to first overload.
2021-10-01libstdc++: Fix narrowing conversion in std::visitJonathan Wakely1-1/+2
Signed-off-by: Jonathan Wakely <jwakely@redhat.com> libstdc++-v3/ChangeLog: * include/std/variant (__do_visit): Use variant_npos instead of literal -1 that requires a narrowing conversion.
2021-10-01libstdc++: Add std::__conditional_t alias templateJonathan Wakely1-1/+1
This change is inspired by the suggestion in http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1715r0.html The new std::__conditional_t alias template is functionally equivalent to std::conditional_t but should be more efficient to compile, due to only ever instantiating two specializations (std::__conditional<true> and std::__conditional<false>) rather than a new specialization for every use of std::conditional. The new alias template is also available in C++11, unlike the C++14 std::conditional_t alias. Signed-off-by: Jonathan Wakely <jwakely@redhat.com> libstdc++-v3/ChangeLog: * include/std/type_traits (__conditional): New class template for internal uses of std::conditional. (__conditional_t): New alias template to replace conditional_t. (__and_, __or_, __result_of_memfun, __result_of_memobj): Use __conditional_t instead of conditional::type. * include/bits/atomic_base.h (__atomic_impl::_Diff): Likewise. * include/bits/hashtable.h (_Hashtable): Likewise. * include/bits/hashtable_policy.h (_Node_iterator, _Insert_base) (_Local_iterator): Likewise. Replace typedefs with using-declarations. * include/bits/move.h (move_if_noexcept): Use __conditional_t. * include/bits/parse_numbers.h (_Select_int_base): Likewise. * include/bits/ptr_traits.h (__make_not_void): Likewise. * include/bits/ranges_algobase.h (__copy_or_move_backward) (__copy_or_move): Likewise. * include/bits/ranges_base.h (borrowed_iterator_t): Likewise. * include/bits/ranges_util.h (borrowed_subrange_t): Likewise. * include/bits/regex_compiler.h (_BracketMatcher): Use __conditional_t. Replace typedefs with using-declarations. * include/bits/shared_ptr_base.h (__shared_count): Use __conditional_t. * include/bits/stl_algobase.h (__copy_move, __copy_move_backward): Likewise. * include/bits/stl_iterator.h (__detail::__clamp_iter_cat) (reverse_iterator::iterator_concept) (__make_move_if_noexcept_iterator) (iterator_traits<common_iterator<_It, _Sent>>) (iterator_traits<counted_iterator<_It>>): Likewise. * include/bits/stl_pair.h (_PCC, pair::operator=): Likewise. * include/bits/stl_tree.h (_Rb_tree::insert_return_type) (_Rb_tree::_M_clone_node): Likewise. * include/bits/unique_ptr.h (unique_ptr(unique_ptr<U,E>&&)): Likewise. * include/bits/uses_allocator.h (__uses_alloc): Likewise. (__is_uses_allocator_predicate): Likewise. * include/debug/functions.h (__foreign_iterator_aux2): Likewise. * include/experimental/any (any::_Manager, __any_caster): Likewise. * include/experimental/executor (async_completion): Likewise. * include/experimental/functional (__boyer_moore_base_t): Likewise. * include/std/any (any::_Manager): Likewise. * include/std/functional (__boyer_moore_base_t): Likewise. * include/std/ranges (borrowed_iterator_t) (borrowed_subrange_t, __detail::__maybe_present_t) (__detail::__maybe_const_t, split_view): Likewise. * include/std/tuple (__empty_not_final, tuple::operator=): Likewise. * include/std/variant (__detail::__variant::__get_t): Likewise.
generated by cgit v1.1 at 2025-08-04 23:09:38 +0000