[libc++][ranges] Implement `construct_at` and `destroy{,_at}`.

[var-const]

Use the actual revision number on status pages.

[• Quuxplusone]

LprettyGTM; just nits.

libcxx/include/__memory/ranges_construct_at.h

49

As always, I'd feel better if this were

return ::new (_VSTD::__voidify(*__location)) _Tp(_VSTD::forward<_Args>(__args)...);

(for obvious-correctness, simplicity of implementation, and efficiency-at--O0) but I suppose the extra-indirection way has the minor benefit that if we ever need to do any special magic to make construct_at constexpr-friendly, we'll only need to do it in one place? (For better or worse, I guess. If it later turned out that that magic was required to happen only in construct_at and not in ranges::construct_at, then we'd have to go back to the simple ::new-expression here anyway.)

58

You've got an extra blank line here (and line 79); and please compare to other CPO definitions to make sure you're consistent with the indentation.
I recommend looking on the right-hand side here: https://reviews.llvm.org/D115607#change-mUEJDUqE3FiU

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.construct/ranges_construct_at.pass.cpp

68–77

Let's make this

struct Foo {
    int a_;
    int b_;
    explicit Foo(int a, int b) : a_(b), b_(a) {}
    Foo(std::initializer_list<int>);
    void operator&() const = delete;
    void operator,(auto&&) const = delete;
};
~~~
Foo f(0, 0);  // or auto f = Foo(0, 0);
Foo *result = std::ranges::construct_at(std::addressof(f), 1, 2);
assert(result == std::addressof(f));
assert(result.a == 2);
assert(result.b == 1);

The major thing here is that I added initializer_list to make sure the library is correctly constructing with Foo(1,2) instead of Foo{1,2}. Then I threw in the deleted & and , overloads as an afterthought; I'm not really attached to them, but they seemed low-cost enough to justify their low benefit.

110–112

I smell clang-format's meddling in this weird comment-inside-the-parens style. ;)
The comments are a bit confusing, especially coupled with the use of nullptr — we do check for nullptr inside construct_at, but that part is specifically not SFINAE-friendly. What I'd rather see here is something like

constexpr bool can_construct_at(auto&&... args)
  requires requires { std::ranges::construct_at(decltype(args)(args)...); }
  { return true; }

constexpr bool can_construct_at(auto&&... args)
  { return false; }

static_assert( can_construct_at((Foo*)nullptr, 1, 2));
static_assert(!can_construct_at((Foo*)nullptr, 1));
static_assert(!can_construct_at((Foo*)nullptr, 1, 2, 3));
static_assert(!can_construct_at(nullptr, 1, 2));
static_assert(!can_construct_at((int*)nullptr, 1, 2));
static_assert(!can_construct_at(contiguous_iterator<Foo*>(), 1, 2));

127

I'd like to see some tests with array types, if that's supposed to work; or otherwise,

static_assert(!can_construct_at((int(*)[])nullptr));
static_assert(!can_construct_at((int(*)[2])nullptr));
static_assert(!can_construct_at((int(*)[2])nullptr, 1, 2));

// and function types while we're at it
static_assert(!can_construct_at((int(*)())nullptr));
static_assert(!can_construct_at((int(*)())nullptr, nullptr));

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/ranges_destroy_at.pass.cpp

52

Passing a polymorphic type by value should be a red flag. Let's make this
void operator&() const = delete;
and remove it from the derived class (because the derived class will inherit this one).

[Mordante]

libcxx/include/__memory/ranges_construct_at.h

43

I miss a lot of _LIBCPP_HIDE_FROM_ABI annotations.

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/ranges_destroy.pass.cpp

219

Please add a link to D114903, which implements the missing feature.

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/ranges_destroy_at.pass.cpp

155

Please add a link to D114903, which implements the missing feature.

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/ranges_destroy_n.pass.cpp

141

Please add a link to D114903, which implements the missing feature.

[ldionne]

Leaving comments but I won't mark as "needs changes" to avoid blocking you. If you implement my suggestions and get ✅ from other libc++ reviewers, 🚢 it.

libcxx/include/__memory/ranges_construct_at.h

49

It's actually the other way around, if you use ::new (location) then it won't be constexpr-friendly, right? std::construct_at was introduced exactly to make this sort of pattern constexpr friendly, unless I'm having a giant brain fart.

This seems to confirm what I'm saying: https://godbolt.org/z/9jb7jx4q3

TLDR: AFAICT, this is the only correct way to implement the function without having to change Clang (and possibly the other compilers we support).

[• Quuxplusone]

libcxx/include/__memory/ranges_construct_at.h

49

Looks like Clang probably whitelists "everything in std": https://godbolt.org/z/sGx1d1T7o
GCC must do something more narrowly tailored: I see their own std::ranges::construct_at is constexpr-friendly, but I haven't been able to craft one myself.

Anyway, I had not realized that std::ranges::construct_at was explicitly mentioned in expr.const/6 alongside std::construct_at; therefore it's already supposed to have the same constexpr magic as std::construct_at. So okay, I still think I'd rather see ::new in both places, but if this way is projected to help us jump through GCC's hoops better, then I certainly won't block over it.

[var-const]

Address feedback.

libcxx/include/__memory/ranges_construct_at.h

43

Thanks for spotting this! It also affects my previous patches in this series (I'll do a fix patch once this series lands)

49

Keeping as is given @ldionne's comment.

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.construct/ranges_construct_at.pass.cpp

68–77

Done, thanks!

110–112

Thanks! This definitely feels more comprehensive than the previous state. I've also backported this to the non-ranges test (from which I copied the previous state).

127

Added the test for function types.

The situation with arrays is interesting. They don't work due to how the return type is currently specified (see https://godbolt.org/z/sT8xM7PvP), but there's no requirement that arrays should be SFINAE'd away. Also, there's a recently-updated proposal to support arrays: LWG 3436.

So we can a) make an extension to SFINAE away array types, then make it conditional in C++23 (or just remove it altogether) or b) do nothing and allow such calls to fail with a hard error. What do you think?

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/ranges_destroy.pass.cpp

