[libc++] Implement P0591R4 (Utility functions to implement uses-allocator construction)

[ldionne]

Please go through D58879 and reuse anything useful (esp. from the tests). Including comments like https://reviews.llvm.org/D58879#1546317. Then we can close D58879 since this supersedes it.

libcxx/include/__memory/uses_allocator_construction.h

31

Maybe this should be three functions instead, it would be easier to read.

151

FYI this seems to be the resolution of http://wg21.link/LWG3525. I assume now you know how to test it?

[huixie90]

libcxx/include/__memory/uses_allocator_construction.h

23

I am slightly confused by the versions. The paper seems to be C++20, but all the internal __ functions are targeting C++17, and then the tests are running on all language versions?

52

As you mentioned in another thread, should be use int = __enable_if_t<b, int> = 0 instead through out the change?

54

is noexcept missing here? Is there a test?

88

I believe this is part of the zip paper, which is c++23. perhaps you need to branch under different language versions?

112

I believe this is part of the "zip" paper and perhaps you can update the zip project csv as well. I have a patch related to pair ongoing as well which skipped this part
https://reviews.llvm.org/D131495

123

nit: can we change its name to be more unique? the chance of other people using the name __detail::__fun is not zero

132

inline

152

nit: what does Mut mean?

168

does parenthesis work for c++17 to init aggregates?

libcxx/test/std/utilities/memory/allocator.uses/allocator.uses.construction/uses_allocator_construction_args.pass.cpp

63

why maybe_unused? it seems that you are using the result in most of the tests

[philnik]

• Address comments

libcxx/include/__memory/uses_allocator_construction.h

23

polymorphic_allocator uses uses-allocator-construction, which this implements. So instead of implementing it twice we can use the same implementation. The tests were just an oversight.

31

I read the standard again, and the program is actually ill-formed if none of the if constexpr conditions are met.

52

Yes. I wrote this before the discussion. Thanks for not letting me produce more work for myself!

54

Good catch! Added a regression test.

152

mutable

168

Nope, replaced it with {}.

libcxx/test/std/utilities/memory/allocator.uses/allocator.uses.construction/uses_allocator_construction_args.pass.cpp

63

Because I forgot to remove it.

[philnik]

• Fix CI; update scoped_allocator_adaptor

[ldionne]

Leaving final approval to @huixie90

libcxx/include/__memory/uses_allocator_construction.h

152

I think Mutable would be clearer, especially given the question. I had the same.

libcxx/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp

56

Would it be valid to pass it as a const& before C++20?

[huixie90]

Almost LGTM. Just two small clarification questions

libcxx/include/__memory/uses_allocator_construction.h

132

question : do we need hidden from abi macro for inline constexpr variables

172

In your original version , this is doing sfinae, but now you’ve changed the use_allocator_constructution_args to static_assert in the function body. Does this still do the things you want?

[philnik]

libcxx/include/__memory/uses_allocator_construction.h

132

We don't do it anywhere else and it would also kind-of defeat the purpose of marking it inline. I don't think it will ever be emitted anyways, since AFAIK the only time clang will emit the symbol is when you take the address of it, which we will never do.

172

Yes. The instantiation error is actually requested by the standard, so this fails correctly.

[philnik]

• Try to fix CI

[philnik]

• Address comments

libcxx/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp

56

I'll look into that after this patch. If it's the case I'll create a follow-up to fix the tests.

[philnik]

• Try to fix CI

[philnik]

• Fix CI

[philnik]

• Try to fix CI

[philnik]

• Fix includes

[philnik]

Landing this again, since the CI is green with the updated transitive includes test.

libcxx/docs/ReleaseNotes.rst

 ============================
 
 Implemented Papers
 ------------------
 - P2499R0 - ``string_view`` range constructor should be ``explicit``
 - P2417R2 - A more constexpr bitset
 - P2445R1 - ``std::forward_like``
 - P2273R3 - Making ``std::unique_ptr`` constexpr
+- P0591R4 - Utility functions to implement uses-allocator construction
 
 Improvements and New Features
 -----------------------------
 - Declarations of ``std::c8rtomb()`` and ``std::mbrtoc8()`` from P0482R6 are
   now provided when implementations in the global namespace are provided by
   the C library.
 
 Deprecations and Removals

libcxx/docs/Status/Cxx20.rst

 
 .. csv-table::
    :file: Cxx20Papers.csv
    :header-rows: 1
    :widths: auto
 
 .. note::
 
