[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

30

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

150

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

22

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?

51

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

53

is noexcept missing here? Is there a test?

87

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

111

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

122

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

131

inline

151

nit: what does Mut mean?

167

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

62

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

22

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.

30

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

51

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

53

Good catch! Added a regression test.

151

mutable

167

Nope, replaced it with {}.

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

62

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

151

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 ↗

(On Diff #457044)

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

131

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

131

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 ↗

(On Diff #457044)

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

 
 What's New in Libc++ 16.0.0?
 ============================
 
 Implemented Papers
 ------------------
 - P2499R0 - ``string_view`` range constructor should be ``explicit``
 - P2417R2 - A more constexpr bitset
+- P0591R4 - Utility functions to implement uses-allocator construction
 
 Improvements and New Features
 -----------------------------
 
 Deprecations and Removals
 -------------------------
 
 Upcoming Deprecations and Removals

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","|In Progress|",""
 "`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","|Complete|","16.0"
+"`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/include/CMakeLists.txt

set(files
   __memory/ranges_uninitialized_algorithms.h
   __memory/raw_storage_iterator.h
   __memory/shared_ptr.h
   __memory/swap_allocator.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>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 14
+
+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,
+    class = __enable_if_t<
+        !__is_std_pair<_Type> &&
+        ((!uses_allocator_v<_Type, _Alloc> && is_constructible_v<_Type, _Args...>) ||
+         (uses_allocator_v<_Type, _Alloc> && is_constructible_v<_Type, allocator_arg_t, const _Alloc&, _Args...>) ||
+         (uses_allocator_v<_Type, _Alloc> && is_constructible_v<_Type, _Args..., const _Alloc&>))>>
+_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);
+  }
+}
+
+template <class _Pair, class _Alloc, class _Tuple1, class _Tuple2, class = __enable_if_t<__is_std_pair<_Pair>>>
+_LIBCPP_HIDE_FROM_ABI constexpr auto
+__uses_allocator_construction_args(const _Alloc& __alloc, piecewise_construct_t, _Tuple1&& __x, _Tuple2&& __y) {
+  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, class = __enable_if_t<__is_std_pair<_Pair>>>
+_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, class = __enable_if_t<__is_std_pair<_Pair>>>
+_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)));
+}
+
+template <class _Pair, class _Alloc, class _Up, class _Vp, class = __enable_if_t<__is_std_pair<_Pair>>>
+_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));
+}
+
+template <class _Pair, class _Alloc, class _Up, class _Vp, class = __enable_if_t<__is_std_pair<_Pair>>>
+_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, class = __enable_if_t<__is_std_pair<_Pair>>>
+_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))));
+}
+
+template <class _Pair, class _Alloc, class _Up, class _Vp, class = __enable_if_t<__is_std_pair<_Pair>>>
+_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))));
+}
+
+namespace __detail {
+
+template <class _Ap, class _Bp>
+void __fun(const pair<_Ap, _Bp>&);
+
+template <class _Tp>
+decltype(__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>
+constexpr bool __convertible_to_const_pair_ref =
+    decltype(__detail::__convertible_to_const_pair_ref_impl<_Tp>(0))::value;
+
+} // namespace __detail
+
+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_from_tuple<_Type>(
+        std::__uses_allocator_construction_args<_Type>(__alloc, std::forward<_Args>(__args)...))) {
+  return std::make_from_tuple<_Type>(
+      std::__uses_allocator_construction_args<_Type>(__alloc, std::forward<_Args>(__args)...));
+}
+
+template <class _Pair,
+          class _Alloc,
+          class _Type,
+          class = __enable_if_t<__is_std_pair<_Pair> && !__detail::__convertible_to_const_pair_ref<_Type>>>
+_LIBCPP_HIDE_FROM_ABI constexpr auto
+__uses_allocator_construction_args(const _Alloc& __alloc, _Type&& __value) noexcept {
+  struct __pair_constructor {
+    using _PairMut = remove_cv_t<_Pair>;
+
+    _LIBCPP_HIDE_FROM_ABI constexpr auto __do_construct(const _PairMut& __pair) const {
+      return std::__make_obj_using_allocator<_PairMut>(__alloc_, __pair);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI constexpr auto __do_construct(_PairMut&& __pair) const {
+      return std::__make_obj_using_allocator<_PairMut>(__alloc_, std::move(__pair));
+    }
+
+    const _Alloc& __alloc_;
+    _Type& __value_;
+
+    _LIBCPP_HIDE_FROM_ABI constexpr operator _PairMut() const { return __do_construct(std::forward<_Type>(__value_)); }
+  };
+
+  return std::make_tuple(__pair_constructor(__alloc, __value));
+}
+
+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::apply(
+        [](auto&&... __xs) {
+          return std::__construct_at(std::declval<_Type*>(), std::forward<decltype(__xs)>(__xs)...);
+        },
+        std::__uses_allocator_construction_args<_Type>(__alloc, std::forward<_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 > 14
+
+#if _LIBCPP_STD_VER > 17
+
+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, __args...)) {
+  return /*--*/ std::__uninitialized_construct_using_allocator(__ptr, __alloc, __args...);
+}
+
+#endif // _LIBCPP_STD_VER > 17
+
+_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 <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <iosfwd>
 #include <new>
 #include <stdexcept>
 #include <tuple>
 #include <type_traits>

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);
+
+#include <concepts>
+#include <memory>
+#include <tuple>
+#include <utility>
+
+#include "test_allocator.h"
+
+using Alloc = test_allocator<int>;
+
+struct UsesAllocArgT {
+  using allocator_type = Alloc;
+
+  bool allocator_constructed_ = false;
+  const Alloc& alloc_         = Alloc();
+
+  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)
+      : allocator_constructed_(true), alloc_(alloc) {}
+  constexpr UsesAllocArgT(std::allocator_arg_t, int, const Alloc& alloc)
+      : allocator_constructed_(true), alloc_(alloc) {}
+};
+
+struct UsesAllocLast {
+  using allocator_type = Alloc;
+
+  bool allocator_constructed_ = false;
+  const Alloc& alloc_         = Alloc();
+
+  constexpr UsesAllocLast() = default;
+  constexpr UsesAllocLast(const Alloc& alloc) : allocator_constructed_(true), alloc_(alloc) {}
+  constexpr UsesAllocLast(int, const Alloc& alloc) : allocator_constructed_(true), alloc_(alloc) {}
+  constexpr UsesAllocLast(const Alloc& alloc, int) : allocator_constructed_(true), alloc_(alloc) {}
+};
+
+struct NotAllocatorAware {
+  bool allocator_constructed_ = false;
+
+  constexpr NotAllocatorAware() = default;
+  constexpr NotAllocatorAware(const Alloc&) : allocator_constructed_(true) {}
+  constexpr NotAllocatorAware(const Alloc&, int) : allocator_constructed_(true) {}
+};
+
+template <class T, class... Args>
+concept HasMakeObjUsingAllocator = requires(Args... args) { std::make_obj_using_allocator<T>(args...); };
+
+static_assert(HasMakeObjUsingAllocator<UsesAllocArgT, Alloc>);
+static_assert(!HasMakeObjUsingAllocator<UsesAllocArgT, Alloc, int*>);
+static_assert(!HasMakeObjUsingAllocator<UsesAllocArgT, Alloc, int*>);
+
+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);
+  }
+  {
+    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.second.allocator_constructed_);
+    assert(&ret.second.alloc_ == &a);
+  }
+  {
+    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.second.allocator_constructed_);
+    assert(&ret.second.alloc_ == &a);
+  }
+  {
+    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.second.allocator_constructed_);
+    assert(&ret.second.alloc_ == &a);
+  }
+  {
+    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.second.allocator_constructed_);
+    assert(&ret.second.alloc_ == &a);
+  }
+
+  // TODO: test make_obj_using_allocator<Pair>(Alloc, NotConvertibleToPair)
+
+  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);
+
+#include <concepts>
+#include <memory>
+#include <tuple>
+#include <utility>
+
+#include "test_allocator.h"
+
+using Alloc = test_allocator<int>;
+
+struct UsesAllocArgT {
+  using allocator_type = Alloc;
+
+  bool allocator_constructed_ = false;
+  const Alloc& alloc_         = Alloc();
+
+  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)
+      : allocator_constructed_(true), alloc_(alloc) {}
+  constexpr UsesAllocArgT(std::allocator_arg_t, int, const Alloc& alloc)
+      : allocator_constructed_(true), alloc_(alloc) {}
+};
+
+struct UsesAllocLast {
+  using allocator_type = Alloc;
+
+  bool allocator_constructed_ = false;
+  const Alloc& alloc_         = Alloc();
+
+  constexpr UsesAllocLast() = default;
+  constexpr UsesAllocLast(const Alloc& alloc) : allocator_constructed_(true), alloc_(alloc) {}
+  constexpr UsesAllocLast(int, const Alloc& alloc) : allocator_constructed_(true), alloc_(alloc) {}
+  constexpr UsesAllocLast(const Alloc& alloc, int) : allocator_constructed_(true), alloc_(alloc) {}
+};
+
+struct NotAllocatorAware {
+  bool allocator_constructed_ = false;
+
+  constexpr NotAllocatorAware() = default;
+  constexpr NotAllocatorAware(const Alloc&) : allocator_constructed_(true) {}
+  constexpr NotAllocatorAware(const Alloc&, int) : allocator_constructed_(true) {}
+};
+
+template <class T, class... Args>
+concept HasMakeObjUsingAllocator =
+    requires(T* ptr, Args... args) { std::uninitialized_construct_using_allocator<T>(ptr, args...); };
+
+static_assert(HasMakeObjUsingAllocator<UsesAllocArgT, Alloc>);
+static_assert(!HasMakeObjUsingAllocator<UsesAllocArgT, Alloc, int*>);
+static_assert(!HasMakeObjUsingAllocator<UsesAllocArgT, Alloc, int*>);
+
+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);
+  }
+  {
+    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, 0, 0);
+    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);
+  }
+  {
+    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->second.allocator_constructed_);
+    assert(&ret->second.alloc_ == &a);
+    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::as_const(p));
+    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);
+  }
+  {
+    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->second.allocator_constructed_);
+    assert(&ret->second.alloc_ == &a);
+    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(std::as_const(p)));
+    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);
+  }
+
+  // TODO: test uninitialized_construct_using_allocator<Pair>(Alloc, NotConvertibleToPair)
+
+  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;
+
+#include <concepts>
+#include <memory>
+#include <tuple>
+#include <utility>
+
+#include "test_allocator.h"
+
+using Alloc = test_allocator<int>;
+
+struct UsesAllocArgT {
+  using allocator_type = Alloc;
+
+  bool allocator_constructed_ = false;
+
+  UsesAllocArgT() = default;
+  UsesAllocArgT(std::allocator_arg_t, const Alloc&) : allocator_constructed_(true) {}
+  UsesAllocArgT(std::allocator_arg_t, const Alloc&, int) : allocator_constructed_(true) {}
+  UsesAllocArgT(std::allocator_arg_t, int, const Alloc&) : allocator_constructed_(true) {}
+};
+
+struct UsesAllocLast {
+  using allocator_type = Alloc;
+
+  bool allocator_constructed_ = false;
+
+  UsesAllocLast() = default;
+  UsesAllocLast(const Alloc&) : allocator_constructed_(true) {}
+  UsesAllocLast(int, const Alloc&) : allocator_constructed_(true) {}
+  UsesAllocLast(const Alloc&, int) : allocator_constructed_(true) {}
+};
+
+struct NotAllocatorAware {
+  bool allocator_constructed_ = false;
+
+  NotAllocatorAware() = default;
+  NotAllocatorAware(const Alloc&) : allocator_constructed_(true) {}
+  NotAllocatorAware(const Alloc&, int) : allocator_constructed_(true) {}
+};
+
+template <class T, class... Args>
+concept HasUsesAllocatorConstructionArgs =
+    requires(Args... args) { std::uses_allocator_construction_args<T>(args...); };
+
+static_assert(HasUsesAllocatorConstructionArgs<UsesAllocArgT, Alloc>);
+static_assert(!HasUsesAllocatorConstructionArgs<UsesAllocArgT, Alloc, int*>);
+static_assert(!HasUsesAllocatorConstructionArgs<UsesAllocArgT, Alloc, int*>);
+
+constexpr bool test() {
+  Alloc a(12);
+  {
+    [[maybe_unused]] std::same_as<std::tuple<std::allocator_arg_t, const Alloc&>> auto ret =
+        std::uses_allocator_construction_args<UsesAllocArgT>(a);
+    assert(std::get<1>(ret).get_data() == 12);
+  }
+  {
+    [[maybe_unused]] std::same_as<std::tuple<const Alloc&>> auto ret =
+        std::uses_allocator_construction_args<UsesAllocLast>(a);
+    assert(std::get<0>(ret).get_data() == 12);
+  }
+  {
+    [[maybe_unused]] std::same_as<std::tuple<>> auto ret = std::uses_allocator_construction_args<NotAllocatorAware>(a);
+  }
+  {
+    [[maybe_unused]] std::same_as<std::tuple<std::piecewise_construct_t,
+                                             std::tuple<std::allocator_arg_t, const Alloc&>,
+                                             std::tuple<const Alloc&>>> auto ret =
+        std::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);
+  }
+  {
+    [[maybe_unused]] std::same_as<std::tuple<std::piecewise_construct_t,
+                                             std::tuple<std::allocator_arg_t, const Alloc&>,
+                                             std::tuple<const Alloc&>>> auto ret =
+        std::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);
+  }
+  {
+    [[maybe_unused]] 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 =
+        std::uses_allocator_construction_args<std::pair<UsesAllocArgT, UsesAllocLast>>(a, 0, 0);
+    assert(std::get<1>(std::get<1>(ret)).get_data() == 12);
+    assert(std::get<1>(std::get<2>(ret)).get_data() == 12);
+  }
+  {
+    std::pair p{0, 0};
+
+    [[maybe_unused]] 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 =
+        std::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);
+  }
+  {
+    std::pair p{0, 0};
+    [[maybe_unused]] 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 =
+        std::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);
+  }
+  {
+    std::pair p{0, 0};
+    [[maybe_unused]] 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 =
+        std::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);
+  }
+  {
+    std::pair p{0, 0};
+    [[maybe_unused]] 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 =
+        std::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);
+  }
+
+  // TODO: test uses_allocator_construction_args<Pair>(Alloc, NotConvertibleToPair)
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+}