219

Thanks for the link! Added to the new files and also to tests of the old versions of these algorithms.

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/ranges_destroy_at.pass.cpp

52

Changed here and in tests for the non-ranges version of destroy_at.

[• Quuxplusone]

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.construct/ranges_construct_at.pass.cpp

127

Personally, I'd just implement the proposed resolution for LWG3436 (in C++20-and-later). It's a good fix for a bug in the Standard, and it's always useful to get implementation experience with this kind of thing ASAP. Also, we don't want people to start relying on the wrong behavior and then change it out from under them in C++23. Also, once we've implemented the correct behavior, there's no reason to limit it to C++23-and-later when it could apply just as well to C++20. (We'd still have to decide what to do in C++20, because what was published is not implementable.)

[ldionne]

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.construct/ranges_construct_at.pass.cpp

127

See https://reviews.llvm.org/D114649 for rectifying the solution for array types.

[var-const]

• rebase on main and fix the commit history;
• add a TODO to test array support in construct_at.

[var-const]

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.construct/ranges_construct_at.pass.cpp

127

Given that there's an in-progress patch addressing LWG 3436, I'm inclined to leave as-is with a TODO to test array types once the patch lands.

(We'd still have to decide what to do in C++20, because what was published is not implementable.)

I don't have a strong preference here. I presume we can postpone this discussion until D114649 lands.

[var-const]

Rebase

[var-const]

Fix CI.

[var-const]

Fix CI.

[var-const]

Fix CI.

[var-const]

Fix CI (part 3).

[var-const]

Replace the use of concepts in the construct_at test with SFINAE. While
construct_at requires C++20, older compiler versions might not implement
concepts in that mode.

libcxx/docs/Status/RangesAlgorithms.csv

 Uninitialised memory,uninitialized_fill,Konstantin Varlamov,`D115626 <https://llvm.org/D115626>`_,✅
 Uninitialised memory,uninitialized_fill_n,Konstantin Varlamov,`D115626 <https://llvm.org/D115626>`_,✅
 Uninitialised memory,uninitialized_move,Konstantin Varlamov,`D116023 <https://llvm.org/D116023>`_,✅
 Uninitialised memory,uninitialized_move_n,Konstantin Varlamov,`D116023 <https://llvm.org/D116023>`_,✅
 Uninitialised memory,uninitialized_default_construct,Konstantin Varlamov,`D115315 <https://llvm.org/D115315>`_,✅
 Uninitialised memory,uninitialized_default_construct_n,Konstantin Varlamov,`D115315 <https://llvm.org/D115315>`_,✅
 Uninitialised memory,uninitialized_value_construct,Konstantin Varlamov,`D115626 <https://llvm.org/D115626>`_,✅
 Uninitialised memory,uninitialized_value_construct_n,Konstantin Varlamov,`D115626 <https://llvm.org/D115626>`_,✅
-Uninitialised memory,destroy,Konstantin Varlamov,n/a,Not started
-Uninitialised memory,destroy_n,Konstantin Varlamov,n/a,Not started
-Uninitialised memory,destroy_at,Konstantin Varlamov,n/a,Not started
-Uninitialised memory,construct_at,Konstantin Varlamov,n/a,Not started
+Uninitialised memory,destroy,Konstantin Varlamov,`D116078 <https://llvm.org/D116078>`_,✅
+Uninitialised memory,destroy_n,Konstantin Varlamov,`D116078 <https://llvm.org/D116078>`_,✅
+Uninitialised memory,destroy_at,Konstantin Varlamov,`D116078 <https://llvm.org/D116078>`_,✅
+Uninitialised memory,construct_at,Konstantin Varlamov,`D116078 <https://llvm.org/D116078>`_,✅

libcxx/docs/Status/RangesPaper.csv

 | `ranges::uninitialized_value_construct <https://llvm.org/D115626>`_
 | `ranges::uninitialized_value_construct_n <https://llvm.org/D115626>`_
 | `ranges::uninitialized_copy <https://llvm.org/D116023>`_
 | `ranges::uninitialized_copy_n <https://llvm.org/D116023>`_
 | `ranges::uninitialized_move <https://llvm.org/D116023>`_
 | `ranges::uninitialized_move_n <https://llvm.org/D116023>`_
 | `ranges::uninitialized_fill <https://llvm.org/D115626>`_
 | `ranges::uninitialized_fill_n <https://llvm.org/D115626>`_
-| ranges::construct_at
-| ranges::destroy
-| ranges::destroy_at
-| ranges::destroy_n",[special.mem.concepts],Konstantin Varlamov,In progress
+| `ranges::construct_at <https://llvm.org/D116078>`_
+| `ranges::destroy <https://llvm.org/D116078>`_
+| `ranges::destroy_at <https://llvm.org/D116078>`_
+| `ranges::destroy_n <https://llvm.org/D116078>`_",[special.mem.concepts],Konstantin Varlamov,✅
 [strings],Adds begin/end and updates const_iterator.,[iterator.concepts],Unassigned,Not started
 [views.span],Same as [strings],[iterator.concepts],Unassigned,Not started
 `[iterator.cust.move] <http://wg21.link/iterator.cust.move>`_,`ranges::iter_move <https://llvm.org/D99873>`_,,Zoe Carver,✅
 `[iterator.cust.swap] <http://wg21.link/iterator.cust.swap>`_,`ranges::iter_swap <https://llvm.org/D102809>`_,iter_value_t,Zoe Carver,✅
 `[iterator.concepts] <http://wg21.link/iterator.concepts>`_,"| `indirectly_readable <https://llvm.org/D100073>`_
 | `indirectly_writable <https://llvm.org/D100073>`_
 | `weakly_incrementable <https://llvm.org/D100080>`_
 | `incrementable <https://llvm.org/D100080>`_

libcxx/include/CMakeLists.txt

set(files
   __memory/allocator.h
   __memory/allocator_arg_t.h
   __memory/allocator_traits.h
   __memory/auto_ptr.h
   __memory/compressed_pair.h
   __memory/concepts.h
   __memory/construct_at.h
   __memory/pointer_traits.h
+  __memory/ranges_construct_at.h
   __memory/ranges_uninitialized_algorithms.h
   __memory/raw_storage_iterator.h
   __memory/shared_ptr.h
   __memory/temporary_buffer.h
   __memory/uninitialized_algorithms.h
   __memory/unique_ptr.h
   __memory/uses_allocator.h
   __memory/voidify.h

libcxx/include/__memory/construct_at.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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_CONSTRUCT_AT_H
 #define _LIBCPP___MEMORY_CONSTRUCT_AT_H
 
 #include <__config>
 #include <__debug>
 #include <__iterator/access.h>
 #include <__memory/addressof.h>
+#include <__memory/voidify.h>
 #include <__utility/forward.h>
 #include <type_traits>
 #include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // construct_at
 
 #if _LIBCPP_STD_VER > 17
 
 template<class _Tp, class ..._Args, class = decltype(
     ::new (declval<void*>()) _Tp(declval<_Args>()...)
 )>
-_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 constexpr _Tp* construct_at(_Tp* __location, _Args&& ...__args) {
     _LIBCPP_ASSERT(__location, "null pointer given to construct_at");
-    return ::new ((void*)__location) _Tp(_VSTD::forward<_Args>(__args)...);
+    return ::new (_VSTD::__voidify(*__location)) _Tp(_VSTD::forward<_Args>(__args)...);
 }
 
 #endif
 
 // destroy_at
 
 // The internal functions are available regardless of the language version (with the exception of the `__destroy_at`
 // taking an array).
 
 template <class _ForwardIterator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
-void __destroy(_ForwardIterator, _ForwardIterator);
+_ForwardIterator __destroy(_ForwardIterator, _ForwardIterator);
 
 template <class _Tp, typename enable_if<!is_array<_Tp>::value, int>::type = 0>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
 void __destroy_at(_Tp* __loc) {
     _LIBCPP_ASSERT(__loc, "null pointer given to destroy_at");
     __loc->~_Tp();
 }
 
 #if _LIBCPP_STD_VER > 17
 template <class _Tp, typename enable_if<is_array<_Tp>::value, int>::type = 0>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
 void __destroy_at(_Tp* __loc) {
     _LIBCPP_ASSERT(__loc, "null pointer given to destroy_at");
     _VSTD::__destroy(_VSTD::begin(*__loc), _VSTD::end(*__loc));
 }
 #endif
 
 template <class _ForwardIterator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
-void __destroy(_ForwardIterator __first, _ForwardIterator __last) {
+_ForwardIterator __destroy(_ForwardIterator __first, _ForwardIterator __last) {
     for (; __first != __last; ++__first)
         _VSTD::__destroy_at(_VSTD::addressof(*__first));
+    return __first;
 }
 
 #if _LIBCPP_STD_VER > 14
 
 template <class _Tp, enable_if_t<!is_array_v<_Tp>, int> = 0>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
 void destroy_at(_Tp* __loc) {
     _VSTD::__destroy_at(__loc);
 }
 
 #if _LIBCPP_STD_VER > 17
 template <class _Tp, enable_if_t<is_array_v<_Tp>, int> = 0>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
 void destroy_at(_Tp* __loc) {
   _VSTD::__destroy_at(__loc);
 }
 #endif
 
 template <class _ForwardIterator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
 void destroy(_ForwardIterator __first, _ForwardIterator __last) {
-    _VSTD::__destroy(_VSTD::move(__first), _VSTD::move(__last));
+  (void)_VSTD::__destroy(_VSTD::move(__first), _VSTD::move(__last));
 }
 
 template <class _ForwardIterator, class _Size>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
 _ForwardIterator destroy_n(_ForwardIterator __first, _Size __n) {
     for (; __n > 0; (void)++__first, --__n)
         _VSTD::__destroy_at(_VSTD::addressof(*__first));
     return __first;
 }
 
 #endif // _LIBCPP_STD_VER > 14
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MEMORY_CONSTRUCT_AT_H

libcxx/include/__memory/ranges_construct_at.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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_RANGES_CONSTRUCT_AT_H
+#define _LIBCPP___MEMORY_RANGES_CONSTRUCT_AT_H
+
+#include <__concepts/destructible.h>
+#include <__config>
+#include <__function_like.h>
+#include <__iterator/incrementable_traits.h>
+#include <__iterator/readable_traits.h>
+#include <__memory/concepts.h>
+#include <__memory/construct_at.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/dangling.h>
+#include <__utility/declval.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+namespace ranges {
+
+// construct_at
+
+namespace __construct_at {
+
+struct __fn final : private __function_like {
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr explicit __fn(__tag __x) noexcept : __function_like(__x) {}
+
+  template<class _Tp, class... _Args, class = decltype(
+    ::new (declval<void*>()) _Tp(declval<_Args>()...)
+  )>
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr _Tp* operator()(_Tp* __location, _Args&& ...__args) const {
+    return _VSTD::construct_at(__location, _VSTD::forward<_Args>(__args)...);
+  }
+
+};
+
+} // namespace __construct_at
+
+inline namespace __cpo {
+inline constexpr auto construct_at = __construct_at::__fn(__function_like::__tag());
+} // namespace __cpo
+
+// destroy_at
+
+namespace __destroy_at {
+
+struct __fn final : private __function_like {
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr explicit __fn(__tag __x) noexcept : __function_like(__x) {}
+
+  template <destructible _Tp>
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr void operator()(_Tp* __location) const noexcept {
+    _VSTD::destroy_at(__location);
+  }
+
+};
+
+} // namespace __destroy_at
+
+inline namespace __cpo {
+inline constexpr auto destroy_at = __destroy_at::__fn(__function_like::__tag());
+} // namespace __cpo
+
+// destroy
+
+namespace __destroy {
+
+struct __fn final : private __function_like {
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr explicit __fn(__tag __x) noexcept : __function_like(__x) {}
+
+  template <__nothrow_input_iterator _InputIterator, __nothrow_sentinel_for<_InputIterator> _Sentinel>
+    requires destructible<iter_value_t<_InputIterator>>
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr _InputIterator operator()(_InputIterator __first, _Sentinel __last) const noexcept {
+    return _VSTD::__destroy(_VSTD::move(__first), _VSTD::move(__last));
+  }
+
+  template <__nothrow_input_range _InputRange>
+    requires destructible<range_value_t<_InputRange>>
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr borrowed_iterator_t<_InputRange> operator()(_InputRange&& __range) const noexcept {
+    return (*this)(ranges::begin(__range), ranges::end(__range));
+  }
+
+};
+
+} // namespace __destroy
+
+inline namespace __cpo {
+inline constexpr auto destroy = __destroy::__fn(__function_like::__tag());
+} // namespace __cpo
+
+// destroy_n
+
+namespace __destroy_n {
+
+struct __fn final : private __function_like {
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr explicit __fn(__tag __x) noexcept : __function_like(__x) {}
+
+  template <__nothrow_input_iterator _InputIterator>
+    requires destructible<iter_value_t<_InputIterator>>
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr _InputIterator operator()(_InputIterator __first, iter_difference_t<_InputIterator> __n) const noexcept {
+    return _VSTD::destroy_n(_VSTD::move(__first), __n);
+  }
+
+};
+
+} // namespace __destroy_n
+
+inline namespace __cpo {
+inline constexpr auto destroy_n = __destroy_n::__fn(__function_like::__tag());
+} // namespace __cpo
+
+} // namespace ranges
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MEMORY_RANGES_CONSTRUCT_AT_H

libcxx/include/memory

template <nothrow-forward-iterator ForwardIterator, class T>
   requires constructible_from<iter_value_t<ForwardIterator>, const T&>
 ForwardIterator uninitialized_fill_n(ForwardIterator first, iter_difference_t<ForwardIterator> n); // since C++20
 
 }
 
 template <class T, class ...Args>
 constexpr T* construct_at(T* location, Args&& ...args); // since C++20
 
+namespace ranges {
+  template<class T, class... Args>
+    constexpr T* construct_at(T* location, Args&&... args); // since C++20
+}
+
 template <class T>
 void destroy_at(T* location); // constexpr in C++20
 
+namespace ranges {
+  template<destructible T>
+    constexpr void destroy_at(T* location) noexcept; // since C++20
+}
+
 template <class ForwardIterator>
 void destroy(ForwardIterator first, ForwardIterator last); // constexpr in C++20
 
+namespace ranges {
+  template<nothrow-input-iterator InputIterator, nothrow-sentinel-for<InputIterator> Sentinel>
+    requires destructible<iter_value_t<InputIterator>>
+    constexpr InputIterator destroy(InputIterator first, Sentinel last) noexcept; // since C++20
+  template<nothrow-input-range InputRange>
+    requires destructible<range_value_t<InputRange>>
+    constexpr borrowed_iterator_t<InputRange> destroy(InputRange&& range) noexcept; // since C++20
+}
+
 template <class ForwardIterator, class Size>
 ForwardIterator destroy_n(ForwardIterator first, Size n); // constexpr in C++20
 
+namespace ranges {
+  template<nothrow-input-iterator InputIterator>
+    requires destructible<iter_value_t<InputIterator>>
+    constexpr InputIterator destroy_n(InputIterator first, iter_difference_t<InputIterator> n) noexcept; // since C++20
+}
+
 template <class InputIterator, class ForwardIterator>
  ForwardIterator uninitialized_move(InputIterator first, InputIterator last, ForwardIterator result);
 
 namespace ranges {
 
 template<class InputIterator, class OutputIterator>
 using uninitialized_move_result = in_out_result<InputIterator, OutputIterator>; // since C++20
 

 #include <__memory/allocation_guard.h>
 #include <__memory/allocator.h>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/concepts.h>
 #include <__memory/construct_at.h>
 #include <__memory/pointer_traits.h>
+#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 <compare>

libcxx/include/module.modulemap

module __memory {
       module allocator                       { private header "__memory/allocator.h" }
       module allocator_arg_t                 { private header "__memory/allocator_arg_t.h" }
       module allocator_traits                { private header "__memory/allocator_traits.h" }
       module auto_ptr                        { private header "__memory/auto_ptr.h" }
       module compressed_pair                 { private header "__memory/compressed_pair.h" }
       module concepts                        { private header "__memory/concepts.h" }
       module construct_at                    { private header "__memory/construct_at.h" }
       module pointer_traits                  { private header "__memory/pointer_traits.h" }
+      module ranges_construct_at {
+        private header "__memory/ranges_construct_at.h"
+        export __function_like
+      }
       module ranges_uninitialized_algorithms {
         private header "__memory/ranges_uninitialized_algorithms.h"
         export __function_like
       }
       module raw_storage_iterator            { private header "__memory/raw_storage_iterator.h" }
       module shared_ptr                      { private header "__memory/shared_ptr.h" }
       module temporary_buffer                { private header "__memory/temporary_buffer.h" }
       module uninitialized_algorithms        { private header "__memory/uninitialized_algorithms.h" }

libcxx/test/libcxx/diagnostics/detail.headers/memory/ranges_construct_at.module.verify.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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__memory/ranges_construct_at.h'}}
+#include <__memory/ranges_construct_at.h>

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.construct/construct_at.pass.cpp

 
 // <memory>
 
 // template <class T, class ...Args>
 // constexpr T* construct_at(T* location, Args&& ...args);
 
 #include <memory>
 #include <cassert>
+#include <utility>
 
+#include "test_iterators.h"
 
 struct Foo {
     int a;
     char b;
     double c;
     constexpr Foo() { }
     constexpr Foo(int a, char b, double c) : a(a), b(b), c(c) { }
     constexpr Foo(int a, char b, double c, int* count) : Foo(a, b, c) { *count += 1; }
constexpr bool test()
         p->~Counted();
         assert(count == 0);
         a.deallocate(p, 2);
     }
 
     return true;
 }
 
-// Make sure std::construct_at SFINAEs out based on the validity of calling
-// the constructor, instead of hard-erroring.
-template <typename T, typename = decltype(
-    std::construct_at((T*)nullptr, 1, 2) // missing arguments for Foo(...)
-)>
-constexpr bool test_sfinae(int) { return false; }
-template <typename T>
-constexpr bool test_sfinae(...) { return true; }
-static_assert(test_sfinae<Foo>(int()));
+template <class ...Args, class = decltype(std::construct_at(std::declval<Args>()...))>
+constexpr bool can_construct_at(Args&&...) { return true; }
+
+template <class ...Args>
+constexpr bool can_construct_at(...) { return false; }
+
+// Check that SFINAE works.
+static_assert( can_construct_at((int*)nullptr, 42));
+static_assert( can_construct_at((Foo*)nullptr, 1, '2', 3.0));
+static_assert(!can_construct_at((Foo*)nullptr, 1, '2'));
+static_assert(!can_construct_at((Foo*)nullptr, 1, '2', 3.0, 4));
+static_assert(!can_construct_at(nullptr, 1, '2', 3.0));
+static_assert(!can_construct_at((int*)nullptr, 1, '2', 3.0));
+static_assert(!can_construct_at(contiguous_iterator<Foo*>(), 1, '2', 3.0));
+// Can't construct function pointers.
+static_assert(!can_construct_at((int(*)())nullptr));
+static_assert(!can_construct_at((int(*)())nullptr, nullptr));
 
 int main(int, char**)
 {
     test();
     static_assert(test());
     return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.construct/ranges_construct_at.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts, libcpp-has-no-incomplete-ranges
+
+// <memory>
+//
+// namespace ranges {
+//   template<class T, class... Args>
+//     constexpr T* construct_at(T* location, Args&&... args); // since C++20
+// }
+
+#include <cassert>
+#include <initializer_list>
+#include <memory>
+#include <type_traits>
+
+#include "test_iterators.h"
+#include "test_macros.h"
+
+// TODO(varconst): consolidate the ADL checks into a single file.
+// Because this is a variable and not a function, it's guaranteed that ADL won't be used. However,
+// implementations are allowed to use a different mechanism to achieve this effect, so this check is
+// libc++-specific.
+LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::construct_at)>);
+
+struct Foo {
+  int x = 0;
+  int y = 0;
+
+  constexpr Foo() = default;
+  constexpr explicit Foo(int set_x, int set_y) : x(set_x), y(set_y) {}
+  constexpr Foo(std::initializer_list<int>);
+
+  void operator&() const = delete;
+  void operator,(auto&&) const = delete;
+};
+
+ASSERT_SAME_TYPE(decltype(std::ranges::construct_at((int*)nullptr)), int*);
+ASSERT_SAME_TYPE(decltype(std::ranges::construct_at((Foo*)nullptr)), Foo*);
+
+struct Counted {
+  int& count;
+
+  constexpr Counted(int& count_ref) : count(count_ref) { ++count; }
+  constexpr Counted(const Counted& rhs) : count(rhs.count) { ++count; }
+  constexpr ~Counted() { --count; }
+};
+
+constexpr bool test() {
+  // Value initialization.
+  {
+    int x = 1;
+
+    int* result = std::ranges::construct_at(&x);
+    assert(result == &x);
+    assert(x == 0);
+  }
+
+  // Copy initialization.
+  {
+    int x = 1;
+
+    int* result = std::ranges::construct_at(&x, 42);
+    assert(result == &x);
+    assert(x == 42);
+  }
+
+  // Explicit multiargument constructor; also checks that the initializer list constructor is not invoked.
+  {
+    Foo f;
+
+    Foo* result = std::ranges::construct_at(std::addressof(f), 42, 123);
+    assert(result == std::addressof(f));
+    assert(f.x == 42);
+    assert(f.y == 123);
+  }
+
+  // Works with buffers of uninitialized memory.
+  {
+    std::allocator<Counted> alloc;
+    Counted* out = alloc.allocate(2);
+    int count = 0;
+
+    Counted* result = std::ranges::construct_at(out, count);
+    assert(result == out);
+    assert(count == 1);
+
+    result = std::ranges::construct_at(out + 1, count);
+    assert(result == out + 1);
+    assert(count == 2);
+
+    std::destroy(out, out + 1);
+    alloc.deallocate(out, 2);
+  }
+
+  // Works with const pointers.
+  {
+    int x = 1;
+    const int* ptr = &x;
+
+    const int* result = std::ranges::construct_at(ptr, 42);
+    assert(result == ptr);
+    assert(x == 42);
+  }
+
+  return true;
+}
+
+constexpr bool can_construct_at(auto&&... args)
+  requires requires { std::ranges::construct_at(decltype(args)(args)...); }
+  { return true; }
+
+constexpr bool can_construct_at(auto&&...) { return false; }
+
+// Check that SFINAE works.
+static_assert( can_construct_at((Foo*)nullptr, 1, 2));
+static_assert(!can_construct_at((Foo*)nullptr, 1));
+static_assert(!can_construct_at((Foo*)nullptr, 1, 2, 3));
+static_assert(!can_construct_at(nullptr, 1, 2));
+static_assert(!can_construct_at((int*)nullptr, 1, 2));
+static_assert(!can_construct_at(contiguous_iterator<Foo*>(), 1, 2));
+// Can't construct function pointers.
+static_assert(!can_construct_at((int(*)())nullptr));
+static_assert(!can_construct_at((int(*)())nullptr, nullptr));
+// TODO(varconst): check that array types work once D114649 implementing LWG3639 lands.
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy.pass.cpp

 }
 
 int main(int, char**) {
     tests();
 #if TEST_STD_VER > 17
     test_arrays();
     static_assert(tests());
     // TODO: Until std::construct_at has support for arrays, it's impossible to test this
-    //       in a constexpr context.
+    //       in a constexpr context (see https://reviews.llvm.org/D114903).
     // static_assert(test_arrays());
 #endif
     return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_at.pass.cpp

struct Counted {
     TEST_CONSTEXPR_CXX20 ~Counted() { --*counter_; }
     friend void operator&(Counted) = delete;
 };
 
 struct VirtualCounted {
     int* counter_;
     TEST_CONSTEXPR VirtualCounted(int* counter) : counter_(counter) { ++*counter_; }
     TEST_CONSTEXPR_CXX20 virtual ~VirtualCounted() { --*counter_; }
-    friend void operator&(VirtualCounted) = delete;
+    void operator&() const = delete;
 };
 
 struct DerivedCounted : VirtualCounted {
     TEST_CONSTEXPR DerivedCounted(int* counter) : VirtualCounted(counter) { }
     TEST_CONSTEXPR_CXX20 ~DerivedCounted() override { }
-    friend void operator&(DerivedCounted) = delete;
 };
 
 #if TEST_STD_VER > 17
 constexpr bool test_arrays() {
     {
         using Array = Counted[3];
         using Alloc = std::allocator<Array>;
         Alloc alloc;

 }
 
 int main(int, char**) {
     test();
 #if TEST_STD_VER > 17
     test_arrays();
     static_assert(test());
     // TODO: Until std::construct_at has support for arrays, it's impossible to test this
-    //       in a constexpr context.
+    //       in a constexpr context (see https://reviews.llvm.org/D114903).
     // static_assert(test_arrays());
 #endif
     return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_n.pass.cpp

 }
 
 int main(int, char**) {
     tests();
 #if TEST_STD_VER > 17
     test_arrays();
     static_assert(tests());
     // TODO: Until std::construct_at has support for arrays, it's impossible to test this
-    //       in a constexpr context.
+    //       in a constexpr context (see https://reviews.llvm.org/D114903).
     // static_assert(test_arrays());
 #endif
     return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/ranges_destroy.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts, libcpp-has-no-incomplete-ranges
+
+// <memory>
+//
+// namespace ranges {
+//   template<nothrow-input-iterator InputIterator, nothrow-sentinel-for<InputIterator> Sentinel>
+//     requires destructible<iter_value_t<InputIterator>>
+//     constexpr InputIterator destroy(InputIterator first, Sentinel last) noexcept; // since C++20
+//   template<nothrow-input-range InputRange>
+//     requires destructible<range_value_t<InputRange>>
+//     constexpr borrowed_iterator_t<InputRange> destroy(InputRange&& range) noexcept; // since C++20
+// }
+
+#include <cassert>
+#include <memory>
+#include <ranges>
+#include <type_traits>
+
+#include "test_iterators.h"
+#include "test_macros.h"
+
+// TODO(varconst): consolidate the ADL checks into a single file.
+// Because this is a variable and not a function, it's guaranteed that ADL won't be used. However,
+// implementations are allowed to use a different mechanism to achieve this effect, so this check is
+// libc++-specific.
+LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::destroy)>);
+
+struct NotNothrowDtrable {
+  ~NotNothrowDtrable() noexcept(false) {}
+};
+static_assert(!std::is_invocable_v<decltype(std::ranges::destroy), NotNothrowDtrable*, NotNothrowDtrable*>);
+
+struct Counted {
+  int& count;
+
+  constexpr Counted(int& count_ref) : count(count_ref) { ++count; }
+  constexpr Counted(const Counted& rhs) : count(rhs.count) { ++count; }
+  constexpr ~Counted() { --count; }
+
+  friend void operator&(Counted) = delete;
+};
+
+template <class Iterator>
+constexpr void test() {
+  // (iterator + sentinel) overload.
+  {
+    constexpr int N = 5;
+    std::allocator<Counted> alloc;
+    using Traits = std::allocator_traits<decltype(alloc)>;
+    int counter = 0;
+
+    Counted* out = Traits::allocate(alloc, N);
+    for (int i = 0; i != N; ++i) {
+      Traits::construct(alloc, out + i, counter);
+    }
+    assert(counter == N);
+
+    std::ranges::destroy(Iterator(out), Iterator(out + N));
+    assert(counter == 0);
+
+    Traits::deallocate(alloc, out, N);
+  }
+
+  // (range) overload.
+  {
+    constexpr int N = 5;
+    std::allocator<Counted> alloc;
+    using Traits = std::allocator_traits<decltype(alloc)>;
+    int counter = 0;
+
+    Counted* out = Traits::allocate(alloc, N);
+    for (int i = 0; i != N; ++i) {
+      Traits::construct(alloc, out + i, counter);
+    }
+    assert(counter == N);
+
+    auto range = std::ranges::subrange(Iterator(out), Iterator(out + N));
+    std::ranges::destroy(range);
+    assert(counter == 0);
+
+    Traits::deallocate(alloc, out, N);
+  }
+}
+
+constexpr bool tests() {
+  test<Counted*>();
+  test<forward_iterator<Counted*>>();
+
+  return true;
+}
+
+constexpr bool test_arrays() {
+  // One-dimensional array, (iterator + sentinel) overload.
+  {
+    constexpr int N = 5;
+    constexpr int M = 3;
+
+    using Array = Counted[M];
+    std::allocator<Array> alloc;
+    using Traits = std::allocator_traits<decltype(alloc)>;
+    int counter = 0;
+
+    Array* buffer = Traits::allocate(alloc, N);
+    for (int i = 0; i != N; ++i) {
+      Array& array_ref = *(buffer + i);
+      for (int j = 0; j != M; ++j) {
+        Traits::construct(alloc, std::addressof(array_ref[j]), counter);
+      }
+    }
+    assert(counter == N * M);
+
+    std::ranges::destroy(buffer, buffer + N);
+    assert(counter == 0);
+
+    Traits::deallocate(alloc, buffer, N);
+  }
+
+  // One-dimensional array, (range) overload.
+  {
+    constexpr int N = 5;
+    constexpr int A = 3;
+
+    using Array = Counted[A];
+    std::allocator<Array> alloc;
+    using Traits = std::allocator_traits<decltype(alloc)>;
+    int counter = 0;
+
+    Array* buffer = Traits::allocate(alloc, N);
+    for (int i = 0; i != N; ++i) {
+      Array& array_ref = *(buffer + i);
+      for (int j = 0; j != A; ++j) {
+        Traits::construct(alloc, std::addressof(array_ref[j]), counter);
+      }
+    }
+    assert(counter == N * A);
+
+    auto range = std::ranges::subrange(buffer, buffer + N);
+    std::ranges::destroy(range);
+    assert(counter == 0);
+
+    Traits::deallocate(alloc, buffer, N);
+  }
+
+  // Multidimensional array, (iterator + sentinel ) overload.
+  {
+    constexpr int N = 5;
+    constexpr int A = 3;
+    constexpr int B = 3;
+
+    using Array = Counted[A][B];
+    std::allocator<Array> alloc;
+    using Traits = std::allocator_traits<decltype(alloc)>;
+    int counter = 0;
+
+    Array* buffer = Traits::allocate(alloc, N);
+    for (int i = 0; i != N; ++i) {
+      Array& array_ref = *(buffer + i);
+      for (int j = 0; j != A; ++j) {
+        for (int k = 0; k != B; ++k) {
+          Traits::construct(alloc, std::addressof(array_ref[j][k]), counter);
+        }
+      }
+    }
+    assert(counter == N * A * B);
+
+    std::ranges::destroy(buffer, buffer + N);
+    assert(counter == 0);
+
+    Traits::deallocate(alloc, buffer, N);
+  }
+
+  // Multidimensional array, (range) overload.
+  {
+    constexpr int N = 5;
+    constexpr int A = 3;
+    constexpr int B = 3;
+
+    using Array = Counted[A][B];
+    std::allocator<Array> alloc;
+    using Traits = std::allocator_traits<decltype(alloc)>;
+    int counter = 0;
+
+    Array* buffer = Traits::allocate(alloc, N);
+    for (int i = 0; i != N; ++i) {
+      Array& array_ref = *(buffer + i);
+      for (int j = 0; j != A; ++j) {
+        for (int k = 0; k != B; ++k) {
+          Traits::construct(alloc, std::addressof(array_ref[j][k]), counter);
+        }
+      }
+    }
+    assert(counter == N * A * B);
+
+    std::ranges::destroy(buffer, buffer + N);
+    assert(counter == 0);
+
+    Traits::deallocate(alloc, buffer, N);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  test_arrays();
+
+  static_assert(tests());
+  // TODO: Until std::construct_at has support for arrays, it's impossible to test this
+  //       in a constexpr context (see https://reviews.llvm.org/D114903).
+  // static_assert(test_arrays());
+
+  return 0;
+}

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/ranges_destroy_at.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts, libcpp-has-no-incomplete-ranges
+
+// <memory>
+//
+// namespace ranges {
+//   template<destructible T>
+//     constexpr void destroy_at(T* location) noexcept; // since C++20
+// }
+
+#include <cassert>
+#include <memory>
+#include <type_traits>
+
+#include "test_macros.h"
+
+// TODO(varconst): consolidate the ADL checks into a single file.
+// Because this is a variable and not a function, it's guaranteed that ADL won't be used. However,
+// implementations are allowed to use a different mechanism to achieve this effect, so this check is
+// libc++-specific.
+LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::destroy_at)>);
+
+struct NotNothrowDtrable {
+  ~NotNothrowDtrable() noexcept(false) {}
+};
+static_assert(!std::is_invocable_v<decltype(std::ranges::destroy_at), NotNothrowDtrable*>);
+
+struct Counted {
+  int& count;
+
+  constexpr Counted(int& count_ref) : count(count_ref) { ++count; }
+  constexpr ~Counted() { --count; }
+
+  friend void operator&(Counted) = delete;
+};
+
+struct VirtualCountedBase {
+  int& count;
+
+  constexpr VirtualCountedBase(int& count_ref) : count(count_ref) { ++count; }
+  constexpr virtual ~VirtualCountedBase() { --count; }
+
+  void operator&() const = delete;
+};
+
+struct VirtualCountedDerived : VirtualCountedBase {
+  constexpr VirtualCountedDerived(int& count_ref) : VirtualCountedBase(count_ref) {}
+
+  // Without a definition, GCC gives an error when the destructor is invoked in a constexpr context (see
+  // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=93413).
+  constexpr ~VirtualCountedDerived() override {}
+};
+
+constexpr bool test() {
+  // Destroying a "trivial" object.
+  {
+    std::allocator<Counted> alloc;
+    using Traits = std::allocator_traits<decltype(alloc)>;
+    int counter = 0;
+
+    Counted* buffer = Traits::allocate(alloc, 2);
+    Traits::construct(alloc, buffer, counter);
+    Traits::construct(alloc, buffer + 1, counter);
+    assert(counter == 2);
+
+    std::ranges::destroy_at(buffer);
+    assert(counter == 1);
+    std::ranges::destroy_at(buffer + 1);
+    assert(counter == 0);
+
+    Traits::deallocate(alloc, buffer, 2);
+  }
+
+  // Destroying a derived object with a virtual destructor.
+  {
+    std::allocator<VirtualCountedDerived> alloc;
+    using Traits = std::allocator_traits<decltype(alloc)>;
+    int counter = 0;
+
+    VirtualCountedDerived* buffer = Traits::allocate(alloc, 2);
+    Traits::construct(alloc, buffer, counter);
+    Traits::construct(alloc, buffer + 1, counter);
+    assert(counter == 2);
+
+    std::ranges::destroy_at(buffer);
+    assert(counter == 1);
+    std::ranges::destroy_at(buffer + 1);
+    assert(counter == 0);
+
+    Traits::deallocate(alloc, buffer, 2);
+  }
+
+  return true;
+}
+
+constexpr bool test_arrays() {
+  // Pointer to an array.
+  {
+    using Array = Counted[3];
+    std::allocator<Array> alloc;
+    using Traits = std::allocator_traits<decltype(alloc)>;
+    int counter = 0;
+
+    Array* array = Traits::allocate(alloc, 1);
+    Array& array_ref = *array;
+    for (int i = 0; i != 3; ++i) {
+      Traits::construct(alloc, std::addressof(array_ref[i]), counter);
+    }
+    assert(counter == 3);
+
+    std::ranges::destroy_at(array);
+    assert(counter == 0);
+
+    Traits::deallocate(alloc, array, 1);
+  }
+
+  // Pointer to a two-dimensional array.
+  {
+    using Array = Counted[3][2];
+    std::allocator<Array> alloc;
+    using Traits = std::allocator_traits<decltype(alloc)>;
+    int counter = 0;
+
+    Array* array = Traits::allocate(alloc, 1);
+    Array& array_ref = *array;
+    for (int i = 0; i != 3; ++i) {
+      for (int j = 0; j != 2; ++j) {
+        Traits::construct(alloc, std::addressof(array_ref[i][j]), counter);
+      }
+    }
+    assert(counter == 3 * 2);
+
+    std::ranges::destroy_at(array);
+    assert(counter == 0);
+
+    Traits::deallocate(alloc, array, 1);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  test_arrays();
+
+  static_assert(test());
+  // TODO: Until std::construct_at has support for arrays, it's impossible to test this
+  //       in a constexpr context (see https://reviews.llvm.org/D114903).
+  // static_assert(test_arrays());
+
+  return 0;
+}

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/ranges_destroy_n.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts, libcpp-has-no-incomplete-ranges
+
+// <memory>
+//
+// namespace ranges {
+//   template<nothrow-input-iterator InputIterator>
+//     requires destructible<iter_value_t<InputIterator>>
+//     constexpr InputIterator destroy_n(InputIterator first, iter_difference_t<InputIterator> n) noexcept; // since C++20
+// }
+
+#include <cassert>
+#include <memory>
+#include <ranges>
+#include <type_traits>
+
+#include "test_iterators.h"
+#include "test_macros.h"
+
+// TODO(varconst): consolidate the ADL checks into a single file.
+// Because this is a variable and not a function, it's guaranteed that ADL won't be used. However,
+// implementations are allowed to use a different mechanism to achieve this effect, so this check is
+// libc++-specific.
+LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::destroy_n)>);
+
+struct NotNothrowDtrable {
+  ~NotNothrowDtrable() noexcept(false) {}
+};
+static_assert(!std::is_invocable_v<decltype(std::ranges::destroy_n), NotNothrowDtrable*, int>);
+
+struct Counted {
+  int& count;
+
+  constexpr Counted(int& count_ref) : count(count_ref) { ++count; }
+  constexpr Counted(const Counted& rhs) : count(rhs.count) { ++count; }
+  constexpr ~Counted() { --count; }
+
+  friend void operator&(Counted) = delete;
+};
+
+template <class Iterator>
+constexpr void test() {
+  {
+    constexpr int N = 5;
+    std::allocator<Counted> alloc;
+    using Traits = std::allocator_traits<decltype(alloc)>;
+    int counter = 0;
+
+    Counted* out = Traits::allocate(alloc, N);
+    for (int i = 0; i != N; ++i) {
+      Traits::construct(alloc, out + i, counter);
+    }
+    assert(counter == N);
+
+    std::ranges::destroy_n(Iterator(out), N);
+    assert(counter == 0);
+
+    Traits::deallocate(alloc, out, N);
+  }
+}
+
+constexpr bool tests() {
+  test<Counted*>();
+  test<forward_iterator<Counted*>>();
+
+  return true;
+}
+
+constexpr bool test_arrays() {
+  // One-dimensional array.
+  {
+    constexpr int N = 5;
+    constexpr int M = 3;
+
+    using Array = Counted[M];
+    std::allocator<Array> alloc;
+    using Traits = std::allocator_traits<decltype(alloc)>;
+    int counter = 0;
+
+    Array* buffer = Traits::allocate(alloc, N);
+    for (int i = 0; i != N; ++i) {
+      Array& array_ref = *(buffer + i);
+      for (int j = 0; j != M; ++j) {
+        Traits::construct(alloc, std::addressof(array_ref[j]), counter);
+      }
+    }
+    assert(counter == N * M);
+
+    std::ranges::destroy_n(buffer, N);
+    assert(counter == 0);
+
+    Traits::deallocate(alloc, buffer, N);
+  }
+
+  // Multidimensional array.
+  {
+    constexpr int N = 5;
+    constexpr int A = 3;
+    constexpr int B = 3;
+
+    using Array = Counted[A][B];
+    std::allocator<Array> alloc;
+    using Traits = std::allocator_traits<decltype(alloc)>;
+    int counter = 0;
+
+    Array* buffer = Traits::allocate(alloc, N);
+    for (int i = 0; i != N; ++i) {
+      Array& array_ref = *(buffer + i);
+      for (int j = 0; j != A; ++j) {
+        for (int k = 0; k != B; ++k) {
+          Traits::construct(alloc, std::addressof(array_ref[j][k]), counter);
+        }
+      }
+    }
+    assert(counter == N * A * B);
+
+    std::ranges::destroy_n(buffer, N);
+    assert(counter == 0);
+
+    Traits::deallocate(alloc, buffer, N);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  test_arrays();
+
+  static_assert(tests());
+  // TODO: Until std::construct_at has support for arrays, it's impossible to test this
+  //       in a constexpr context (see https://reviews.llvm.org/D114903).
+  // static_assert(test_arrays());
+
+  return 0;
+}