+   .. [#note-P0591] P0591: The changes in [mem.poly.allocator.mem] are missing.
    .. [#note-P0600] P0600: The missing bits in P0600 are in |sect|\ [mem.res.class] and |sect|\ [mem.poly.allocator.class].
    .. [#note-P0645] P0645: The paper is implemented but still marked as an incomplete feature
       (the feature-test macro is not set and the libary is only available when built with ``-fexperimental-library``).
       Not yet implemented LWG-issues will cause API and ABI breakage.
    .. [#note-P0966] P0966: It was previously erroneously marked as complete in version 8.0. See `bug 45368 <https://llvm.org/PR45368>`__.
    .. [#note-P0619] P0619: Only sections D.8, D.9, D.10 and D.13 are implemented. Sections D.4, D.7, D.11, D.12, and D.14 remain undone.
    .. [#note-P0883.1] P0883: shared_ptr and floating-point changes weren't applied as they themselves aren't implemented yet.
    .. [#note-P0883.2] P0883: ``ATOMIC_FLAG_INIT`` was marked deprecated in version 14.0, but was undeprecated with the implementation of LWG3659 in version 15.0.

libcxx/docs/Status/Cxx20Issues.csv

 "`3182 <https://wg21.link/LWG3182>`__","Specification of ``Same``\  could be clearer","Kona","|Complete|","15.0"
 "","","","",""
 "`2899 <https://wg21.link/LWG2899>`__","``is_(nothrow_)move_constructible``\  and ``tuple``\ , ``optional``\  and ``unique_ptr``\ ","Cologne","",""
 "`3055 <https://wg21.link/LWG3055>`__","``path::operator+=(*single-character*)``\  misspecified","Cologne","|Complete|","7.0"
 "`3158 <https://wg21.link/LWG3158>`__","``tuple(allocator_arg_t, const Alloc&)``\  should be conditionally explicit","Cologne","|Complete|","10.0"
 "`3169 <https://wg21.link/LWG3169>`__","``ranges``\  permutation generators discard useful information","Cologne","|Complete|","15.0","|ranges|"
 "`3183 <https://wg21.link/LWG3183>`__","Normative permission to specialize Ranges variable templates","Cologne","|Nothing To Do|","","|ranges|"
 "`3184 <https://wg21.link/LWG3184>`__","Inconsistencies in ``bind_front``\  wording","Cologne","|Complete|","13.0"
-"`3185 <https://wg21.link/LWG3185>`__","Uses-allocator construction functions missing ``constexpr``\  and ``noexcept``\ ","Cologne","",""
+"`3185 <https://wg21.link/LWG3185>`__","Uses-allocator construction functions missing ``constexpr``\  and ``noexcept``\ ","Cologne","|Complete|","16.0"
 "`3186 <https://wg21.link/LWG3186>`__","``ranges``\  removal, partition, and ``partial_sort_copy``\  algorithms discard useful information","Cologne","|Complete|","15.0","|ranges|"
 "`3187 <https://wg21.link/LWG3187>`__","`P0591R4 <https://wg21.link/p0591r4>`__ reverted DR 2586 fixes to ``scoped_allocator_adaptor::construct()``\ ","Cologne","",""
 "`3191 <https://wg21.link/LWG3191>`__","``std::ranges::shuffle``\  synopsis does not match algorithm definition","Cologne","|Complete|","15.0","|ranges|"
 "`3196 <https://wg21.link/LWG3196>`__","``std::optional<T>``\  is ill-formed is ``T``\  is an array","Cologne","|Complete|",""
 "`3198 <https://wg21.link/LWG3198>`__","Bad constraint on ``std::span::span()``\ ","Cologne","|Complete|",""
 "`3199 <https://wg21.link/LWG3199>`__","``istream >> bitset<0>``\  fails","Cologne","",""
 "`3202 <https://wg21.link/LWG3202>`__","P0318R1 was supposed to be revised","Cologne","|Complete|",""
 "`3206 <https://wg21.link/LWG3206>`__","``year_month_day``\  conversion to ``sys_days``\  uses not-existing member function","Cologne","|Complete|",""

 "`3313 <https://wg21.link/LWG3313>`__","``join_view::iterator::operator--``\  is incorrectly constrained","Prague","|Complete|","14.0","|ranges|"
 "`3314 <https://wg21.link/LWG3314>`__","Is stream insertion behavior locale dependent when ``Period::type``\  is ``micro``\ ?","Prague","","","|chrono|"
 "`3315 <https://wg21.link/LWG3315>`__","Correct Allocator Default Behavior","Prague","",""
 "`3316 <https://wg21.link/LWG3316>`__","Correctly define epoch for ``utc_clock``\  / ``utc_timepoint``\ ","Prague","","","|chrono|"
 "`3317 <https://wg21.link/LWG3317>`__","Incorrect ``operator<<``\  for floating-point durations","Prague","","","|chrono|"
 "`3318 <https://wg21.link/LWG3318>`__","Clarify whether clocks can represent time before their epoch","Prague","","","|chrono|"
 "`3319 <https://wg21.link/LWG3319>`__","Properly reference specification of IANA time zone database","Prague","","","|chrono|"
 "`3320 <https://wg21.link/LWG3320>`__","``span::cbegin/cend``\  methods produce different results than ``std::[ranges::]cbegin/cend``\ ","Prague","|Complete|",""
-"`3321 <https://wg21.link/LWG3321>`__","``uninitialized_construct_using_allocator``\  should use ``construct_at``\ ","Prague","",""
+"`3321 <https://wg21.link/LWG3321>`__","``uninitialized_construct_using_allocator``\  should use ``construct_at``\ ","Prague","|Complete|","16.0"
 "`3323 <https://wg21.link/LWG3323>`__","``*has-tuple-element*``\  helper concept needs ``convertible_to``\ ","Prague","","","|ranges|"
 "`3324 <https://wg21.link/LWG3324>`__","Special-case ``std::strong/weak/partial_order``\  for pointers","Prague","|Complete|","14.0","|spaceship|"
 "`3325 <https://wg21.link/LWG3325>`__","Constrain return type of transformation function for ``transform_view``\ ","Prague","|Complete|","15.0","|ranges|"
 "`3326 <https://wg21.link/LWG3326>`__","``enable_view``\  has false positives","Prague","|Complete|","15.0","|ranges|"
 "`3327 <https://wg21.link/LWG3327>`__","Format alignment specifiers vs. text direction","Prague","|Nothing To Do|","","|format|"
 "`3328 <https://wg21.link/LWG3328>`__","Clarify that ``std::string``\  is not good for UTF-8","Prague","",""
 "`3329 <https://wg21.link/LWG3329>`__","``totally_ordered_with``\  both directly and indirectly requires ``common_reference_with``\ ","Prague","|Complete|","13.0"
 "`3330 <https://wg21.link/LWG3330>`__","Include ``<compare>``\  from most library headers","Prague","|Complete|","13.0","|spaceship|"

libcxx/docs/Status/Cxx20Papers.csv

 "`P1025R1 <https://wg21.link/P1025R1>`__","CWG","Update The Reference To The Unicode Standard","Rapperswil","",""
 "`P1120R0 <https://wg21.link/P1120R0>`__","CWG","Consistency improvements for <=> and other comparison operators","Rapperswil","",""
 "","","","","",""
 "`P0318R1 <https://wg21.link/P0318R1>`__","LWG","unwrap_ref_decay and unwrap_reference","San Diego","|Complete|","8.0"
 "`P0356R5 <https://wg21.link/P0356R5>`__","LWG","Simplified partial function application","San Diego","|Complete|","13.0"
 "`P0357R3 <https://wg21.link/P0357R3>`__","LWG","reference_wrapper for incomplete types","San Diego","|Complete|","8.0"
 "`P0482R6 <https://wg21.link/P0482R6>`__","CWG","char8_t: A type for UTF-8 characters and strings","San Diego","|Partial| [#note-P0482]_","16.0"
 "`P0487R1 <https://wg21.link/P0487R1>`__","LWG","Fixing ``operator>>(basic_istream&, CharT*)``\  (LWG 2499)","San Diego","|Complete|","8.0"
-"`P0591R4 <https://wg21.link/P0591R4>`__","LWG","Utility functions to implement uses-allocator construction","San Diego","* *",""
-"`P0595R2 <https://wg21.link/P0595R2>`__","CWG","P0595R2 std::is_constant_evaluated()","San Diego","|Complete|","9.0"
+"`P0591R4 <https://wg21.link/P0591R4>`__","LWG","Utility functions to implement uses-allocator construction","San Diego","|Partial| [#note-P0591]_",""
+"`P0595R2 <https://wg21.link/P0595R2>`__","CWG","std::is_constant_evaluated()","San Diego","|Complete|","9.0"
 "`P0602R4 <https://wg21.link/P0602R4>`__","LWG","variant and optional should propagate copy/move triviality","San Diego","|Complete|","8.0"
 "`P0608R3 <https://wg21.link/P0608R3>`__","LWG","A sane variant converting constructor","San Diego","|Complete|","9.0"
 "`P0655R1 <https://wg21.link/P0655R1>`__","LWG","visit<R>: Explicit Return Type for visit","San Diego","|Complete|","12.0"
 "`P0771R1 <https://wg21.link/P0771R1>`__","LWG","std::function move constructor should be noexcept","San Diego","|Complete|","6.0"
 "`P0896R4 <https://wg21.link/P0896R4>`__","LWG","The One Ranges Proposal","San Diego","|Complete|","15.0"
 "`P0899R1 <https://wg21.link/P0899R1>`__","LWG","P0899R1 - LWG 3016 is not a defect","San Diego","|Nothing To Do|",""
 "`P0919R3 <https://wg21.link/P0919R3>`__","LWG","Heterogeneous lookup for unordered containers","San Diego","|Complete|","12.0"
 "`P0972R0 <https://wg21.link/P0972R0>`__","LWG","<chrono> ``zero()``\ , ``min()``\ , and ``max()``\  should be noexcept","San Diego","|Complete|","8.0"

libcxx/docs/Status/ZipProjects.csv

 Section,Description,Dependencies,Assignee,Complete
 | `[tuple.syn] <https://wg21.link/tuple.syn>`_, "`[tuple] basic_common_reference, common_type <https://reviews.llvm.org/D116538>`_", None, Nikolas Klauser, |Complete|
 | `[tuple.tuple] <https://wg21.link/tuple.tuple>`_, "`[tuple] constructor, assignment and swap overloads <https://reviews.llvm.org/D116621>`_", None, Nikolas Klauser, |In Progress|
 | `[utility.syn] <https://wg21.link/utility.syn>`_, "[pair] basic_common_reference, common_type", None, Nikolas Klauser, |Complete|
 | `[pairs.pair] <https://wg21.link/pairs.pair>`_, "[pair] constructor, assignment and swap overloads", None, Nikolas Klauser, |Not Started|
 "| `[memory.syn] <https://wg21.link/memory.syn>`_
-| `[allocator.uses.construction] <https://wg21.link/allocator.uses.construction>`_", "[pair] uses_allocator_construction_args overloads", None, Unassigned, |Not Started|
+| `[allocator.uses.construction] <https://wg21.link/allocator.uses.construction>`_", "[pair] uses_allocator_construction_args overloads", None, Nikolas Klauser, |Complete|
 | `[vector.bool] <https://wg21.link/vector.bool>`_, "[vector<bool>::reference] add const operator= overload", None, Nikolas Klauser, |Not Started|
 | `[iterator.concept.winc] <https://wg21.link/iterator.concept.winc>`_, "Update weakly_comparable", None, Unassigned, |Not Started|
 | `[range.zip] <https://wg21.link/ranges.syn>`_, "`zip_view <https://reviews.llvm.org/D122806>`_", "| `zip_view::iterator`
 | `zip_view::sentinel`", Hui Xie, |Complete|
 | `[range.zip.iterator] <https://wg21.link/range.zip.iterator>`_, "`zip_view::iterator <https://reviews.llvm.org/D122806>`_", None, Hui Xie, |Complete|
 | `[range.zip.sentinel] <https://wg21.link/range.zip.sentinel>`_, "`zip_view::sentinel <https://reviews.llvm.org/D122806>`_", None, Hui Xie, |Complete|
 | `[range.zip.transform.view] <https://wg21.link/range.zip.transform.view>`_, "zip_transform_view", "| `zip_transform_view::iterator`
 | `zip_transform_view::sentinel`", Unassigned, |Not Started|

libcxx/include/CMakeLists.txt

set(files
   __memory/raw_storage_iterator.h
   __memory/shared_ptr.h
   __memory/swap_allocator.h
   __memory/temp_value.h
   __memory/temporary_buffer.h
   __memory/uninitialized_algorithms.h
   __memory/unique_ptr.h
   __memory/uses_allocator.h
+  __memory/uses_allocator_construction.h
   __memory/voidify.h
   __mutex_base
   __node_handle
   __numeric/accumulate.h
   __numeric/adjacent_difference.h
   __numeric/exclusive_scan.h
   __numeric/gcd_lcm.h
   __numeric/inclusive_scan.h

libcxx/include/__memory/uses_allocator_construction.h

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MEMORY_USES_ALLOCATOR_CONSTRUCTION_H
+#define _LIBCPP___MEMORY_USES_ALLOCATOR_CONSTRUCTION_H
+
+#include <__config>
+#include <__memory/construct_at.h>
+#include <__memory/uses_allocator.h>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_same.h>
+#include <__utility/pair.h>
+#include <tuple>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 17
+
+template <class _Type>
+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>
+_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...>) {
+    return std::forward_as_tuple(std::forward<_Args>(__args)...);
+  } else if constexpr (uses_allocator_v<_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&>) {
+    return std::forward_as_tuple(std::forward<_Args>(__args)..., __alloc);
+  } else {
+    static_assert(
+        sizeof(_Type) + 1 == 0, "If uses_allocator_v<Type> is true, the type has to be allocator-constructible");
+  }
+}
+
+template <class _Pair, class _Alloc, class _Tuple1, class _Tuple2, __enable_if_t<__is_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(
+      piecewise_construct,
+      std::apply(
+          [&__alloc](auto&&... __args1) {
+            return std::__uses_allocator_construction_args<typename _Pair::first_type>(
+                __alloc, std::forward<decltype(__args1)>(__args1)...);
+          },
+          std::forward<_Tuple1>(__x)),
+      std::apply(
+          [&__alloc](auto&&... __args2) {
+            return std::__uses_allocator_construction_args<typename _Pair::second_type>(
+                __alloc, std::forward<decltype(__args2)>(__args2)...);
+          },
+          std::forward<_Tuple2>(__y)));
+}
+
+template <class _Pair, class _Alloc, __enable_if_t<__is_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>
+_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>(
+      __alloc,
+      piecewise_construct,
+      std::forward_as_tuple(std::forward<_Up>(__u)),
+      std::forward_as_tuple(std::forward<_Vp>(__v)));
+}
+
+#  if _LIBCPP_STD_VER > 20
+template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_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>(
+      __alloc, piecewise_construct, std::forward_as_tuple(__pair.first), std::forward_as_tuple(__pair.second));
+}
+#  endif
+
+template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_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>
+_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>(
+      __alloc,
+      piecewise_construct,
+      std::forward_as_tuple(std::get<0>(std::move(__pair))),
+      std::forward_as_tuple(std::get<1>(std::move(__pair))));
+}
+
+#  if _LIBCPP_STD_VER > 20
+template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_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(std::get<0>(std::move(__pair))),
+      std::forward_as_tuple(std::get<1>(std::move(__pair))));
+}
+#  endif
+
+namespace __uses_allocator_detail {
+
+template <class _Ap, class _Bp>
+void __fun(const pair<_Ap, _Bp>&);
+
+template <class _Tp>
+decltype(__uses_allocator_detail::__fun(std::declval<_Tp>()), true_type()) __convertible_to_const_pair_ref_impl(int);
+
+template <class>
+false_type __convertible_to_const_pair_ref_impl(...);
+
+template <class _Tp>
+inline constexpr bool __convertible_to_const_pair_ref =
+    decltype(__uses_allocator_detail::__convertible_to_const_pair_ref_impl<_Tp>(0))::value;
+
+} // 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>
+_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 auto __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>>
+_LIBCPP_HIDE_FROM_ABI constexpr auto
+__uses_allocator_construction_args(const _Alloc& __alloc, _Type&& __value) noexcept {
+  struct __pair_constructor {
+    using _PairMutable = remove_cv_t<_Pair>;
+
+    _LIBCPP_HIDE_FROM_ABI constexpr auto __do_construct(const _PairMutable& __pair) const {
+      return std::__make_obj_using_allocator<_PairMutable>(__alloc_, __pair);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI constexpr auto __do_construct(_PairMutable&& __pair) const {
+      return std::__make_obj_using_allocator<_PairMutable>(__alloc_, std::move(__pair));
+    }
+
+    const _Alloc& __alloc_;
+    _Type& __value_;
+
+    _LIBCPP_HIDE_FROM_ABI constexpr operator _PairMutable() const {
+      return __do_construct(std::forward<_Type>(this->__value_));
+    }
+  };
+
+  return std::make_tuple(__pair_constructor{__alloc, __value});
+}
+
+template <class _Type, class _Alloc, class... _Args>
+_LIBCPP_HIDE_FROM_ABI constexpr _Type __make_obj_using_allocator(const _Alloc& __alloc, _Args&&... __args) {
+  return std::make_from_tuple<_Type>(
+      std::__uses_allocator_construction_args<_Type>(__alloc, std::forward<_Args>(__args)...));
+}
+
+template <class _Type, class _Alloc, class... _Args>
+_LIBCPP_HIDE_FROM_ABI constexpr _Type*
+__uninitialized_construct_using_allocator(_Type* __ptr, const _Alloc& __alloc, _Args&&... __args) {
+  return std::apply(
+      [&__ptr](auto&&... __xs) { return std::__construct_at(__ptr, std::forward<decltype(__xs)>(__xs)...); },
+      std::__uses_allocator_construction_args<_Type>(__alloc, std::forward<_Args>(__args)...));
+}
+
+#endif // _LIBCPP_STD_VER >= 17
+
+#if _LIBCPP_STD_VER >= 20
+
+template <class _Type, class _Alloc, class... _Args>
+_LIBCPP_HIDE_FROM_ABI constexpr auto uses_allocator_construction_args(const _Alloc& __alloc, _Args&&... __args) noexcept
+    -> decltype(std::__uses_allocator_construction_args<_Type>(__alloc, std::forward<_Args>(__args)...)) {
+  return /*--*/ std::__uses_allocator_construction_args<_Type>(__alloc, std::forward<_Args>(__args)...);
+}
+
+template <class _Type, class _Alloc, class... _Args>
+_LIBCPP_HIDE_FROM_ABI constexpr auto make_obj_using_allocator(const _Alloc& __alloc, _Args&&... __args)
+    -> decltype(std::__make_obj_using_allocator<_Type>(__alloc, std::forward<_Args>(__args)...)) {
+  return /*--*/ std::__make_obj_using_allocator<_Type>(__alloc, std::forward<_Args>(__args)...);
+}
+
+template <class _Type, class _Alloc, class... _Args>
+_LIBCPP_HIDE_FROM_ABI constexpr auto
+uninitialized_construct_using_allocator(_Type* __ptr, const _Alloc& __alloc, _Args&&... __args)
+    -> decltype(std::__uninitialized_construct_using_allocator(__ptr, __alloc, std::forward<_Args>(__args)...)) {
+  return /*--*/ std::__uninitialized_construct_using_allocator(__ptr, __alloc, std::forward<_Args>(__args)...);
+}
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MEMORY_USES_ALLOCATOR_CONSTRUCTION_H

libcxx/include/memory

 #include <__memory/ranges_construct_at.h>
 #include <__memory/ranges_uninitialized_algorithms.h>
 #include <__memory/raw_storage_iterator.h>
 #include <__memory/shared_ptr.h>
 #include <__memory/temporary_buffer.h>
 #include <__memory/uninitialized_algorithms.h>
 #include <__memory/unique_ptr.h>
 #include <__memory/uses_allocator.h>
+#include <__memory/uses_allocator_construction.h>
 #include <version>
 
 // standard-mandated includes
 #include <compare>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/module.modulemap.in

module __memory {
       module raw_storage_iterator            { private header "__memory/raw_storage_iterator.h" }
       module shared_ptr                      { private header "__memory/shared_ptr.h" }
       module swap_allocator                  { private header "__memory/swap_allocator.h" }
       module temp_value                      { private header "__memory/temp_value.h" }
       module temporary_buffer                { private header "__memory/temporary_buffer.h" }
       module uninitialized_algorithms        { private header "__memory/uninitialized_algorithms.h" }
       module unique_ptr                      { private header "__memory/unique_ptr.h" }
       module uses_allocator                  { private header "__memory/uses_allocator.h" }
+      module uses_allocator_construction     { private header "__memory/uses_allocator_construction.h" }
       module voidify                         { private header "__memory/voidify.h" }
     }
   }
   module mutex {
     @requires_LIBCXX_ENABLE_THREADS@
     header "mutex"
     export *
   }

