[libcxx-commits] [libcxx] bcf172e - [libc++] LWG 3821 uses_allocator_construction_args should have overload for pair-like (#66939)
via libcxx-commits
libcxx-commits at lists.llvm.org
Mon Oct 9 05:50:33 PDT 2023
Author: Hui
Date: 2023-10-09T13:50:27+01:00
New Revision: bcf172ec578a2a787de45858871e59fd64f7b196
URL: https://github.com/llvm/llvm-project/commit/bcf172ec578a2a787de45858871e59fd64f7b196
DIFF: https://github.com/llvm/llvm-project/commit/bcf172ec578a2a787de45858871e59fd64f7b196.diff
LOG: [libc++] LWG 3821 uses_allocator_construction_args should have overload for pair-like (#66939)
This change addresses LWG 3821 and LWG 3677.
- make `std::pair`'s constructor no longer takes `subrange`
- `uses_allocator_construction_args` constraint changes w.r.t to
`pair-like` types
- `uses_allocator_construction_args` constraints checks
`is-pair-like<remove_cv_t<T>>`
Added:
libcxx/test/std/ranges/range.utility/range.subrange/operator.pair_like.pass.cpp
Modified:
libcxx/docs/Status/Cxx23Issues.csv
libcxx/include/__memory/uses_allocator_construction.h
libcxx/include/__utility/pair.h
libcxx/include/memory
libcxx/test/std/depr/depr.numeric.imits.has.denorm/deprecated.verify.cpp
libcxx/test/std/utilities/memory/allocator.uses/allocator.uses.construction/uses_allocator_construction_args.pass.cpp
libcxx/test/std/utilities/utility/pairs/pairs.pair/ctor.pair_like.pass.cpp
libcxx/utils/data/ignore_format.txt
Removed:
################################################################################
diff --git a/libcxx/docs/Status/Cxx23Issues.csv b/libcxx/docs/Status/Cxx23Issues.csv
index 67ef35ec39b2a81..8be1ff588cf3b5c 100644
--- a/libcxx/docs/Status/Cxx23Issues.csv
+++ b/libcxx/docs/Status/Cxx23Issues.csv
@@ -198,7 +198,7 @@
"`3629 <https://wg21.link/LWG3629>`__","``make_error_code`` and ``make_error_condition`` are customization points","November 2022","|Complete|","16.0",""
"`3636 <https://wg21.link/LWG3636>`__","``formatter<T>::format`` should be ``const``-qualified","November 2022","|Complete|","16.0","|format|"
"`3646 <https://wg21.link/LWG3646>`__","``std::ranges::view_interface::size`` returns a signed type","November 2022","|Complete|","16.0","|ranges|"
-"`3677 <https://wg21.link/LWG3677>`__","Is a cv-qualified ``pair`` specially handled in uses-allocator construction?", "November 2022","","",""
+"`3677 <https://wg21.link/LWG3677>`__","Is a cv-qualified ``pair`` specially handled in uses-allocator construction?", "November 2022","|Complete|","18.0",""
"`3717 <https://wg21.link/LWG3717>`__","``common_view::end`` should improve ``random_access_range`` case", "November 2022","","","|ranges|"
"`3732 <https://wg21.link/LWG3732>`__","``prepend_range`` and ``append_range`` can't be amortized constant time", "November 2022","|Nothing to do|","","|ranges|"
"`3736 <https://wg21.link/LWG3736>`__","``move_iterator`` missing ``disable_sized_sentinel_for`` specialization", "November 2022","","","|ranges|"
@@ -262,7 +262,7 @@
"`3742 <https://wg21.link/LWG3742>`__","``deque::prepend_range`` needs to permute","February 2023","","","|ranges|"
"`3790 <https://wg21.link/LWG3790>`__","`P1467 <https://wg21.link/P1467>`__ accidentally changed ``nexttoward``'s signature","February 2023","","",""
"`3819 <https://wg21.link/LWG3819>`__","``reference_meows_from_temporary`` should not use ``is_meowible``","February 2023","","",""
-"`3821 <https://wg21.link/LWG3821>`__","``uses_allocator_construction_args`` should have overload for ``pair-like``","February 2023","","",""
+"`3821 <https://wg21.link/LWG3821>`__","``uses_allocator_construction_args`` should have overload for ``pair-like``","February 2023","|Complete|","18.0.0",""
"`3834 <https://wg21.link/LWG3834>`__","Missing ``constexpr`` for ``std::intmax_t`` math functions in ``<cinttypes>``","February 2023","","",""
"`3839 <https://wg21.link/LWG3839>`__","``range_formatter``'s ``set_separator``, ``set_brackets``, and ``underlying`` functions should be ``noexcept``","February 2023","|Complete|","17.0","|format|"
"`3841 <https://wg21.link/LWG3841>`__","``<version>`` should not be ""all freestanding""","February 2023","","",""
diff --git a/libcxx/include/__memory/uses_allocator_construction.h b/libcxx/include/__memory/uses_allocator_construction.h
index a2e4f6e26f4b3af..71ae5bcd323315b 100644
--- a/libcxx/include/__memory/uses_allocator_construction.h
+++ b/libcxx/include/__memory/uses_allocator_construction.h
@@ -12,6 +12,7 @@
#include <__config>
#include <__memory/construct_at.h>
#include <__memory/uses_allocator.h>
+#include <__tuple/pair_like.h>
#include <__type_traits/enable_if.h>
#include <__type_traits/is_same.h>
#include <__type_traits/remove_cv.h>
@@ -36,15 +37,19 @@ inline constexpr bool __is_std_pair = false;
template <class _Type1, class _Type2>
inline constexpr bool __is_std_pair<pair<_Type1, _Type2>> = true;
-template <class _Type, class _Alloc, class... _Args, __enable_if_t<!__is_std_pair<_Type>, int> = 0>
+template <class _Tp>
+inline constexpr bool __is_cv_std_pair = __is_std_pair<remove_cv_t<_Tp>>;
+
+template <class _Type, class _Alloc, class... _Args, __enable_if_t<!__is_cv_std_pair<_Type>, int> = 0>
_LIBCPP_HIDE_FROM_ABI constexpr auto
__uses_allocator_construction_args(const _Alloc& __alloc, _Args&&... __args) noexcept {
- if constexpr (!uses_allocator_v<_Type, _Alloc> && is_constructible_v<_Type, _Args...>) {
+ if constexpr (!uses_allocator_v<remove_cv_t<_Type>, _Alloc> && is_constructible_v<_Type, _Args...>) {
return std::forward_as_tuple(std::forward<_Args>(__args)...);
- } else if constexpr (uses_allocator_v<_Type, _Alloc> &&
+ } else if constexpr (uses_allocator_v<remove_cv_t<_Type>, _Alloc> &&
is_constructible_v<_Type, allocator_arg_t, const _Alloc&, _Args...>) {
return tuple<allocator_arg_t, const _Alloc&, _Args&&...>(allocator_arg, __alloc, std::forward<_Args>(__args)...);
- } else if constexpr (uses_allocator_v<_Type, _Alloc> && is_constructible_v<_Type, _Args..., const _Alloc&>) {
+ } else if constexpr (uses_allocator_v<remove_cv_t<_Type>, _Alloc> &&
+ is_constructible_v<_Type, _Args..., const _Alloc&>) {
return std::forward_as_tuple(std::forward<_Args>(__args)..., __alloc);
} else {
static_assert(
@@ -52,7 +57,7 @@ __uses_allocator_construction_args(const _Alloc& __alloc, _Args&&... __args) noe
}
}
-template <class _Pair, class _Alloc, class _Tuple1, class _Tuple2, __enable_if_t<__is_std_pair<_Pair>, int> = 0>
+template <class _Pair, class _Alloc, class _Tuple1, class _Tuple2, __enable_if_t<__is_cv_std_pair<_Pair>, int> = 0>
_LIBCPP_HIDE_FROM_ABI constexpr auto __uses_allocator_construction_args(
const _Alloc& __alloc, piecewise_construct_t, _Tuple1&& __x, _Tuple2&& __y) noexcept {
return std::make_tuple(
@@ -71,12 +76,12 @@ _LIBCPP_HIDE_FROM_ABI constexpr auto __uses_allocator_construction_args(
std::forward<_Tuple2>(__y)));
}
-template <class _Pair, class _Alloc, __enable_if_t<__is_std_pair<_Pair>, int> = 0>
+template <class _Pair, class _Alloc, __enable_if_t<__is_cv_std_pair<_Pair>, int> = 0>
_LIBCPP_HIDE_FROM_ABI constexpr auto __uses_allocator_construction_args(const _Alloc& __alloc) noexcept {
return std::__uses_allocator_construction_args<_Pair>(__alloc, piecewise_construct, tuple<>{}, tuple<>{});
}
-template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_std_pair<_Pair>, int> = 0>
+template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_cv_std_pair<_Pair>, int> = 0>
_LIBCPP_HIDE_FROM_ABI constexpr auto
__uses_allocator_construction_args(const _Alloc& __alloc, _Up&& __u, _Vp&& __v) noexcept {
return std::__uses_allocator_construction_args<_Pair>(
@@ -87,7 +92,7 @@ __uses_allocator_construction_args(const _Alloc& __alloc, _Up&& __u, _Vp&& __v)
}
# if _LIBCPP_STD_VER >= 23
-template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_std_pair<_Pair>, int> = 0>
+template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_cv_std_pair<_Pair>, int> = 0>
_LIBCPP_HIDE_FROM_ABI constexpr auto
__uses_allocator_construction_args(const _Alloc& __alloc, pair<_Up, _Vp>& __pair) noexcept {
return std::__uses_allocator_construction_args<_Pair>(
@@ -95,14 +100,14 @@ __uses_allocator_construction_args(const _Alloc& __alloc, pair<_Up, _Vp>& __pair
}
# endif
-template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_std_pair<_Pair>, int> = 0>
+template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_cv_std_pair<_Pair>, int> = 0>
_LIBCPP_HIDE_FROM_ABI constexpr auto
__uses_allocator_construction_args(const _Alloc& __alloc, const pair<_Up, _Vp>& __pair) noexcept {
return std::__uses_allocator_construction_args<_Pair>(
__alloc, piecewise_construct, std::forward_as_tuple(__pair.first), std::forward_as_tuple(__pair.second));
}
-template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_std_pair<_Pair>, int> = 0>
+template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_cv_std_pair<_Pair>, int> = 0>
_LIBCPP_HIDE_FROM_ABI constexpr auto
__uses_allocator_construction_args(const _Alloc& __alloc, pair<_Up, _Vp>&& __pair) noexcept {
return std::__uses_allocator_construction_args<_Pair>(
@@ -113,7 +118,7 @@ __uses_allocator_construction_args(const _Alloc& __alloc, pair<_Up, _Vp>&& __pai
}
# if _LIBCPP_STD_VER >= 23
-template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_std_pair<_Pair>, int> = 0>
+template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_cv_std_pair<_Pair>, int> = 0>
_LIBCPP_HIDE_FROM_ABI constexpr auto
__uses_allocator_construction_args(const _Alloc& __alloc, const pair<_Up, _Vp>&& __pair) noexcept {
return std::__uses_allocator_construction_args<_Pair>(
@@ -122,6 +127,20 @@ __uses_allocator_construction_args(const _Alloc& __alloc, const pair<_Up, _Vp>&&
std::forward_as_tuple(std::get<0>(std::move(__pair))),
std::forward_as_tuple(std::get<1>(std::move(__pair))));
}
+
+template < class _Pair,
+ class _Alloc,
+ __pair_like _PairLike,
+ __enable_if_t<__is_cv_std_pair<_Pair> && !__is_specialization_of_subrange<remove_cvref_t<_PairLike>>::value,
+ int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr auto
+__uses_allocator_construction_args(const _Alloc& __alloc, _PairLike&& __p) noexcept {
+ return std::__uses_allocator_construction_args<_Pair>(
+ __alloc,
+ piecewise_construct,
+ std::forward_as_tuple(std::get<0>(std::forward<_PairLike>(__p))),
+ std::forward_as_tuple(std::get<1>(std::forward<_PairLike>(__p))));
+}
# endif
namespace __uses_allocator_detail {
@@ -139,23 +158,33 @@ template <class _Tp>
inline constexpr bool __convertible_to_const_pair_ref =
decltype(__uses_allocator_detail::__convertible_to_const_pair_ref_impl<_Tp>(0))::value;
+# if _LIBCPP_STD_VER >= 23
+template <class _Tp, class _Up>
+inline constexpr bool __uses_allocator_constraints =
+ __is_cv_std_pair<_Tp> &&
+ (__is_specialization_of_subrange<remove_cvref_t<_Up>>::value ||
+ (!__pair_like<_Up> && !__convertible_to_const_pair_ref<_Up>));
+# else
+template <class _Tp, class _Up>
+inline constexpr bool __uses_allocator_constraints = __is_cv_std_pair<_Tp> && !__convertible_to_const_pair_ref<_Up>;
+# endif
+
} // namespace __uses_allocator_detail
-template <
- class _Pair,
- class _Alloc,
- class _Type,
- __enable_if_t<__is_std_pair<_Pair> && !__uses_allocator_detail::__convertible_to_const_pair_ref<_Type>, int> = 0>
+template < class _Pair,
+ class _Alloc,
+ class _Type,
+ __enable_if_t<__uses_allocator_detail::__uses_allocator_constraints<_Pair, _Type>, int> = 0>
_LIBCPP_HIDE_FROM_ABI constexpr auto
__uses_allocator_construction_args(const _Alloc& __alloc, _Type&& __value) noexcept;
template <class _Type, class _Alloc, class... _Args>
_LIBCPP_HIDE_FROM_ABI constexpr _Type __make_obj_using_allocator(const _Alloc& __alloc, _Args&&... __args);
-template <class _Pair,
- class _Alloc,
- class _Type,
- __enable_if_t<__is_std_pair<_Pair> && !__uses_allocator_detail::__convertible_to_const_pair_ref<_Type>, int>>
+template < class _Pair,
+ class _Alloc,
+ class _Type,
+ __enable_if_t< __uses_allocator_detail::__uses_allocator_constraints<_Pair, _Type>, int>>
_LIBCPP_HIDE_FROM_ABI constexpr auto
__uses_allocator_construction_args(const _Alloc& __alloc, _Type&& __value) noexcept {
struct __pair_constructor {
diff --git a/libcxx/include/__utility/pair.h b/libcxx/include/__utility/pair.h
index 62dac6dd1da3f02..535344eb1e2d63f 100644
--- a/libcxx/include/__utility/pair.h
+++ b/libcxx/include/__utility/pair.h
@@ -284,7 +284,8 @@ struct _LIBCPP_TEMPLATE_VIS pair
}
template <__pair_like _PairLike>
- requires(is_constructible_v<first_type, decltype(std::get<0>(std::declval<_PairLike&&>()))> &&
+ requires(!__is_specialization_of_subrange<remove_cvref_t<_PairLike>>::value &&
+ is_constructible_v<first_type, decltype(std::get<0>(std::declval<_PairLike&&>()))> &&
is_constructible_v<second_type, decltype(std::get<1>(std::declval<_PairLike&&>()))>)
_LIBCPP_HIDE_FROM_ABI constexpr explicit(__pair_like_explicit_wknd<_PairLike>())
pair(_PairLike&& __p)
diff --git a/libcxx/include/memory b/libcxx/include/memory
index cd6bcc7eaa35d76..24ba82f43ddd309 100644
--- a/libcxx/include/memory
+++ b/libcxx/include/memory
@@ -867,6 +867,43 @@ template <class T> struct hash<shared_ptr<T> >;
template <class T, class Alloc>
inline constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value;
+// [allocator.uses.construction], uses-allocator construction
+template<class T, class Alloc, class... Args>
+ constexpr auto uses_allocator_construction_args(const Alloc& alloc, // since C++20
+ Args&&... args) noexcept;
+template<class T, class Alloc, class Tuple1, class Tuple2>
+ constexpr auto uses_allocator_construction_args(const Alloc& alloc, // since C++20
+ piecewise_construct_t,
+ Tuple1&& x, Tuple2&& y) noexcept;
+template<class T, class Alloc>
+ constexpr auto uses_allocator_construction_args(const Alloc& alloc) noexcept; // since C++20
+template<class T, class Alloc, class U, class V>
+ constexpr auto uses_allocator_construction_args(const Alloc& alloc, // since C++20
+ U&& u, V&& v) noexcept;
+template<class T, class Alloc, class U, class V>
+ constexpr auto uses_allocator_construction_args(const Alloc& alloc, // since C++23
+ pair<U, V>& pr) noexcept;
+template<class T, class Alloc, class U, class V>
+ constexpr auto uses_allocator_construction_args(const Alloc& alloc, // since C++20
+ const pair<U, V>& pr) noexcept;
+template<class T, class Alloc, class U, class V>
+ constexpr auto uses_allocator_construction_args(const Alloc& alloc, // since C++20
+ pair<U, V>&& pr) noexcept;
+template<class T, class Alloc, class U, class V>
+ constexpr auto uses_allocator_construction_args(const Alloc& alloc, // since C++23
+ const pair<U, V>&& pr) noexcept;
+template<class T, class Alloc, pair-like P>
+ constexpr auto uses_allocator_construction_args(const Alloc& alloc, // since C++20
+ P&& p) noexcept;
+template<class T, class Alloc, class U>
+ constexpr auto uses_allocator_construction_args(const Alloc& alloc, // since C++20
+ U&& u) noexcept;
+template<class T, class Alloc, class... Args>
+ constexpr T make_obj_using_allocator(const Alloc& alloc, Args&&... args); // since C++20
+template<class T, class Alloc, class... Args>
+ constexpr T* uninitialized_construct_using_allocator(T* p, // since C++20
+ const Alloc& alloc, Args&&... args);
+
// [ptr.align]
void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
diff --git a/libcxx/test/std/depr/depr.numeric.imits.has.denorm/deprecated.verify.cpp b/libcxx/test/std/depr/depr.numeric.imits.has.denorm/deprecated.verify.cpp
index 82f838c57f1e448..98d49de80a58cfa 100644
--- a/libcxx/test/std/depr/depr.numeric.imits.has.denorm/deprecated.verify.cpp
+++ b/libcxx/test/std/depr/depr.numeric.imits.has.denorm/deprecated.verify.cpp
@@ -91,8 +91,9 @@ void func() {
std::numeric_limits<const volatile double>::has_denorm_loss; // expected-warning {{'has_denorm_loss' is deprecated}}
std::numeric_limits<const volatile double>::denorm_min();
- std::numeric_limits<const volatile long double>::has_denorm; // expected-warning {{'has_denorm' is deprecated}}
- std::numeric_limits<const volatile long double>::has_denorm_loss; // expected-warning {{'has_denorm_loss' is deprecated}}
+ std::numeric_limits<const volatile long double>::has_denorm; // expected-warning {{'has_denorm' is deprecated}}
+ std::numeric_limits<
+ const volatile long double>::has_denorm_loss; // expected-warning {{'has_denorm_loss' is deprecated}}
std::numeric_limits<const volatile long double>::denorm_min();
std::denorm_indeterminate; // expected-warning {{'denorm_indeterminate' is deprecated}}
diff --git a/libcxx/test/std/ranges/range.utility/range.subrange/operator.pair_like.pass.cpp b/libcxx/test/std/ranges/range.utility/range.subrange/operator.pair_like.pass.cpp
new file mode 100644
index 000000000000000..1d0dfd05b3f7e2b
--- /dev/null
+++ b/libcxx/test/std/ranges/range.utility/range.subrange/operator.pair_like.pass.cpp
@@ -0,0 +1,80 @@
+
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// template<
diff erent-from<subrange> PairLike>
+// requires pair-like-convertible-from<PairLike, const I&, const S&>
+// constexpr operator PairLike() const;
+
+#include <cassert>
+#include <concepts>
+#include <ranges>
+
+#include "test_macros.h"
+
+static_assert(std::convertible_to<std::ranges::subrange<int*>, std::pair<int*, int*>>);
+static_assert(std::convertible_to<std::ranges::subrange<int*>, std::tuple<int*, int*>>);
+static_assert(!std::convertible_to<std::ranges::subrange<int*>, std::pair<long*, int*>>);
+static_assert(!std::convertible_to<std::ranges::subrange<int*>, std::pair<int*, long*>>);
+static_assert(!std::convertible_to<std::ranges::subrange<int*>, std::pair<long*, long*>>);
+static_assert(!std::convertible_to<std::ranges::subrange<int*>, std::array<int*, 2>>);
+
+constexpr bool test() {
+ // Check to std::pair
+ {
+ int data[] = {1, 2, 3, 4, 5};
+ const std::ranges::subrange a(data);
+ {
+ std::pair<int*, int*> p(a);
+ assert(p.first == data + 0);
+ assert(p.second == data + 5);
+ }
+ {
+ std::pair<int*, int*> p{a};
+ assert(p.first == data + 0);
+ assert(p.second == data + 5);
+ }
+ {
+ std::pair<int*, int*> p = a;
+ assert(p.first == data + 0);
+ assert(p.second == data + 5);
+ }
+ }
+
+ // Check to std::tuple
+ {
+ int data[] = {1, 2, 3, 4, 5};
+ const std::ranges::subrange a(data);
+ {
+ std::tuple<int*, int*> p(a);
+ assert(std::get<0>(p) == data + 0);
+ assert(std::get<1>(p) == data + 5);
+ }
+ {
+ std::tuple<int*, int*> p{a};
+ assert(std::get<0>(p) == data + 0);
+ assert(std::get<1>(p) == data + 5);
+ }
+ {
+ std::tuple<int*, int*> p = a;
+ assert(std::get<0>(p) == data + 0);
+ assert(std::get<1>(p) == data + 5);
+ }
+ }
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/memory/allocator.uses/allocator.uses.construction/uses_allocator_construction_args.pass.cpp b/libcxx/test/std/utilities/memory/allocator.uses/allocator.uses.construction/uses_allocator_construction_args.pass.cpp
index 739278e74ddab4f..ab3c039497dd955 100644
--- a/libcxx/test/std/utilities/memory/allocator.uses/allocator.uses.construction/uses_allocator_construction_args.pass.cpp
+++ b/libcxx/test/std/utilities/memory/allocator.uses/allocator.uses.construction/uses_allocator_construction_args.pass.cpp
@@ -16,6 +16,7 @@
#include <concepts>
#include <memory>
+#include <ranges>
#include <tuple>
#include <utility>
@@ -28,25 +29,27 @@ constexpr decltype(auto) test_uses_allocator_construction_args(Args&&... args) {
return std::uses_allocator_construction_args<Type>(std::forward<Args>(args)...);
}
-constexpr bool test() {
+template <template <class> class CV>
+constexpr void testOne() {
Alloc a(12);
{
std::same_as<std::tuple<std::allocator_arg_t, const Alloc&>> auto ret =
- test_uses_allocator_construction_args<UsesAllocArgT>(a);
+ test_uses_allocator_construction_args<CV<UsesAllocArgT>>(a);
assert(std::get<1>(ret).get_data() == 12);
}
{
- std::same_as<std::tuple<const Alloc&>> auto ret = test_uses_allocator_construction_args<UsesAllocLast>(a);
+ std::same_as<std::tuple<const Alloc&>> auto ret = test_uses_allocator_construction_args<CV<UsesAllocLast>>(a);
assert(std::get<0>(ret).get_data() == 12);
}
{
- [[maybe_unused]] std::same_as<std::tuple<>> auto ret = test_uses_allocator_construction_args<NotAllocatorAware>(a);
+ [[maybe_unused]] std::same_as<std::tuple<>> auto ret =
+ test_uses_allocator_construction_args<CV<NotAllocatorAware>>(a);
}
{
std::same_as<std::tuple<std::piecewise_construct_t,
std::tuple<std::allocator_arg_t, const Alloc&>,
std::tuple<const Alloc&>>> auto ret =
- test_uses_allocator_construction_args<std::pair<UsesAllocArgT, UsesAllocLast>>(
+ test_uses_allocator_construction_args<CV<std::pair<UsesAllocArgT, UsesAllocLast>>>(
a, std::piecewise_construct, std::tuple<>{}, std::tuple<>{});
assert(std::get<1>(std::get<1>(ret)).get_data() == 12);
assert(std::get<0>(std::get<2>(ret)).get_data() == 12);
@@ -55,7 +58,7 @@ constexpr bool test() {
std::same_as<std::tuple<std::piecewise_construct_t,
std::tuple<std::allocator_arg_t, const Alloc&>,
std::tuple<const Alloc&>>> auto ret =
- test_uses_allocator_construction_args<std::pair<UsesAllocArgT, UsesAllocLast>>(a);
+ test_uses_allocator_construction_args<CV<std::pair<UsesAllocArgT, UsesAllocLast>>>(a);
assert(std::get<1>(std::get<1>(ret)).get_data() == 12);
assert(std::get<0>(std::get<2>(ret)).get_data() == 12);
}
@@ -64,7 +67,7 @@ constexpr bool test() {
std::same_as<std::tuple<std::piecewise_construct_t,
std::tuple<std::allocator_arg_t, const Alloc&, int&>,
std::tuple<int&, const Alloc&>>> auto ret =
- test_uses_allocator_construction_args<std::pair<UsesAllocArgT, UsesAllocLast>>(a, val, val);
+ test_uses_allocator_construction_args<CV<std::pair<UsesAllocArgT, UsesAllocLast>>>(a, val, val);
assert(std::get<1>(std::get<1>(ret)).get_data() == 12);
assert(std::get<1>(std::get<2>(ret)).get_data() == 12);
assert(&std::get<2>(std::get<1>(ret)) == &val);
@@ -75,7 +78,7 @@ constexpr bool test() {
std::same_as<std::tuple<std::piecewise_construct_t,
std::tuple<std::allocator_arg_t, const Alloc&, int&&>,
std::tuple<int&&, const Alloc&>>> auto ret =
- test_uses_allocator_construction_args<std::pair<UsesAllocArgT, UsesAllocLast>>(
+ test_uses_allocator_construction_args<CV<std::pair<UsesAllocArgT, UsesAllocLast>>>(
a, std::move(val), std::move(val));
assert(std::get<1>(std::get<1>(ret)).get_data() == 12);
assert(std::get<1>(std::get<2>(ret)).get_data() == 12);
@@ -89,7 +92,7 @@ constexpr bool test() {
std::same_as<std::tuple<std::piecewise_construct_t,
std::tuple<std::allocator_arg_t, const Alloc&, int&>,
std::tuple<int&, const Alloc&>>> auto ret =
- test_uses_allocator_construction_args<std::pair<UsesAllocArgT, UsesAllocLast>>(a, p);
+ test_uses_allocator_construction_args<CV<std::pair<UsesAllocArgT, UsesAllocLast>>>(a, p);
assert(std::get<1>(std::get<1>(ret)).get_data() == 12);
assert(std::get<1>(std::get<2>(ret)).get_data() == 12);
assert(std::get<2>(std::get<1>(ret)) == 3);
@@ -101,7 +104,7 @@ constexpr bool test() {
std::same_as<std::tuple<std::piecewise_construct_t,
std::tuple<std::allocator_arg_t, const Alloc&, const int&>,
std::tuple<const int&, const Alloc&>>> auto ret =
- test_uses_allocator_construction_args<std::pair<UsesAllocArgT, UsesAllocLast>>(a, std::as_const(p));
+ test_uses_allocator_construction_args<CV<std::pair<UsesAllocArgT, UsesAllocLast>>>(a, std::as_const(p));
assert(std::get<1>(std::get<1>(ret)).get_data() == 12);
assert(std::get<1>(std::get<2>(ret)).get_data() == 12);
assert(std::get<2>(std::get<1>(ret)) == 3);
@@ -112,7 +115,7 @@ constexpr bool test() {
std::same_as<std::tuple<std::piecewise_construct_t,
std::tuple<std::allocator_arg_t, const Alloc&, int&&>,
std::tuple<int&&, const Alloc&>>> auto ret =
- test_uses_allocator_construction_args<std::pair<UsesAllocArgT, UsesAllocLast>>(a, std::move(p));
+ test_uses_allocator_construction_args<CV<std::pair<UsesAllocArgT, UsesAllocLast>>>(a, std::move(p));
assert(std::get<1>(std::get<1>(ret)).get_data() == 12);
assert(std::get<1>(std::get<2>(ret)).get_data() == 12);
assert(std::get<2>(std::get<1>(ret)) == 3);
@@ -124,7 +127,8 @@ constexpr bool test() {
std::same_as<std::tuple<std::piecewise_construct_t,
std::tuple<std::allocator_arg_t, const Alloc&, const int&&>,
std::tuple<const int&&, const Alloc&>>> auto ret =
- test_uses_allocator_construction_args<std::pair<UsesAllocArgT, UsesAllocLast>>(a, std::move(std::as_const(p)));
+ test_uses_allocator_construction_args<CV<std::pair<UsesAllocArgT, UsesAllocLast>>>(
+ a, std::move(std::as_const(p)));
assert(std::get<1>(std::get<1>(ret)).get_data() == 12);
assert(std::get<1>(std::get<2>(ret)).get_data() == 12);
assert(std::get<2>(std::get<1>(ret)) == 3);
@@ -132,19 +136,57 @@ constexpr bool test() {
}
#endif
{
- ConvertibleToPair ctp {};
- auto ret = test_uses_allocator_construction_args<std::pair<int, int>>(a, ctp);
+ ConvertibleToPair ctp{};
+ auto ret = test_uses_allocator_construction_args<CV<std::pair<int, int>>>(a, ctp);
std::pair<int, int> v = std::get<0>(ret);
assert(std::get<0>(v) == 1);
assert(std::get<1>(v) == 2);
}
{
- ConvertibleToPair ctp {};
- auto ret = test_uses_allocator_construction_args<std::pair<int, int>>(a, std::move(ctp));
+ ConvertibleToPair ctp{};
+ auto ret = test_uses_allocator_construction_args<CV<std::pair<int, int>>>(a, std::move(ctp));
std::pair<int, int> v = std::get<0>(ret);
assert(std::get<0>(v) == 1);
assert(std::get<1>(v) == 2);
}
+#if TEST_STD_VER >= 23
+ // P2165R4 with LWG3821 applied
+ // uses_allocator_construction_args should have overload for pair-like
+ {
+ // pair-like with explicit ctr should work
+ struct Foo {
+ int i = 5;
+ };
+ struct Bar {
+ int i;
+ constexpr explicit Bar(Foo foo) : i(foo.i) {}
+ };
+
+ std::tuple<Foo, Foo> pair_like;
+ auto ret = test_uses_allocator_construction_args<CV<std::pair<Bar, Bar>>>(a, pair_like);
+ auto pair = std::make_from_tuple<std::pair<Bar, Bar>>(std::move(ret));
+ assert(pair.first.i == 5);
+ assert(pair.second.i == 5);
+ }
+ {
+ // subrange should work
+ int i = 5;
+ std::ranges::subrange<int*, int*> r{&i, &i};
+ auto ret = test_uses_allocator_construction_args<CV<std::pair<int*, int*>>>(a, r);
+ auto pair = std::make_from_tuple<std::pair<int*, int*>>(std::move(ret));
+ assert(pair.first == &i);
+ assert(pair.second == &i);
+ }
+#endif
+}
+
+constexpr bool test() {
+ testOne<std::type_identity_t>();
+
+ // LWG 3677. Is a cv-qualified pair specially handled in uses-allocator construction
+ testOne<std::add_const_t>();
+ testOne<std::add_volatile_t>();
+ testOne<std::add_cv_t>();
return true;
}
diff --git a/libcxx/test/std/utilities/utility/pairs/pairs.pair/ctor.pair_like.pass.cpp b/libcxx/test/std/utilities/utility/pairs/pairs.pair/ctor.pair_like.pass.cpp
index b93adb0ef3ebc6d..3810c4450e57fd7 100644
--- a/libcxx/test/std/utilities/utility/pairs/pairs.pair/ctor.pair_like.pass.cpp
+++ b/libcxx/test/std/utilities/utility/pairs/pairs.pair/ctor.pair_like.pass.cpp
@@ -79,25 +79,15 @@ constexpr bool test() {
static_assert(!std::is_constructible_v<std::pair<int, int>, std::tuple<int, int, int>>); // too large
}
- // Check from ranges::subrange
+ // Check that the constructor excludes ranges::subrange
{
int data[] = {1, 2, 3, 4, 5};
- std::ranges::subrange a(data);
- {
- std::pair<int*, int*> p(a);
- assert(p.first == data + 0);
- assert(p.second == data + 5);
- }
- {
- std::pair<int*, int*> p{a};
- assert(p.first == data + 0);
- assert(p.second == data + 5);
- }
- {
- std::pair<int*, int*> p = a;
- assert(p.first == data + 0);
- assert(p.second == data + 5);
- }
+ const std::ranges::subrange a(data);
+ // Note the expression below would be ambiguous if pair's
+ // constructor does not exclude subrange
+ std::pair<int*, int*> p = a;
+ assert(p.first == data + 0);
+ assert(p.second == data + 5);
}
}
diff --git a/libcxx/utils/data/ignore_format.txt b/libcxx/utils/data/ignore_format.txt
index 8f929c2c0a23651..1d0a6b0b7ef5f8f 100644
--- a/libcxx/utils/data/ignore_format.txt
+++ b/libcxx/utils/data/ignore_format.txt
@@ -6512,7 +6512,6 @@ libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.types/void_po
libcxx/test/std/utilities/memory/allocator.traits/allocator_type.pass.cpp
libcxx/test/std/utilities/memory/allocator.traits/rebind_traits.pass.cpp
libcxx/test/std/utilities/memory/allocator.traits/value_type.pass.cpp
-libcxx/test/std/utilities/memory/allocator.uses/allocator.uses.construction/uses_allocator_construction_args.pass.cpp
libcxx/test/std/utilities/memory/allocator.uses/allocator.uses.trait/uses_allocator.pass.cpp
libcxx/test/std/utilities/memory/c.malloc/nothing_to_do.pass.cpp
libcxx/test/std/utilities/memory/default.allocator/allocator.ctor.pass.cpp
More information about the libcxx-commits
mailing list