libcxx/include/scoped_allocator

 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__memory/allocator_traits.h>
+#include <__memory/uses_allocator_construction.h>
 #include <__type_traits/common_type.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/integral_constant.h>
 #include <__type_traits/is_constructible.h>
 #include <__type_traits/remove_reference.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
public:
     void deallocate(pointer __p, size_type __n) _NOEXCEPT
         {allocator_traits<outer_allocator_type>::
             deallocate(outer_allocator(), __p, __n);}
 
     _LIBCPP_INLINE_VISIBILITY
     size_type max_size() const
         {return allocator_traits<outer_allocator_type>::max_size(outer_allocator());}
 
+#if _LIBCPP_STD_VER >= 20
+    template <class _Type, class... _Args>
+    _LIBCPP_HIDE_FROM_ABI void construct(_Type* __ptr, _Args&&... __args) {
+      using _OM = __outermost<outer_allocator_type>;
+      std::apply(
+          [__ptr, this](auto&&... __newargs) {
+            allocator_traits<typename _OM::type>::construct(
+                _OM()(outer_allocator()), __ptr, std::forward<decltype(__newargs)>(__newargs)...);
+          },
+          std::uses_allocator_construction_args<_Type>(inner_allocator(), std::forward<_Args>(__args)...));
+    }
+#else
     template <class _Tp, class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         void construct(_Tp* __p, _Args&& ...__args)
             {__construct(__uses_alloc_ctor<_Tp, inner_allocator_type&, _Args...>(),
                          __p, _VSTD::forward<_Args>(__args)...);}
 
     template <class _T1, class _T2, class... _Args1, class... _Args2>
     void construct(pair<_T1, _T2>* __p, piecewise_construct_t,
#else
     }
 
     template <class _T1, class _T2, class _Up, class _Vp>
     void construct(pair<_T1, _T2>* __p, pair<_Up, _Vp>&& __x) {
         construct(__p, piecewise_construct,
                   _VSTD::forward_as_tuple(_VSTD::forward<_Up>(__x.first)),
                   _VSTD::forward_as_tuple(_VSTD::forward<_Vp>(__x.second)));
     }
+#endif
 
     template <class _Tp>
         _LIBCPP_INLINE_VISIBILITY
         void destroy(_Tp* __p)
             {
                 typedef __outermost<outer_allocator_type> _OM;
                 allocator_traits<typename _OM::type>::
                                          destroy(_OM()(outer_allocator()), __p);

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__memory/raw_storage_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__memory/raw_storage_iterator.h'}}
 #include <__memory/shared_ptr.h> // expected-error@*:* {{use of private header from outside its module: '__memory/shared_ptr.h'}}
 #include <__memory/swap_allocator.h> // expected-error@*:* {{use of private header from outside its module: '__memory/swap_allocator.h'}}
 #include <__memory/temp_value.h> // expected-error@*:* {{use of private header from outside its module: '__memory/temp_value.h'}}
 #include <__memory/temporary_buffer.h> // expected-error@*:* {{use of private header from outside its module: '__memory/temporary_buffer.h'}}
 #include <__memory/uninitialized_algorithms.h> // expected-error@*:* {{use of private header from outside its module: '__memory/uninitialized_algorithms.h'}}
 #include <__memory/unique_ptr.h> // expected-error@*:* {{use of private header from outside its module: '__memory/unique_ptr.h'}}
 #include <__memory/uses_allocator.h> // expected-error@*:* {{use of private header from outside its module: '__memory/uses_allocator.h'}}
+#include <__memory/uses_allocator_construction.h> // expected-error@*:* {{use of private header from outside its module: '__memory/uses_allocator_construction.h'}}
 #include <__memory/voidify.h> // expected-error@*:* {{use of private header from outside its module: '__memory/voidify.h'}}
 #include <__mutex_base> // expected-error@*:* {{use of private header from outside its module: '__mutex_base'}}
 #include <__node_handle> // expected-error@*:* {{use of private header from outside its module: '__node_handle'}}
 #include <__numeric/accumulate.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/accumulate.h'}}
 #include <__numeric/adjacent_difference.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/adjacent_difference.h'}}
 #include <__numeric/exclusive_scan.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/exclusive_scan.h'}}
 #include <__numeric/gcd_lcm.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/gcd_lcm.h'}}
 #include <__numeric/inclusive_scan.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/inclusive_scan.h'}}

libcxx/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct.pass.cpp

 };
 
 bool F::constructed = false;
 
 struct G
 {
     static bool constructed;
 
-    typedef std::allocator<G> allocator_type;
+    typedef std::scoped_allocator_adaptor<std::allocator<G>> allocator_type;
 
     G(std::allocator_arg_t, allocator_type&&) { assert(false); }
-    G(allocator_type&) { constructed = true; }
+    G(const allocator_type&) { constructed = true; }
 };
 
 bool G::constructed = false;
 
 int main(int, char**)
 {
 
     {
int main(int, char**)
         assert(A3<F>::constructed);
         s->~S();
     }
 
     // LWG 2586
     // Test that is_constructible uses an lvalue ref so the correct constructor
     // is picked.
     {
-        std::scoped_allocator_adaptor<G::allocator_type> sa;
+        G::allocator_type sa;
         G* ptr = sa.allocate(1);
         sa.construct(ptr);
         assert(G::constructed);
         sa.deallocate(ptr, 1);
     }
 
   return 0;
 }

libcxx/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp

AllocController P;
         static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr);
         Alloc CA(P);
         SA A(CA);
         A.construct(ptr);
         assert(checkConstruct<>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<>(ptr->second, UA_AllocLast, CA));
+#if TEST_STD_VER >= 20
+        assert((P.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t, const SA&>&&,
+                                 std::tuple<const SA&>&&
+              >(CA, ptr)));
+#else
         assert((P.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SA&>&&,
                                  std::tuple<SA&>&&
               >(CA, ptr)));
+#endif
         A.destroy(ptr);
         std::free(ptr);
 
     }
     P.reset();
     {
         using T = UsesAllocatorV3<VoidAlloc, 0>;
         using U = NotUsesAllocator<VoidAlloc, 0>;
         using Pair = std::pair<T, U>;
         using Alloc = CountingAllocator<Pair>;
         using SA = std::scoped_allocator_adaptor<Alloc>;
         static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr);
         Alloc CA(P);
         SA A(CA);
         A.construct(ptr);
         assert(checkConstruct<>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<>(ptr->second, UA_None));
+#if TEST_STD_VER >= 20
+        assert((P.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t, const SA&>&&,
+                                 std::tuple<>&&
+                   >(CA, ptr)));
+#else
         assert((P.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SA&>&&,
                                  std::tuple<>&&
                    >(CA, ptr)));
+#endif
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 
 void test_with_inner_alloc()
 {
     using VoidAlloc2 = CountingAllocator<void, 2>;
AllocController PInner;
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         A.construct(ptr);
         assert(checkConstruct<>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<>(ptr->second, UA_AllocLast));
+#if TEST_STD_VER >= 20
+        assert((POuter.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t, const SAInner&>&&,
+                                 std::tuple<const SAInner&>&&
+              >(O, ptr)));
+#else
         assert((POuter.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SAInner&>&&,
                                  std::tuple<SAInner&>&&
               >(O, ptr)));
+#endif
         A.destroy(ptr);
         std::free(ptr);
     }
     PInner.reset();
     POuter.reset();
     {
         using T = UsesAllocatorV3<VoidAlloc2, 0>;
         using U = NotUsesAllocator<VoidAlloc2, 0>;
         using Pair = std::pair<T, U>;
         using Outer = CountingAllocator<Pair, 1>;
         using Inner = CountingAllocator<Pair, 2>;
         using SA = std::scoped_allocator_adaptor<Outer, Inner>;
         using SAInner = std::scoped_allocator_adaptor<Inner>;
         static_assert(!std::uses_allocator<T, Outer>::value, "");
         static_assert(std::uses_allocator<T, Inner>::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         A.construct(ptr);
         assert(checkConstruct<>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<>(ptr->second, UA_None));
+#if TEST_STD_VER >= 20
+        assert((POuter.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t, const SAInner&>&&,
+                                 std::tuple<>&&
+              >(O, ptr)));
+#else
         assert((POuter.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SAInner&>&&,
                                  std::tuple<>&&
               >(O, ptr)));
+#endif
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 int main(int, char**) {
     test_no_inner_alloc();
     test_with_inner_alloc();
 
   return 0;
 }

libcxx/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp

AllocController P;
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr != nullptr);
         Alloc CA(P);
         SA A(CA);
         const PairIn in(x, std::move(y));
         A.construct(ptr, in);
         assert(checkConstruct<int&>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<int const&>(ptr->second, UA_AllocLast, CA));
+#if TEST_STD_VER >= 20
+        assert((P.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t, const SA&, int&>&&,
+                                 std::tuple<int const&, const SA&>&&
+              >(CA, ptr)));
+#else
         assert((P.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SA&, int&>&&,
                                  std::tuple<int const&, SA&>&&
               >(CA, ptr)));
+#endif
         A.destroy(ptr);
         std::free(ptr);
 
     }
     P.reset();
     {
         using T = UsesAllocatorV3<VoidAlloc, 1>;
         using U = NotUsesAllocator<VoidAlloc, 1>;
         using Pair = std::pair<T, U>;
         using PairIn = std::pair<int, int const&>;
         int x = 42;
         const int y = 101;
         using Alloc = CountingAllocator<Pair>;
         using SA = std::scoped_allocator_adaptor<Alloc>;
         static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr != nullptr);
         Alloc CA(P);
         SA A(CA);
         const PairIn in(x, y);
         A.construct(ptr, in);
         assert(checkConstruct<int const&>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<int const&>(ptr->second, UA_None));
+#if TEST_STD_VER >= 20
+        assert((P.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t, const SA&, int const&>&&,
+                                 std::tuple<int const&>&&
+                   >(CA, ptr)));
+#else
         assert((P.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SA&, int const&>&&,
                                  std::tuple<int const&>&&
                    >(CA, ptr)));
+#endif
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 
 void test_with_inner_alloc()
 {
     using VoidAlloc2 = CountingAllocator<void, 2>;
AllocController PInner;
         assert(ptr != nullptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         const PairIn in(x, std::move(y));
         A.construct(ptr, in);
         assert(checkConstruct<int&>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<int const&>(ptr->second, UA_AllocLast));
+#if TEST_STD_VER >= 20
+        assert((POuter.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t, const SAInner&, int&>&&,
+                                 std::tuple<int const&, const SAInner&>&&
+              >(O, ptr)));
+#else
         assert((POuter.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SAInner&, int&>&&,
                                  std::tuple<int const&, SAInner&>&&
               >(O, ptr)));
+#endif
         A.destroy(ptr);
         std::free(ptr);
     }
     PInner.reset();
     POuter.reset();
     {
         using T = UsesAllocatorV3<VoidAlloc2, 1>;
         using U = NotUsesAllocator<VoidAlloc2, 1>;
POuter.reset();
         assert(ptr != nullptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         const PairIn in(x, y);
         A.construct(ptr, in);
         assert(checkConstruct<int const&>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<int const&>(ptr->second, UA_None));
+#if TEST_STD_VER >= 20
+        assert((POuter.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t, const SAInner&, int const&>&&,
+                                 std::tuple<int const&>&&
+              >(O, ptr)));
+#else
         assert((POuter.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SAInner&, int const&>&&,
                                  std::tuple<int const&>&&
               >(O, ptr)));
+#endif
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 int main(int, char**) {
     test_no_inner_alloc();
     test_with_inner_alloc();
 
   return 0;
 }

libcxx/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp

AllocController P;
         assert(ptr != nullptr);
         Alloc CA(P);
         SA A(CA);
         A.construct(ptr, std::piecewise_construct,
                     std::forward_as_tuple(x),
                     std::forward_as_tuple(std::move(y)));
         assert(checkConstruct<int&>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<int const&&>(ptr->second, UA_AllocLast, CA));
+#if TEST_STD_VER >= 20
+        assert((P.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t, const SA&, int&>&&,
+                                 std::tuple<int const&&, const SA&>&&
+              >(CA, ptr)));
+#else
         assert((P.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SA&, int&>&&,
                                  std::tuple<int const&&, SA&>&&
               >(CA, ptr)));
+#endif
         A.destroy(ptr);
         std::free(ptr);
 
     }
     P.reset();
     {
         using T = UsesAllocatorV3<VoidAlloc, 1>;
         using U = NotUsesAllocator<VoidAlloc, 1>;
         using Pair = std::pair<T, U>;
         int x = 42;
         const int y = 101;
         using Alloc = CountingAllocator<Pair>;
         using SA = std::scoped_allocator_adaptor<Alloc>;
         static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr != nullptr);
         Alloc CA(P);
         SA A(CA);
         A.construct(ptr, std::piecewise_construct,
                     std::forward_as_tuple(std::move(x)),
                     std::forward_as_tuple(y));
         assert(checkConstruct<int&&>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<int const&>(ptr->second, UA_None));
+#if TEST_STD_VER >= 20
+        assert((P.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t, const SA&, int&&>&&,
+                                 std::tuple<int const&>&&
+                   >(CA, ptr)));
+#else
         assert((P.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SA&, int&&>&&,
                                  std::tuple<int const&>&&
                    >(CA, ptr)));
+#endif
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 
 void test_with_inner_alloc()
 {
     using VoidAlloc2 = CountingAllocator<void, 2>;
AllocController PInner;
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         A.construct(ptr, std::piecewise_construct,
                     std::forward_as_tuple(x),
                     std::forward_as_tuple(std::move(y)));
         assert(checkConstruct<int&>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<int &&>(ptr->second, UA_AllocLast));
+#if TEST_STD_VER >= 20
+        assert((POuter.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t, const SAInner&, int&>&&,
+                                 std::tuple<int &&, const SAInner&>&&
+              >(O, ptr)));
+#else
         assert((POuter.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SAInner&, int&>&&,
                                  std::tuple<int &&, SAInner&>&&
               >(O, ptr)));
+#endif
         A.destroy(ptr);
         std::free(ptr);
     }
     PInner.reset();
     POuter.reset();
     {
         using T = UsesAllocatorV3<VoidAlloc2, 1>;
         using U = NotUsesAllocator<VoidAlloc2, 1>;
POuter.reset();
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         A.construct(ptr, std::piecewise_construct,
                     std::forward_as_tuple(std::move(x)),
                     std::forward_as_tuple(std::move(y)));
         assert(checkConstruct<int&&>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<int const&&>(ptr->second, UA_None));
+#if TEST_STD_VER >= 20
+        assert((POuter.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t, const SAInner&, int&&>&&,
+                                 std::tuple<int const&&>&&
+              >(O, ptr)));
+#else
         assert((POuter.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SAInner&, int&&>&&,
                                  std::tuple<int const&&>&&
               >(O, ptr)));
+#endif
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 int main(int, char**) {
     test_no_inner_alloc();
     test_with_inner_alloc();
 
   return 0;
 }

libcxx/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp

AllocController P;
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr != nullptr);
         Alloc CA(P);
         SA A(CA);
         PairIn in(x, std::move(y));
         A.construct(ptr, std::move(in));
         assert(checkConstruct<int&>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<int const&&>(ptr->second, UA_AllocLast, CA));
+#if TEST_STD_VER >= 20
+        assert((P.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t, const SA&, int&>&&,
+                                 std::tuple<int const&&, const SA&>&&
+              >(CA, ptr)));
+#else
         assert((P.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SA&, int&>&&,
                                  std::tuple<int const&&, SA&>&&
               >(CA, ptr)));
+#endif
         A.destroy(ptr);
         std::free(ptr);
 
     }
     P.reset();
     {
         using T = UsesAllocatorV3<VoidAlloc, 1>;
         using U = NotUsesAllocator<VoidAlloc, 1>;
         using Pair = std::pair<T, U>;
         using PairIn = std::pair<int, int const&>;
         int x = 42;
         const int y = 101;
         using Alloc = CountingAllocator<Pair>;
         using SA = std::scoped_allocator_adaptor<Alloc>;
         static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr != nullptr);
         Alloc CA(P);
         SA A(CA);
         PairIn in(x, y);
         A.construct(ptr, std::move(in));
         assert(checkConstruct<int&&>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<int const&>(ptr->second, UA_None));
+#if TEST_STD_VER >= 20
+        assert((P.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t, const SA&, int&&>&&,
+                                 std::tuple<int const&>&&
+                   >(CA, ptr)));
+#else
         assert((P.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SA&, int&&>&&,
                                  std::tuple<int const&>&&
                    >(CA, ptr)));
+#endif
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 
 void test_with_inner_alloc()
 {
     using VoidAlloc2 = CountingAllocator<void, 2>;
AllocController PInner;
         assert(ptr != nullptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         PairIn in(x, std::move(y));
         A.construct(ptr, std::move(in));
         assert(checkConstruct<int&>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<int const&&>(ptr->second, UA_AllocLast));
+#if TEST_STD_VER >= 20
+        assert((POuter.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t, const SAInner&, int&>&&,
+                                 std::tuple<int const&&, const SAInner&>&&
+              >(O, ptr)));
+#else
         assert((POuter.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SAInner&, int&>&&,
                                  std::tuple<int const&&, SAInner&>&&
               >(O, ptr)));
+#endif
         A.destroy(ptr);
         std::free(ptr);
     }
     PInner.reset();
     POuter.reset();
     {
         using T = UsesAllocatorV3<VoidAlloc2, 1>;
         using U = NotUsesAllocator<VoidAlloc2, 1>;
POuter.reset();
         assert(ptr != nullptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         PairIn in(x, y);
         A.construct(ptr, std::move(in));
         assert(checkConstruct<int&&>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<int const&>(ptr->second, UA_None));
+#if TEST_STD_VER >= 20
+        assert((POuter.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t, const SAInner&, int&&>&&,
+                                 std::tuple<int const&>&&
+              >(O, ptr)));
+#else
         assert((POuter.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SAInner&, int&&>&&,
                                  std::tuple<int const&>&&
               >(O, ptr)));
+#endif
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 int main(int, char**) {
     test_no_inner_alloc();
     test_with_inner_alloc();
 
   return 0;
 }

libcxx/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp

AllocController P;
         static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr != nullptr);
         Alloc CA(P);
         SA A(CA);
         A.construct(ptr, x, std::move(y));
         assert(checkConstruct<int&>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<int const&&>(ptr->second, UA_AllocLast, CA));
+#if TEST_STD_VER >= 20
+        assert((P.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t, const SA&, int&>&&,
+                                 std::tuple<int const&&, const SA&>&&
+              >(CA, ptr)));
+#else
         assert((P.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SA&, int&>&&,
                                  std::tuple<int const&&, SA&>&&
               >(CA, ptr)));
+#endif
         A.destroy(ptr);
         std::free(ptr);
 
     }
     P.reset();
     {
         using T = UsesAllocatorV3<VoidAlloc, 1>;
         using U = NotUsesAllocator<VoidAlloc, 1>;
         using Pair = std::pair<T, U>;
         int x = 42;
         const int y = 101;
         using Alloc = CountingAllocator<Pair>;
         using SA = std::scoped_allocator_adaptor<Alloc>;
         static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr != nullptr);
         Alloc CA(P);
         SA A(CA);
         A.construct(ptr, std::move(x), y);
         assert(checkConstruct<int&&>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<int const&>(ptr->second, UA_None));
+#if TEST_STD_VER >= 20
+        assert((P.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t, const SA&, int&&>&&,
+                                 std::tuple<int const&>&&
+                   >(CA, ptr)));
+#else
         assert((P.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SA&, int&&>&&,
                                  std::tuple<int const&>&&
                    >(CA, ptr)));
+#endif
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 
 void test_with_inner_alloc()
 {
     using VoidAlloc2 = CountingAllocator<void, 2>;
AllocController PInner;
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr != nullptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         A.construct(ptr, x, std::move(y));
         assert(checkConstruct<int&>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<int &&>(ptr->second, UA_AllocLast));
+#if TEST_STD_VER >= 20
+        assert((POuter.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t, const SAInner&, int&>&&,
+                                 std::tuple<int &&, const SAInner&>&&
+              >(O, ptr)));
+#else
         assert((POuter.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SAInner&, int&>&&,
                                  std::tuple<int &&, SAInner&>&&
               >(O, ptr)));
+#endif
         A.destroy(ptr);
         std::free(ptr);
     }
     PInner.reset();
     POuter.reset();
     {
         using T = UsesAllocatorV3<VoidAlloc2, 1>;
         using U = NotUsesAllocator<VoidAlloc2, 1>;
POuter.reset();
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr != nullptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         A.construct(ptr, std::move(x), std::move(y));
         assert(checkConstruct<int&&>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<int const&&>(ptr->second, UA_None));
+#if TEST_STD_VER >= 20
+        assert((POuter.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t, const SAInner&, int&&>&&,
+                                 std::tuple<int const&&>&&
+              >(O, ptr)));
+#else
         assert((POuter.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SAInner&, int&&>&&,
                                  std::tuple<int const&&>&&
               >(O, ptr)));
+#endif
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 int main(int, char**) {
     test_no_inner_alloc();
     test_with_inner_alloc();
 
   return 0;
 }

libcxx/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp

AllocController PInner;
         T* ptr = (T*)::operator new(sizeof(T));
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         int x = 42;
         int const& cx = x;
         A.construct(ptr, x, cx, std::move(x));
         assert((checkConstruct<int&, int const&, int&&>(*ptr, UA_AllocArg, I)));
+#if TEST_STD_VER >= 20
+        assert((POuter.checkConstruct<std::allocator_arg_t&&,
+                   const SA::inner_allocator_type&, int&, int const&, int&&>(O, ptr)));
+#else
         assert((POuter.checkConstruct<std::allocator_arg_t const&,
                    SA::inner_allocator_type&, int&, int const&, int&&>(O, ptr)));
+#endif
         A.destroy(ptr);
         ::operator delete((void*)ptr);
     }
     PInner.reset();
     POuter.reset();
 }
 
 // Otherwise, if uses_allocator_v<T, inner_allocator_type> is true and
AllocController PInner;
         T* ptr = (T*)::operator new(sizeof(T));
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         int x = 42;
         int const& cx = x;
         A.construct(ptr, x, cx, std::move(x));
         assert((checkConstruct<int&, int const&, int&&>(*ptr, UA_AllocLast, I)));
+#if TEST_STD_VER >= 20
+        assert((POuter.checkConstruct<
+                   int&, int const&, int&&,
+                   const SA::inner_allocator_type&>(O, ptr)));
+#else
         assert((POuter.checkConstruct<
                    int&, int const&, int&&,
                    SA::inner_allocator_type&>(O, ptr)));
+#endif
         A.destroy(ptr);
         ::operator delete((void*)ptr);
     }
     PInner.reset();
     POuter.reset();
 }
 
 int main(int, char**) {
     test_bullet_one();
     test_bullet_two();
     test_bullet_three();
 
   return 0;
 }

libcxx/test/std/utilities/memory/allocator.uses/allocator.uses.construction/common.h

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "test_allocator.h"
+
+using Alloc = test_allocator<int>;
+
+enum class RefType {
+  LValue,
+  ConstLValue,
+  RValue,
+  ConstRValue,
+};
+
+struct UsesAllocArgT {
+  using allocator_type = Alloc;
+
+  bool allocator_constructed_ = false;
+  Alloc a_;
+  const Alloc& alloc_ = a_;
+  const int* val_ptr_;
+  RefType ref_type_;
+
+  constexpr UsesAllocArgT() = default;
+  constexpr UsesAllocArgT(std::allocator_arg_t, const Alloc& alloc) : allocator_constructed_(true), alloc_(alloc) {}
+  constexpr UsesAllocArgT(std::allocator_arg_t, const Alloc& alloc, int& val)
+      : allocator_constructed_(true), alloc_(alloc), val_ptr_(&val), ref_type_(RefType::LValue) {}
+  constexpr UsesAllocArgT(std::allocator_arg_t, const Alloc& alloc, const int& val)
+      : allocator_constructed_(true), alloc_(alloc), val_ptr_(&val), ref_type_(RefType::ConstLValue) {}
+  constexpr UsesAllocArgT(std::allocator_arg_t, const Alloc& alloc, int&& val)
+      : allocator_constructed_(true), alloc_(alloc), val_ptr_(&val), ref_type_(RefType::RValue) {}
+  constexpr UsesAllocArgT(std::allocator_arg_t, const Alloc& alloc, const int&& val)
+      : allocator_constructed_(true), alloc_(alloc), val_ptr_(&val), ref_type_(RefType::ConstRValue) {}
+};
+
+struct UsesAllocLast {
+  using allocator_type = Alloc;
+
+  bool allocator_constructed_ = false;
+  Alloc a_;
+  const Alloc& alloc_ = a_;
+  const int* val_ptr_;
+  RefType ref_type_;
+
+  constexpr UsesAllocLast() = default;
+  constexpr UsesAllocLast(const Alloc& alloc) : allocator_constructed_(true), alloc_(alloc) {}
+  constexpr UsesAllocLast(int& val, const Alloc& alloc)
+      : allocator_constructed_(true), alloc_(alloc), val_ptr_(&val), ref_type_(RefType::LValue) {}
+  constexpr UsesAllocLast(const int& val, const Alloc& alloc)
+      : allocator_constructed_(true), alloc_(alloc), val_ptr_(&val), ref_type_(RefType::ConstLValue) {}
+  constexpr UsesAllocLast(int&& val, const Alloc& alloc)
+      : allocator_constructed_(true), alloc_(alloc), val_ptr_(&val), ref_type_(RefType::RValue) {}
+  constexpr UsesAllocLast(const int&& val, const Alloc& alloc)
+      : allocator_constructed_(true), alloc_(alloc), val_ptr_(&val), ref_type_(RefType::ConstRValue) {}
+};
+
+struct NotAllocatorAware {
+  bool allocator_constructed_ = false;
+
+  constexpr NotAllocatorAware() = default;
+  constexpr NotAllocatorAware(const Alloc&) : allocator_constructed_(true) {}
+  constexpr NotAllocatorAware(const Alloc&, int) : allocator_constructed_(true) {}
+};
+
+struct ConvertibleToPair {
+  constexpr operator std::pair<int, int>() const { return {1, 2}; }
+};

libcxx/test/std/utilities/memory/allocator.uses/allocator.uses.construction/make_obj_using_allocator.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// template<class T, class Alloc, class... Args>
+//   constexpr T make_obj_using_allocator(const Alloc& alloc, Args&&... args);
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+#include <concepts>
+#include <memory>
+#include <tuple>
+#include <utility>
+
+#include "common.h"
+#include "test_allocator.h"
+
+constexpr bool test() {
+  Alloc a(12);
+  {
+    std::same_as<UsesAllocArgT> auto ret = std::make_obj_using_allocator<UsesAllocArgT>(a);
+    assert(ret.allocator_constructed_);
+    assert(&ret.alloc_ == &a);
+  }
+  {
+    std::same_as<UsesAllocLast> auto ret = std::make_obj_using_allocator<UsesAllocLast>(a);
+    assert(ret.allocator_constructed_);
+    assert(&ret.alloc_ == &a);
+  }
+  {
+    std::same_as<NotAllocatorAware> auto ret = std::make_obj_using_allocator<NotAllocatorAware>(a);
+    assert(!ret.allocator_constructed_);
+  }
+  {
+    std::same_as<std::pair<UsesAllocArgT, UsesAllocLast>> auto ret =
+        std::make_obj_using_allocator<std::pair<UsesAllocArgT, UsesAllocLast>>(
+            a, std::piecewise_construct, std::tuple<>{}, std::tuple<>{});
+    assert(ret.first.allocator_constructed_);
+    assert(&ret.first.alloc_ == &a);
+    assert(ret.second.allocator_constructed_);
+    assert(&ret.second.alloc_ == &a);
+  }
+  {
+    std::same_as<std::pair<UsesAllocArgT, UsesAllocLast>> auto ret =
+        std::make_obj_using_allocator<std::pair<UsesAllocArgT, UsesAllocLast>>(a);
+    assert(ret.first.allocator_constructed_);
+    assert(&ret.first.alloc_ == &a);
+    assert(ret.second.allocator_constructed_);
+    assert(&ret.second.alloc_ == &a);
+  }
+  {
+    std::same_as<std::pair<UsesAllocArgT, UsesAllocLast>> auto ret =
+        std::make_obj_using_allocator<std::pair<UsesAllocArgT, UsesAllocLast>>(a, 0, 0);
+    assert(ret.first.allocator_constructed_);
+    assert(&ret.first.alloc_ == &a);
+    assert(ret.second.allocator_constructed_);
+    assert(&ret.second.alloc_ == &a);
+  }
+#if TEST_STD_VER >= 23
+  {
+    std::pair p{0, 0};
+
+    std::same_as<std::pair<UsesAllocArgT, UsesAllocLast>> auto ret =
+        std::make_obj_using_allocator<std::pair<UsesAllocArgT, UsesAllocLast>>(a, p);
+    assert(ret.first.allocator_constructed_);
+    assert(&ret.first.alloc_ == &a);
+    assert(ret.first.ref_type_ == RefType::LValue);
+    assert(ret.first.val_ptr_ == &p.first);
+    assert(ret.second.allocator_constructed_);
+    assert(&ret.second.alloc_ == &a);
+    assert(ret.second.ref_type_ == RefType::LValue);
+    assert(ret.second.val_ptr_ == &p.second);
+  }
+#endif
+  {
+    std::pair p{0, 0};
+    std::same_as<std::pair<UsesAllocArgT, UsesAllocLast>> auto ret =
+        std::make_obj_using_allocator<std::pair<UsesAllocArgT, UsesAllocLast>>(a, std::as_const(p));
+    assert(ret.first.allocator_constructed_);
+    assert(&ret.first.alloc_ == &a);
+    assert(ret.first.ref_type_ == RefType::ConstLValue);
+    assert(ret.first.val_ptr_ == &p.first);
+    assert(ret.second.allocator_constructed_);
+    assert(&ret.second.alloc_ == &a);
+    assert(ret.second.ref_type_ == RefType::ConstLValue);
+    assert(ret.second.val_ptr_ == &p.second);
+  }
+  {
+    std::pair p{0, 0};
+    std::same_as<std::pair<UsesAllocArgT, UsesAllocLast>> auto ret =
+        std::make_obj_using_allocator<std::pair<UsesAllocArgT, UsesAllocLast>>(a, std::move(p));
+    assert(ret.first.allocator_constructed_);
+    assert(&ret.first.alloc_ == &a);
+    assert(ret.first.ref_type_ == RefType::RValue);
+    assert(ret.first.val_ptr_ == &p.first);
+    assert(ret.second.allocator_constructed_);
+    assert(&ret.second.alloc_ == &a);
+    assert(ret.second.ref_type_ == RefType::RValue);
+    assert(ret.second.val_ptr_ == &p.second);
+  }
+#if TEST_STD_VER >= 23
+  {
+    std::pair p{0, 0};
+    std::same_as<std::pair<UsesAllocArgT, UsesAllocLast>> auto ret =
+        std::make_obj_using_allocator<std::pair<UsesAllocArgT, UsesAllocLast>>(a, std::move(std::as_const(p)));
+    assert(ret.first.allocator_constructed_);
+    assert(&ret.first.alloc_ == &a);
+    assert(ret.first.ref_type_ == RefType::ConstRValue);
+    assert(ret.first.val_ptr_ == &p.first);
+    assert(ret.second.allocator_constructed_);
+    assert(&ret.second.alloc_ == &a);
+    assert(ret.second.ref_type_ == RefType::ConstRValue);
+    assert(ret.second.val_ptr_ == &p.second);
+  }
+#endif
+  {
+    ConvertibleToPair ctp;
+    std::same_as<std::pair<int, int>> auto ret = std::make_obj_using_allocator<std::pair<int, int>>(a, ctp);
+    assert(ret.first == 1);
+    assert(ret.second == 2);
+  }
+  {
+    ConvertibleToPair ctp;
+    std::same_as<std::pair<int, int>> auto ret = std::make_obj_using_allocator<std::pair<int, int>>(a, std::move(ctp));
+    assert(ret.first == 1);
+    assert(ret.second == 2);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+}

libcxx/test/std/utilities/memory/allocator.uses/allocator.uses.construction/tested_elsewhere.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-int main(int, char**)
-{
-
-  return 0;
-}

libcxx/test/std/utilities/memory/allocator.uses/allocator.uses.construction/uninitialized_construct_using_allocator.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// template<class T, class Alloc, class... Args>
+//   constexpr T uninitialized_construct_using_allocator(const Alloc& alloc, Args&&... args);
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+#include <concepts>
+#include <memory>
+#include <tuple>
+#include <utility>
+
+#include "common.h"
+#include "test_allocator.h"
+
+constexpr bool test() {
+  Alloc a(12);
+  {
+    auto* ptr                             = std::allocator<UsesAllocArgT>{}.allocate(1);
+    std::same_as<UsesAllocArgT*> auto ret = std::uninitialized_construct_using_allocator(ptr, a);
+    assert(ret == ptr);
+    assert(ret->allocator_constructed_);
+    assert(&ret->alloc_ == &a);
+    std::allocator<UsesAllocArgT>{}.deallocate(ptr, 1);
+  }
+  {
+    auto* ptr                             = std::allocator<UsesAllocLast>{}.allocate(1);
+    std::same_as<UsesAllocLast*> auto ret = std::uninitialized_construct_using_allocator(ptr, a);
+    assert(ret->allocator_constructed_);
+    assert(&ret->alloc_ == &a);
+    std::allocator<UsesAllocLast>{}.deallocate(ptr, 1);
+  }
+  {
+    auto* ptr                                 = std::allocator<NotAllocatorAware>{}.allocate(1);
+    std::same_as<NotAllocatorAware*> auto ret = std::uninitialized_construct_using_allocator(ptr, a);
+    assert(!ret->allocator_constructed_);
+    std::allocator<NotAllocatorAware>{}.deallocate(ptr, 1);
+  }
+  {
+    auto* ptr = std::allocator<std::pair<UsesAllocArgT, UsesAllocLast>>{}.allocate(1);
+    std::same_as<std::pair<UsesAllocArgT, UsesAllocLast>*> auto ret =
+        std::uninitialized_construct_using_allocator(ptr, a, std::piecewise_construct, std::tuple<>{}, std::tuple<>{});
+    assert(ret->first.allocator_constructed_);
+    assert(&ret->first.alloc_ == &a);
+    assert(ret->second.allocator_constructed_);
+    assert(&ret->second.alloc_ == &a);
+    std::allocator<std::pair<UsesAllocArgT, UsesAllocLast>>{}.deallocate(ptr, 1);
+  }
+  {
+    auto* ptr = std::allocator<std::pair<UsesAllocArgT, UsesAllocLast>>{}.allocate(1);
+    std::same_as<std::pair<UsesAllocArgT, UsesAllocLast>*> auto ret =
+        std::uninitialized_construct_using_allocator(ptr, a);
+    assert(ret->first.allocator_constructed_);
+    assert(&ret->first.alloc_ == &a);
+    assert(ret->second.allocator_constructed_);
+    assert(&ret->second.alloc_ == &a);
+    std::allocator<std::pair<UsesAllocArgT, UsesAllocLast>>{}.deallocate(ptr, 1);
+  }
+  {
+    int val   = 0;
+    auto* ptr = std::allocator<std::pair<UsesAllocArgT, UsesAllocLast>>{}.allocate(1);
+    std::same_as<std::pair<UsesAllocArgT, UsesAllocLast>*> auto ret =
+        std::uninitialized_construct_using_allocator(ptr, a, val, val);
+    assert(ret->first.allocator_constructed_);
+    assert(&ret->first.alloc_ == &a);
+    assert(ret->first.ref_type_ == RefType::LValue);
+    assert(ret->first.val_ptr_ == &val);
+    assert(ret->second.allocator_constructed_);
+    assert(&ret->second.alloc_ == &a);
+    assert(ret->second.ref_type_ == RefType::LValue);
+    assert(ret->second.val_ptr_ == &val);
+    std::allocator<std::pair<UsesAllocArgT, UsesAllocLast>>{}.deallocate(ptr, 1);
+  }
+  {
+    int val   = 0;
+    auto* ptr = std::allocator<std::pair<UsesAllocArgT, UsesAllocLast>>{}.allocate(1);
+    std::same_as<std::pair<UsesAllocArgT, UsesAllocLast>*> auto ret =
+        std::uninitialized_construct_using_allocator(ptr, a, std::move(val), std::move(val));
+    assert(ret->first.allocator_constructed_);
+    assert(&ret->first.alloc_ == &a);
+    assert(ret->first.ref_type_ == RefType::RValue);
+    assert(ret->first.val_ptr_ == &val);
+    assert(ret->second.allocator_constructed_);
+    assert(&ret->second.alloc_ == &a);
+    assert(ret->second.ref_type_ == RefType::RValue);
+    assert(ret->second.val_ptr_ == &val);
+    std::allocator<std::pair<UsesAllocArgT, UsesAllocLast>>{}.deallocate(ptr, 1);
+  }
+#if TEST_STD_VER >= 23
+  {
+    std::pair p{0, 0};
+
+    auto* ptr = std::allocator<std::pair<UsesAllocArgT, UsesAllocLast>>{}.allocate(1);
+    std::same_as<std::pair<UsesAllocArgT, UsesAllocLast>*> auto ret =
+        std::uninitialized_construct_using_allocator(ptr, a, p);
+    assert(ret->first.allocator_constructed_);
+    assert(&ret->first.alloc_ == &a);
+    assert(ret->first.ref_type_ == RefType::LValue);
+    assert(ret->first.val_ptr_ == &p.first);
+    assert(ret->second.allocator_constructed_);
+    assert(&ret->second.alloc_ == &a);
+    assert(ret->second.ref_type_ == RefType::LValue);
+    assert(ret->second.val_ptr_ == &p.second);
+    std::allocator<std::pair<UsesAllocArgT, UsesAllocLast>>{}.deallocate(ptr, 1);
+  }
+#endif
+  {
+    std::pair p{0, 0};
+    auto* ptr = std::allocator<std::pair<UsesAllocArgT, UsesAllocLast>>{}.allocate(1);
+    std::same_as<std::pair<UsesAllocArgT, UsesAllocLast>*> auto ret =
+        std::uninitialized_construct_using_allocator(ptr, a, std::as_const(p));
+    assert(ret->first.allocator_constructed_);
+    assert(&ret->first.alloc_ == &a);
+    assert(ret->first.ref_type_ == RefType::ConstLValue);
+    assert(ret->first.val_ptr_ == &p.first);
+    assert(ret->second.allocator_constructed_);
+    assert(&ret->second.alloc_ == &a);
+    assert(ret->second.ref_type_ == RefType::ConstLValue);
+    assert(ret->second.val_ptr_ == &p.second);
+    std::allocator<std::pair<UsesAllocArgT, UsesAllocLast>>{}.deallocate(ptr, 1);
+  }
+  {
+    std::pair p{0, 0};
+    auto* ptr = std::allocator<std::pair<UsesAllocArgT, UsesAllocLast>>{}.allocate(1);
+    std::same_as<std::pair<UsesAllocArgT, UsesAllocLast>*> auto ret =
+        std::uninitialized_construct_using_allocator(ptr, a, std::move(p));
+    assert(ret->first.allocator_constructed_);
+    assert(&ret->first.alloc_ == &a);
+    assert(ret->first.ref_type_ == RefType::RValue);
+    assert(ret->first.val_ptr_ == &p.first);
+    assert(ret->second.allocator_constructed_);
+    assert(&ret->second.alloc_ == &a);
+    assert(ret->second.ref_type_ == RefType::RValue);
+    assert(ret->second.val_ptr_ == &p.second);
+    std::allocator<std::pair<UsesAllocArgT, UsesAllocLast>>{}.deallocate(ptr, 1);
+  }
+#if TEST_STD_VER >= 23
+  {
+    std::pair p{0, 0};
+    auto* ptr = std::allocator<std::pair<UsesAllocArgT, UsesAllocLast>>{}.allocate(1);
+    std::same_as<std::pair<UsesAllocArgT, UsesAllocLast>*> auto ret =
+        std::uninitialized_construct_using_allocator(ptr, a, std::move(std::as_const(p)));
+    assert(ret->first.allocator_constructed_);
+    assert(&ret->first.alloc_ == &a);
+    assert(ret->first.ref_type_ == RefType::ConstRValue);
+    assert(ret->first.val_ptr_ == &p.first);
+    assert(ret->second.allocator_constructed_);
+    assert(&ret->second.alloc_ == &a);
+    assert(ret->second.ref_type_ == RefType::ConstRValue);
+    assert(ret->second.val_ptr_ == &p.second);
+    std::allocator<std::pair<UsesAllocArgT, UsesAllocLast>>{}.deallocate(ptr, 1);
+  }
+#endif
+  {
+    ConvertibleToPair ctp;
+    auto* ptr                                   = std::allocator<std::pair<int, int>>{}.allocate(1);
+    std::same_as<std::pair<int, int>*> auto ret = std::uninitialized_construct_using_allocator(ptr, a, ctp);
+    assert(ret == ptr);
+    assert(ret->first == 1);
+    assert(ret->second == 2);
+    std::allocator<std::pair<int, int>>{}.deallocate(ptr, 1);
+  }
+  {
+    ConvertibleToPair ctp;
+    auto* ptr                                   = std::allocator<std::pair<int, int>>{}.allocate(1);
+    std::same_as<std::pair<int, int>*> auto ret = std::uninitialized_construct_using_allocator(ptr, a, std::move(ctp));
+    assert(ret == ptr);
+    assert(ret->first == 1);
+    assert(ret->second == 2);
+    std::allocator<std::pair<int, int>>{}.deallocate(ptr, 1);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+}

libcxx/test/std/utilities/memory/allocator.uses/allocator.uses.construction/uses_allocator_construction_args.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// template<class T, class Alloc, ...>
+// constexpr auto uses_allocator_construction_args(const Alloc& alloc, ...) noexcept;
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+#include <concepts>
+#include <memory>
+#include <tuple>
+#include <utility>
+
+#include "common.h"
+#include "test_allocator.h"
+
+template <class Type, class... Args>
+constexpr decltype(auto) test_uses_allocator_construction_args(Args&&... args) {
+  static_assert(noexcept(std::uses_allocator_construction_args<Type>(std::forward<Args>(args)...)));
+  return std::uses_allocator_construction_args<Type>(std::forward<Args>(args)...);
+}
+
+constexpr bool test() {
+  Alloc a(12);
+  {
+    std::same_as<std::tuple<std::allocator_arg_t, const Alloc&>> auto ret =
+        test_uses_allocator_construction_args<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);
+    assert(std::get<0>(ret).get_data() == 12);
+  }
+  {
+    [[maybe_unused]] std::same_as<std::tuple<>> auto ret = test_uses_allocator_construction_args<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>>(
+            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);
+  }
+  {
+    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);
+    assert(std::get<1>(std::get<1>(ret)).get_data() == 12);
+    assert(std::get<0>(std::get<2>(ret)).get_data() == 12);
+  }
+  {
+    int val = 0;
+    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);
+    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);
+    assert(&std::get<0>(std::get<2>(ret)) == &val);
+  }
+  {
+    int val = 0;
+    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(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);
+    assert(&std::get<2>(std::get<1>(ret)) == &val);
+    assert(&std::get<0>(std::get<2>(ret)) == &val);
+  }
+#if TEST_STD_VER >= 23
+  {
+    std::pair p{3, 4};
+
+    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);
+    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);
+    assert(std::get<0>(std::get<2>(ret)) == 4);
+  }
+#endif
+  {
+    std::pair p{3, 4};
+    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));
+    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);
+    assert(std::get<0>(std::get<2>(ret)) == 4);
+  }
+  {
+    std::pair p{3, 4};
+    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));
+    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);
+    assert(std::get<0>(std::get<2>(ret)) == 4);
+  }
+#if TEST_STD_VER >= 23
+  {
+    std::pair p{3, 4};
+    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)));
+    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);
+    assert(std::get<0>(std::get<2>(ret)) == 4);
+  }
+#endif
+  {
+    ConvertibleToPair ctp {};
+    auto ret = test_uses_allocator_construction_args<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));
+    std::pair<int, int> v = std::get<0>(ret);
+    assert(std::get<0>(v) == 1);
+    assert(std::get<1>(v) == 2);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+}

libcxx/test/support/MoveOnly.h

 {
     int data_;
 public:
     TEST_CONSTEXPR MoveOnly(int data = 1) : data_(data) {}
 
     MoveOnly(const MoveOnly&) = delete;
     MoveOnly& operator=(const MoveOnly&) = delete;
 
-    TEST_CONSTEXPR_CXX14 MoveOnly(MoveOnly&& x)
+    TEST_CONSTEXPR_CXX14 MoveOnly(MoveOnly&& x) TEST_NOEXCEPT
         : data_(x.data_) {x.data_ = 0;}
     TEST_CONSTEXPR_CXX14 MoveOnly& operator=(MoveOnly&& x)
         {data_ = x.data_; x.data_ = 0; return *this;}
 
     TEST_CONSTEXPR int get() const {return data_;}
 
     friend TEST_CONSTEXPR bool operator==(const MoveOnly& x, const MoveOnly& y)
         { return x.data_ == y.data_; }