[libc++][ranges] Implement `uninitialized_value_construct{,_n}` and `uninitialized_fill{,_n}`.

[var-const]

Summary

Also:

• refactor out __voidify;
• use the destroy algorithm internally;
• refactor out helper classes used in tests for uninitialized_* algorithms.

[ldionne]

libcxx/include/__memory/ranges_uninitialized_algorithms.h

49–51

How many columns do you have your Clang format configured to?

96

Please use namespace uninitialized_value_construct_ns and __fn until we've settled on whether we want to move everything to a different convention, to avoid inconsistencies.

libcxx/include/__memory/uninitialized_algorithms.h

100

Let's make those _LIBCPP_HIDE_FROM_ABI.

152

Here and elsewhere.

libcxx/include/__memory/voidify.h

26–30

Any reason why we don't literally copy-paste the definition from the Standard?

[var-const]

libcxx/include/__memory/ranges_uninitialized_algorithms.h

49–51

I'm actually not using clang-format yet (though I do intend to start using it), so this is formatted manually. I set it to 100 columns (FWIW, my personal preference is 80, but a lot of code I've seen uses 100, and quite a few declarations are by necessity verbose, making me lean towards 100).

libcxx/include/__memory/uninitialized_algorithms.h

100

I marked them _LIBCPP_INLINE_VISIBILITY and inline for consistency with newer algorithms (e.g. uninitialized_move). Please let me know if either or both of these changes are wrong.

Regarding the visibility annotation -- I realize _LIBCPP_INLINE_VISIBILITY is just an "alias" for _LIBCPP_HIDE_FROM_ABI. Which form is preferable here? The existing algorithms use _LIBCPP_INLINE_VISIBILITY (when they use an annotation).

152

Thanks!

libcxx/include/__memory/voidify.h

26–30

This is based on a previous (unfinished) discussion in D115315. I think this form was advocated by @Quuxplusone. I didn't have a strong preference at the time of the discussion, but currently I'm leaning towards going with the Standard's definition.

My understanding is that the main advantage of using the C-style cast is its simplicity. However, it now seems to me that it's not so much simplicity as brevity, which isn't the same thing. The implementation from the Standard is, without doubt, clunky, however it a) explains exactly what's going on and b) draws attention to the fact that something unusual is going on. A C-style cast, however, can do one of several things, and remembering the rules and going through the exercise of applying them in this case is, I think, an extra burden for the reader; furthermore, given the C-style cast's brevity, the reader may be _unlikely_ to realize it's even an exercise worth going through because nothing really draws attention to it (other than "Why are we using a C-style cast?").

Finally, copy-pasting the Standard's definition is conceptually simpler. For the reader, there is no need to mentally verify that the two forms achieve exactly the same effect.

For these reasons, I'm currently leaning towards changing this to use the static_cast + const_cast combo. However, I would wait for @Quuxplusone's comments before making the change.

[var-const]

Address feedback, rebase on main.

[ldionne]

LGTM with my comments applied. Thanks!

libcxx/include/__memory/construct_at.h

47–49

We don't need this anymore since we are using __destroy from the is_array_v overload of destroy_at below.

libcxx/include/__memory/ranges_uninitialized_algorithms.h

49–51

Our libcxx/.clang-format uses 120 columns because indeed, we often have very verbose declarations.

libcxx/include/__memory/uninitialized_algorithms.h

100

_LIBCPP_HIDE_FROM_ABI is the newer name for _LIBCPP_INLINE_VISIBILITY. I added an alias instead of renaming everything to _LIBCPP_HIDE_FROM_ABI because that would have created a lot of code churn.

I would say use _LIBCPP_HIDE_FROM_ABI for all new functions and functions that you are touching anyway.

libcxx/include/__memory/voidify.h

26–30

I +1 going with the standard's definition (and that's what I did when I first introduced __voidify before we removed it).

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.fill/ranges_uninitialized_fill.pass.cpp

99–100

Since we are not testing std::destroy here, I would *not* add these assertions (here and in the tests for uninitialized_default_construct). That will make it more obvious that we only need to destroy them as "boilerplate" for testing the rest, but we're not actually trying to check anything related to destroy itself.

Can you pull out that refactoring and the other ones in the .h file for uninitialized_default_construct in its own patch? It should be trivial to approve but it'll simplify this patch.

[• Quuxplusone]

libcxx/include/__memory/voidify.h

26–30

I'm okay with reintroducing __voidify and copy-pasting from the Standard.
(Personally I still think there was nothing wrong with (void*), but if you're waiting for my feedback here, I'm saying "do what Louis says.")

[var-const]

• address feedback;
• run libcxx-generate-files;
• rebase on main.

[var-const]

Run clang-format on newly-added files.

libcxx/include/__memory/construct_at.h

47–49

I had to replicate the "is array" SFINAE in the internal versions of __destroy, and unfortunately the forward declaration is now once again necessary.

The new change also makes it so that deleting an array of arrays now works in C++17 (previously it only worked in C++20):

int x[][2] = {{0, 1}, {2, 3}, {4, 5}};
std::destroy(x, x + 3); // Previously worked in C++20 mode but not in C++17 mode
// Now works in both modes.

From the discussions I've seen on other patches, I don't think these functions should go out of their way to prevent usability improvements from later standards from seeping into older language modes (FWIW, in libstdc++ the code snippet works in C++17 mode). However, this is still something to call out, and please let me know if you think it's an issue.

libcxx/include/__memory/ranges_uninitialized_algorithms.h

49–51

(I personally prefer less columns because it makes it easier to see several files side-by-side)

Reformatted the files newly-added in this patch with .clang-format. I think I'll do an immediate follow-up once this patch lands to reformat ranges_uninitialized_algorithms with clang-format (to avoid introducing extra delta to this patch).

libcxx/include/__memory/uninitialized_algorithms.h

100

Done, thanks for the explanation.

libcxx/include/__memory/voidify.h

26–30

Thanks! Changed the implementation of __voidify (and added a comment to explain the purpose of the casts).

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.fill/ranges_uninitialized_fill.pass.cpp

99–100

Removed from the code added in this patch, will create a separate patch for uninitialized_default_construct.

[var-const]

Fix compilation

[var-const]

Fix the CI (don't use C++14 and C++17 features in C++11 mode)

[var-const]

Fix CI, fix and update the status page.

[var-const]

Fix CI.

[ldionne]

libcxx/include/__memory/construct_at.h

47–49

We could restore the previous behavior by enclosing the array version of __destroy_at in #if _LIBCPP_STD_VER > 17.

I have a slight (but not strong) preference for that since it keeps us strictly conforming, and allows us to be lazy and not add a libc++ specific test for that "extension". I'll let you decide what to do here, but if you do support the extension, please add a test.

[var-const]

Make destroy_at strictly conforming in C++17, rebase on main.

libcxx/docs/Status/RangesAlgorithms.csv

 Permutation,nth_element,Not assigned,n/a,Not started
 Permutation,inplace_merge,Not assigned,n/a,Not started
 Permutation,make_heap,Not assigned,n/a,Not started
 Permutation,push_heap,Not assigned,n/a,Not started
 Permutation,pop_heap,Not assigned,n/a,Not started
 Permutation,sort_heap,Not assigned,n/a,Not started
 Permutation,prev_permutation,Not assigned,n/a,Not started
 Permutation,next_permutation,Not assigned,n/a,Not started
-Uninitialised memory,uninitialized_copy,var-const,n/a,Not started
-Uninitialised memory,uninitialized_copy_n,var-const,n/a,Not started
-Uninitialised memory,uninitialized_fill,var-const,n/a,Not started
-Uninitialised memory,uninitialized_fill_n,var-const,n/a,Not started
-Uninitialised memory,uninitialized_move,var-const,n/a,Not started
-Uninitialised memory,uninitialized_move_n,var-const,n/a,Not started
-Uninitialised memory,uninitialized_default_construct,var-const,n/a,Not started
-Uninitialised memory,uninitialized_default_construct_n,var-const,n/a,Not started
-Uninitialised memory,uninitialized_value_construct,var-const,n/a,Not started
-Uninitialised memory,uninitialized_value_construct_n,var-const,n/a,Not started
-Uninitialised memory,destroy,var-const,n/a,Not started
-Uninitialised memory,destroy_n,var-const,n/a,Not started
-Uninitialised memory,destroy_at,var-const,n/a,Not started
-Uninitialised memory,construct_at,var-const,n/a,Not started
+Uninitialised memory,uninitialized_copy,Konstantin Varlamov,n/a,Not started
+Uninitialised memory,uninitialized_copy_n,Konstantin Varlamov,n/a,Not started
+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,n/a,Not started
+Uninitialised memory,uninitialized_move_n,Konstantin Varlamov,n/a,Not started
+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

libcxx/docs/Status/RangesPaper.csv

 `[iterator.traits] <http://wg21.link/iterator.traits>`_,`Updates to iterator_traits <https://llvm.org/D99855>`_,"| indirectly_readable_traits
 | incrementable_traits",Christopher Di Bella,✅
 `[special.mem.concepts] <http://wg21.link/special.mem.concepts>`_,"| *nothrow-input-iterator*
 | *nothrow-sentinel-for*
 | *nothrow-input-range*
 | *nothrow-forward-iterator*
 | *nothrow-forward-range*","| [iterator.concepts]
 | [range.refinements]",Konstantin Varlamov,✅
-`[specialized.algorithms] <http://wg21.link/specialized.algorithms>`_,"| `ranges::uninitialized_default_construct <https://llvm.org/D115315>`
-| `ranges::uninitialized_default_construct_n <https://llvm.org/D115315>`
-| ranges::uninitialized_value_construct
-| ranges::uninitialized_value_construct_n
+`[specialized.algorithms] <http://wg21.link/specialized.algorithms>`_,"| `ranges::uninitialized_default_construct <https://llvm.org/D115315>`_
+| `ranges::uninitialized_default_construct_n <https://llvm.org/D115315>`_
+| `ranges::uninitialized_value_construct <https://llvm.org/D115626>`_
+| `ranges::uninitialized_value_construct_n <https://llvm.org/D115626>`_
 | ranges::uninitialized_copy
 | ranges::uninitialized_copy_n
 | ranges::uninitialized_move
 | ranges::uninitialized_move_n
-| ranges::uninitialized_fill
-| ranges::uninitialized_fill_n
+| `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
 [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,✅

libcxx/include/CMakeLists.txt

set(files
   __memory/pointer_traits.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
   __mutex_base
   __numeric/accumulate.h
   __numeric/adjacent_difference.h
   __numeric/exclusive_scan.h
   __numeric/gcd_lcm.h
   __numeric/inclusive_scan.h
   __numeric/inner_product.h
   __numeric/iota.h

libcxx/include/__memory/construct_at.h

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)...);
 }
 
 #endif
 
 // destroy_at
 
-#if _LIBCPP_STD_VER > 14
+// 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);
+void __destroy(_ForwardIterator, _ForwardIterator);
 
-template <class _Tp, enable_if_t<!is_array_v<_Tp>, int> = 0>
+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) {
+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) {
+    for (; __first != __last; ++__first)
+        _VSTD::__destroy_at(_VSTD::addressof(*__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) {
-    _LIBCPP_ASSERT(__loc, "null pointer given to destroy_at");
-    _VSTD::destroy(_VSTD::begin(*__loc), _VSTD::end(*__loc));
+  _VSTD::__destroy_at(__loc);
 }
 #endif
 
 template <class _ForwardIterator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
 void destroy(_ForwardIterator __first, _ForwardIterator __last) {
-    for (; __first != __last; ++__first)
-        _VSTD::destroy_at(_VSTD::addressof(*__first));
+    _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));
+        _VSTD::__destroy_at(_VSTD::addressof(*__first));
     return __first;
 }
 
-#endif
+#endif // _LIBCPP_STD_VER > 14
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MEMORY_CONSTRUCT_AT_H

libcxx/include/__memory/ranges_uninitialized_algorithms.h

 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/readable_traits.h>
 #include <__memory/concepts.h>
 #include <__memory/uninitialized_algorithms.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
+#include <__utility/move.h>
 #include <type_traits>
 
 #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 {
 
 // uninitialized_default_construct
 
 namespace __uninitialized_default_construct {
 
 struct __fn final : private __function_like {
 
   constexpr explicit __fn(__tag __x) noexcept : __function_like(__x) {}
 
   template <__nothrow_forward_iterator _ForwardIterator,
             __nothrow_sentinel_for<_ForwardIterator> _Sentinel>
     requires default_initializable<iter_value_t<_ForwardIterator>>
   _ForwardIterator operator()(_ForwardIterator __first, _Sentinel __last) const {
     using _ValueType = remove_reference_t<iter_reference_t<_ForwardIterator>>;
-    return _VSTD::__uninitialized_default_construct<_ValueType>(__first, __last);
+    return _VSTD::__uninitialized_default_construct<_ValueType>(
+        _VSTD::move(__first), _VSTD::move(__last));
   }
 
   template <__nothrow_forward_range _ForwardRange>
     requires default_initializable<range_value_t<_ForwardRange>>
   borrowed_iterator_t<_ForwardRange> operator()(_ForwardRange&& __range) const {
     return (*this)(ranges::begin(__range), ranges::end(__range));
   }
 
 };
 
-} // namespace __uninitialized_default_construct_ns
+} // namespace __uninitialized_default_construct
 
 inline namespace __cpo {
 inline constexpr auto uninitialized_default_construct =
     __uninitialized_default_construct::__fn(__function_like::__tag());
 } // namespace __cpo
 
 // uninitialized_default_construct_n
 
 namespace __uninitialized_default_construct_n {
 
 struct __fn final : private __function_like {
 
   constexpr explicit __fn(__tag __x) noexcept :
       __function_like(__x) {}
 
   template <__nothrow_forward_iterator _ForwardIterator>
     requires default_initializable<iter_value_t<_ForwardIterator>>
   _ForwardIterator operator()(_ForwardIterator __first,
                               iter_difference_t<_ForwardIterator> __n) const {
     using _ValueType = remove_reference_t<iter_reference_t<_ForwardIterator>>;
-    return _VSTD::__uninitialized_default_construct_n<_ValueType>(__first, __n);
+    return _VSTD::__uninitialized_default_construct_n<_ValueType>(_VSTD::move(__first), __n);
   }
 
 };
 
-} // namespace __uninitialized_default_construct_n_ns
+} // namespace __uninitialized_default_construct_n
 
 inline namespace __cpo {
 inline constexpr auto uninitialized_default_construct_n =
     __uninitialized_default_construct_n::__fn(__function_like::__tag());
 } // namespace __cpo
 
+// uninitialized_value_construct
+
+namespace __uninitialized_value_construct {
+
+struct __fn final : private __function_like {
+
+  constexpr explicit __fn(__tag __x) noexcept : __function_like(__x) {}
+
+  template <__nothrow_forward_iterator _ForwardIterator,
+            __nothrow_sentinel_for<_ForwardIterator> _Sentinel>
+    requires default_initializable<iter_value_t<_ForwardIterator>>
+  _ForwardIterator operator()(_ForwardIterator __first, _Sentinel __last) const {
+    using _ValueType = remove_reference_t<iter_reference_t<_ForwardIterator>>;
+    return _VSTD::__uninitialized_value_construct<_ValueType>(
+        _VSTD::move(__first), _VSTD::move(__last));
+  }
+
+  template <__nothrow_forward_range _ForwardRange>
+    requires default_initializable<range_value_t<_ForwardRange>>
+  borrowed_iterator_t<_ForwardRange> operator()(_ForwardRange&& __range) const {
+    return (*this)(ranges::begin(__range), ranges::end(__range));
+  }
+
+};
+
+} // namespace __uninitialized_value_construct
+
+inline namespace __cpo {
+inline constexpr auto uninitialized_value_construct =
+    __uninitialized_value_construct::__fn(__function_like::__tag());
+} // namespace __cpo
+
+// uninitialized_value_construct_n
+
+namespace __uninitialized_value_construct_n {
+
+struct __fn final : private __function_like {
+
+  constexpr explicit __fn(__tag __x) noexcept : __function_like(__x) {}
+
+  template <__nothrow_forward_iterator _ForwardIterator>
+    requires default_initializable<iter_value_t<_ForwardIterator>>
+  _ForwardIterator operator()(_ForwardIterator __first,
+                              iter_difference_t<_ForwardIterator> __n) const {
+    using _ValueType = remove_reference_t<iter_reference_t<_ForwardIterator>>;
+    return _VSTD::__uninitialized_value_construct_n<_ValueType>(_VSTD::move(__first), __n);
+  }
+
+};
+
+} // namespace __uninitialized_value_construct_n
+
+inline namespace __cpo {
+inline constexpr auto uninitialized_value_construct_n =
+    __uninitialized_value_construct_n::__fn(__function_like::__tag());
+} // namespace __cpo
+
+// uninitialized_fill
+
+namespace __uninitialized_fill {
+
+struct __fn final : private __function_like {
+
+  constexpr explicit __fn(__tag __x) noexcept : __function_like(__x) {}
+
+  template <__nothrow_forward_iterator _ForwardIterator,
+            __nothrow_sentinel_for<_ForwardIterator> _Sentinel,
+            class _Tp>
+    requires constructible_from<iter_value_t<_ForwardIterator>, const _Tp&>
+  _ForwardIterator operator()(_ForwardIterator __first, _Sentinel __last, const _Tp& __x) const {
+    using _ValueType = remove_reference_t<iter_reference_t<_ForwardIterator>>;
+    return _VSTD::__uninitialized_fill<_ValueType>(_VSTD::move(__first), _VSTD::move(__last), __x);
+  }
+
+  template <__nothrow_forward_range _ForwardRange, class _Tp>
+    requires constructible_from<range_value_t<_ForwardRange>, const _Tp&>
+  borrowed_iterator_t<_ForwardRange> operator()(_ForwardRange&& __range, const _Tp& __x) const {
+    return (*this)(ranges::begin(__range), ranges::end(__range), __x);
+  }
+
+};
+
+} // namespace __uninitialized_fil
+
+inline namespace __cpo {
+inline constexpr auto uninitialized_fill = __uninitialized_fill::__fn(__function_like::__tag());
+} // namespace __cpo
+
+// uninitialized_fill_n
+
+namespace __uninitialized_fill_n {
+
+struct __fn final : private __function_like {
+
+  constexpr explicit __fn(__tag __x) noexcept : __function_like(__x) {}
+
+  template <__nothrow_forward_iterator _ForwardIterator, class _Tp>
+    requires constructible_from<iter_value_t<_ForwardIterator>, const _Tp&>
+  _ForwardIterator operator()(_ForwardIterator __first,
+                              iter_difference_t<_ForwardIterator> __n,
+                              const _Tp& __x) const {
+    using _ValueType = remove_reference_t<iter_reference_t<_ForwardIterator>>;
+    return _VSTD::__uninitialized_fill_n<_ValueType>(_VSTD::move(__first), __n, __x);
+  }
+
+};
+
+} // namespace __uninitialized_fill_n
+
+inline namespace __cpo {
+inline constexpr auto uninitialized_fill_n = __uninitialized_fill_n::__fn(__function_like::__tag());
+} // namespace __cpo
+
 } // namespace ranges
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MEMORY_RANGES_UNINITIALIZED_ALGORITHMS_H

libcxx/include/__memory/uninitialized_algorithms.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_UNINITIALIZED_ALGORITHMS_H
 #define _LIBCPP___MEMORY_UNINITIALIZED_ALGORITHMS_H
 
 #include <__config>
 #include <__memory/addressof.h>
 #include <__memory/construct_at.h>
+#include <__memory/voidify.h>
 #include <iterator>
 #include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
catch (...)
         for (; __s != __r; ++__s)
             __s->~value_type();
         throw;
     }
 #endif
     return __r;
 }
 
-template <class _ForwardIterator, class _Tp>
-void
-uninitialized_fill(_ForwardIterator __f, _ForwardIterator __l, const _Tp& __x)
+// uninitialized_fill
+
+template <class _ValueType, class _ForwardIterator, class _Sentinel, class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI
+_ForwardIterator __uninitialized_fill(_ForwardIterator __first, _Sentinel __last, const _Tp& __x)
 {
-    typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
+    _ForwardIterator __idx = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
-    _ForwardIterator __s = __f;
     try
     {
 #endif
-        for (; __f != __l; ++__f)
-            ::new ((void*)_VSTD::addressof(*__f)) value_type(__x);
+        for (; __idx != __last; ++__idx)
+            ::new (_VSTD::__voidify(*__idx)) _ValueType(__x);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
-        for (; __s != __f; ++__s)
-            __s->~value_type();
+        _VSTD::__destroy(__first, __idx);
         throw;
     }
 #endif
+
+    return __idx;
 }
 
-template <class _ForwardIterator, class _Size, class _Tp>
-_ForwardIterator
-uninitialized_fill_n(_ForwardIterator __f, _Size __n, const _Tp& __x)
+template <class _ForwardIterator, class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI
+void uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __x)
 {
-    typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
+    typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+    (void)_VSTD::__uninitialized_fill<_ValueType>(__first, __last, __x);
+}
+
+// uninitialized_fill_n
+
+template <class _ValueType, class _ForwardIterator, class _Size, class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI
+_ForwardIterator __uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
+{
+    _ForwardIterator __idx = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
-    _ForwardIterator __s = __f;
     try
     {
 #endif
-        for (; __n > 0; ++__f, (void) --__n)
-            ::new ((void*)_VSTD::addressof(*__f)) value_type(__x);
+        for (; __n > 0; ++__idx, (void) --__n)
+            ::new (_VSTD::__voidify(*__idx)) _ValueType(__x);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
-        for (; __s != __f; ++__s)
-            __s->~value_type();
+        _VSTD::__destroy(__first, __idx);
         throw;
     }
 #endif
-    return __f;
+
+    return __idx;
+}
+
+template <class _ForwardIterator, class _Size, class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI
+_ForwardIterator uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
+{
+    typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+    return _VSTD::__uninitialized_fill_n<_ValueType>(__first, __n, __x);
 }
 
 #if _LIBCPP_STD_VER > 14
 
 // uninitialized_default_construct
 
 template <class _ValueType, class _ForwardIterator, class _Sentinel>
 inline _LIBCPP_HIDE_FROM_ABI
 _ForwardIterator __uninitialized_default_construct(_ForwardIterator __first, _Sentinel __last) {
     auto __idx = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try {
 #endif
     for (; __idx != __last; ++__idx)
-        ::new ((void*)_VSTD::addressof(*__idx)) _ValueType;
+        ::new (_VSTD::__voidify(*__idx)) _ValueType;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     } catch (...) {
-        _VSTD::destroy(__first, __idx);
+        _VSTD::__destroy(__first, __idx);
         throw;
     }
 #endif
 
     return __idx;
 }
 
 template <class _ForwardIterator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_HIDE_FROM_ABI
 void uninitialized_default_construct(_ForwardIterator __first, _ForwardIterator __last) {
     using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
-    (void)_VSTD::__uninitialized_default_construct<_ValueType>(__first, __last);
+    (void)_VSTD::__uninitialized_default_construct<_ValueType>(
+        _VSTD::move(__first), _VSTD::move(__last));
 }
 
 // uninitialized_default_construct_n
 
 template <class _ValueType, class _ForwardIterator, class _Size>
 inline _LIBCPP_HIDE_FROM_ABI
 _ForwardIterator __uninitialized_default_construct_n(_ForwardIterator __first, _Size __n) {
     auto __idx = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try {
 #endif
     for (; __n > 0; ++__idx, (void) --__n)
-        ::new ((void*)_VSTD::addressof(*__idx)) _ValueType;
+        ::new (_VSTD::__voidify(*__idx)) _ValueType;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     } catch (...) {
-        _VSTD::destroy(__first, __idx);
+        _VSTD::__destroy(__first, __idx);
         throw;
     }
 #endif
 
     return __idx;
 }
 
 template <class _ForwardIterator, class _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_HIDE_FROM_ABI
 _ForwardIterator uninitialized_default_construct_n(_ForwardIterator __first, _Size __n) {
     using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
-    return _VSTD::__uninitialized_default_construct_n<_ValueType>(__first, __n);
+    return _VSTD::__uninitialized_default_construct_n<_ValueType>(_VSTD::move(__first), __n);
 }
 
-template <class _ForwardIterator>
-inline _LIBCPP_INLINE_VISIBILITY
-void uninitialized_value_construct(_ForwardIterator __first, _ForwardIterator __last) {
-    using _Vt = typename iterator_traits<_ForwardIterator>::value_type;
+// uninitialized_value_construct
+
+template <class _ValueType, class _ForwardIterator, class _Sentinel>
+inline _LIBCPP_HIDE_FROM_ABI
+_ForwardIterator __uninitialized_value_construct(_ForwardIterator __first, _Sentinel __last) {
     auto __idx = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try {
 #endif
     for (; __idx != __last; ++__idx)
-        ::new ((void*)_VSTD::addressof(*__idx)) _Vt();
+        ::new (_VSTD::__voidify(*__idx)) _ValueType();
 #ifndef _LIBCPP_NO_EXCEPTIONS
     } catch (...) {
-        _VSTD::destroy(__first, __idx);
+        _VSTD::__destroy(__first, __idx);
         throw;
     }
 #endif
+
+    return __idx;
 }
 
-template <class _ForwardIterator, class _Size>
-inline _LIBCPP_INLINE_VISIBILITY
-_ForwardIterator uninitialized_value_construct_n(_ForwardIterator __first, _Size __n) {
-    using _Vt = typename iterator_traits<_ForwardIterator>::value_type;
+template <class _ForwardIterator>
+inline _LIBCPP_HIDE_FROM_ABI
+void uninitialized_value_construct(_ForwardIterator __first, _ForwardIterator __last) {
+    using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
+    (void)_VSTD::__uninitialized_value_construct<_ValueType>(
+        _VSTD::move(__first), _VSTD::move(__last));
+}
+
+// uninitialized_value_construct_n
+
+template <class _ValueType, class _ForwardIterator, class _Size>
+inline _LIBCPP_HIDE_FROM_ABI
+_ForwardIterator __uninitialized_value_construct_n(_ForwardIterator __first, _Size __n) {
     auto __idx = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try {
 #endif
     for (; __n > 0; ++__idx, (void) --__n)
-        ::new ((void*)_VSTD::addressof(*__idx)) _Vt();
-    return __idx;
+        ::new (_VSTD::__voidify(*__idx)) _ValueType();
 #ifndef _LIBCPP_NO_EXCEPTIONS
     } catch (...) {
-        _VSTD::destroy(__first, __idx);
+        _VSTD::__destroy(__first, __idx);
         throw;
     }
 #endif
+
+    return __idx;
 }
 
+template <class _ForwardIterator, class _Size>
+inline _LIBCPP_HIDE_FROM_ABI
+_ForwardIterator uninitialized_value_construct_n(_ForwardIterator __first, _Size __n) {
+    using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
+    return __uninitialized_value_construct_n<_ValueType>(_VSTD::move(__first), __n);
+}
 
 template <class _InputIt, class _ForwardIt>
 inline _LIBCPP_INLINE_VISIBILITY
 _ForwardIt uninitialized_move(_InputIt __first, _InputIt __last, _ForwardIt __first_res) {
     using _Vt = typename iterator_traits<_ForwardIt>::value_type;
     auto __idx = __first_res;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try {

libcxx/include/__memory/voidify.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_VOIDIFY_H
+#define _LIBCPP___MEMORY_VOIDIFY_H
+
+#include <__config>
+#include <__memory/addressof.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <typename _Tp>
+_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 void* __voidify(_Tp& __from) {
+  // Cast away cv-qualifiers to allow modifying elements of a range through const iterators.
+  return const_cast<void*>(static_cast<const volatile void*>(_VSTD::addressof(__from)));
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MEMORY_VOIDIFY_H

libcxx/include/memory

 
 template <class InputIterator, class Size, class ForwardIterator>
 ForwardIterator
 uninitialized_copy_n(InputIterator first, Size n, ForwardIterator result);
 
 template <class ForwardIterator, class T>
 void uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& x);
 
+template <nothrow-forward-iterator ForwardIterator, nothrow-sentinel-for<ForwardIterator> Sentinel, class T>
+  requires constructible_from<iter_value_t<ForwardIterator>, const T&>
+ForwardIterator ranges::uninitialized_fill(ForwardIterator first, Sentinel last, const T& x); // since C++20
+
+template <nothrow-forward-range ForwardRange, class T>
+  requires constructible_from<range_value_t<ForwardRange>, const T&>
+borrowed_iterator_t<ForwardRange> ranges::uninitialized_fill(ForwardRange&& range, const T& x); // since C++20
+
 template <class ForwardIterator, class Size, class T>
 ForwardIterator
 uninitialized_fill_n(ForwardIterator first, Size n, const T& x);
 
+template <nothrow-forward-iterator ForwardIterator, class T>
+  requires constructible_from<iter_value_t<ForwardIterator>, const T&>
+ForwardIterator ranges::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
 
 template <class T>
 void destroy_at(T* location); // constexpr in C++20
 
 template <class ForwardIterator>
 void destroy(ForwardIterator first, ForwardIterator last); // constexpr in C++20
 
 template <class ForwardIterator, class Size>
 ForwardIterator destroy_n(ForwardIterator first, Size n); // constexpr in C++20
 
 template <class InputIterator, class ForwardIterator>
  ForwardIterator uninitialized_move(InputIterator first, InputIterator last, ForwardIterator result);
 
 template <class InputIterator, class Size, class ForwardIterator>
  pair<InputIterator,ForwardIterator> uninitialized_move_n(InputIterator first, Size n, ForwardIterator result);
 
 template <class ForwardIterator>
  void uninitialized_value_construct(ForwardIterator first, ForwardIterator last);
 
+template <nothrow-forward-iterator ForwardIterator, nothrow-sentinel-for<ForwardIterator> Sentinel>
+  requires default_initializable<iter_value_t<ForwardIterator>>
+ ForwardIterator ranges::uninitialized_value_construct(ForwardIterator first, Sentinel last); // since C++20
+
+template <nothrow-forward-range ForwardRange>
+  requires default_initializable<range_value_t<ForwardRange>>
+ borrowed_iterator_t<ForwardRange> ranges::uninitialized_value_construct(ForwardRange&& r); // since C++20
+
 template <class ForwardIterator, class Size>
  ForwardIterator uninitialized_value_construct_n(ForwardIterator first, Size n);
 
+template <nothrow-forward-iterator ForwardIterator>
+  requires default_initializable<iter_value_t<ForwardIterator>>
+ ForwardIterator ranges::uninitialized_value_construct_n(ForwardIterator first, iter_difference_t<ForwardIterator> n); // since C++20
+
 template <class ForwardIterator>
  void uninitialized_default_construct(ForwardIterator first, ForwardIterator last);
 
 template <nothrow-forward-iterator ForwardIterator, nothrow-sentinel-for<ForwardIterator> Sentinel>
   requires default_initializable<iter_value_t<ForwardIterator>>
  ForwardIterator ranges::uninitialized_default_construct(ForwardIterator first, Sentinel last); // since C++20
 
 template <nothrow-forward-range ForwardRange>

libcxx/include/module.modulemap

module __memory {
         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" }
       module unique_ptr                      { private header "__memory/unique_ptr.h" }
       module uses_allocator                  { private header "__memory/uses_allocator.h" }
+      module voidify                         { private header "__memory/voidify.h" }
     }
   }
   module mutex {
     header "mutex"
     export *
   }
   module new {
     header "new"

libcxx/test/libcxx/diagnostics/detail.headers/memory/voidify.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/voidify.h'}}
+#include <__memory/voidify.h>

libcxx/test/std/utilities/memory/specialized.algorithms/buffer.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_TEST_STD_UTILITIES_MEMORY_SPECIALIZED_ALGORITHMS_BUFFER_H
+#define LIBCPP_TEST_STD_UTILITIES_MEMORY_SPECIALIZED_ALGORITHMS_BUFFER_H
+
+template <typename T, int N>
+struct Buffer {
+  alignas(T) char buffer[sizeof(T) * N] = {};
+
+  T* begin() { return reinterpret_cast<T*>(buffer); }
+  T* end() { return begin() + N; }
+  const T* cbegin() const { return reinterpret_cast<const T*>(buffer); }
+  const T* cend() const { return cbegin() + N; }
+
+  constexpr int size() const { return N; }
+};
+
+#endif // LIBCPP_TEST_STD_UTILITIES_MEMORY_SPECIALIZED_ALGORITHMS_BUFFER_H

libcxx/test/std/utilities/memory/specialized.algorithms/counted.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_TEST_STD_UTILITIES_MEMORY_SPECIALIZED_ALGORITHMS_COUNTED_H
+#define LIBCPP_TEST_STD_UTILITIES_MEMORY_SPECIALIZED_ALGORITHMS_COUNTED_H
+
+#include "test_macros.h"
+
+struct Counted {
+  static int current_objects;
+  static int total_objects;
+  static int throw_on;
+
+  int value;
+
+  explicit Counted() {
+    check_throw();
+    increase_counters();
+  }
+
+  explicit Counted(int v) : value(v) {
+    check_throw();
+    increase_counters();
+  }
+
+  ~Counted() { --current_objects; }
+
+  static void reset() {
+    current_objects = total_objects = 0;
+    throw_on = -1;
+  }
+
+  Counted(const Counted& rhs) : value(rhs.value) {
+    check_throw();
+    increase_counters();
+  }
+
+  friend void operator&(Counted) = delete;
+
+private:
+  void check_throw() {
+    if (throw_on == total_objects) {
+      TEST_THROW(1);
+    }
+  }
+
+  void increase_counters() {
+    ++current_objects;
+    ++total_objects;
+  }
+};
+int Counted::current_objects = 0;
+int Counted::total_objects = 0;
+int Counted::throw_on = -1;
+
+#endif // LIBCPP_TEST_STD_UTILITIES_MEMORY_SPECIALIZED_ALGORITHMS_COUNTED_H

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/ranges_uninitialized_default_construct.pass.cpp

 // borrowed_iterator_t<ForwardRange> ranges::uninitialized_default_construct(ForwardRange&& range);
 
 #include <cassert>
 #include <iterator>
 #include <memory>
 #include <ranges>
 #include <type_traits>
 
+#include "../buffer.h"
+#include "../counted.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 
-struct Counted {
-  static int current_objects;
-  static int total_objects;
-  static int throw_on;
-
-  explicit Counted() {
-    if (throw_on == total_objects) {
-      TEST_THROW(1);
-    }
-
-    ++current_objects;
-    ++total_objects;
-  }
-
-  ~Counted() { --current_objects; }
-
-  static void reset() {
-    current_objects = total_objects = 0;
-    throw_on = -1;
-  }
-
-  Counted(Counted const&) = delete;
-  friend void operator&(Counted) = delete;
-};
-int Counted::current_objects = 0;
-int Counted::total_objects = 0;
-int Counted::throw_on = -1;
-
-template <typename T, int N>
-struct Buffer {
-  alignas(T) char buffer[sizeof(T) * N] = {};
-
-  T* begin() { return reinterpret_cast<T*>(buffer); }
-  T* end() { return begin() + N; }
-  const T* cbegin() const { return reinterpret_cast<const T*>(buffer); }
-  const T* cend() const { return cbegin() + N; }
-};
-
 // 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::uninitialized_default_construct)>);
 
 struct NotDefaultCtrable { NotDefaultCtrable() = delete; };
 static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_default_construct),
     NotDefaultCtrable*, NotDefaultCtrable*>);
// Using `counted_iterator`.
     Counted::reset();
   }
 
   // Using `views::counted`.
   {
     constexpr int N = 3;
     Buffer<Counted, 5> buf;
 
-    auto counted_range = std::views::counted(buf.begin(), N);
-    std::ranges::uninitialized_default_construct(counted_range);
+    std::ranges::uninitialized_default_construct(std::views::counted(buf.begin(), N));
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
 
     std::destroy(buf.begin(), buf.begin() + N);
     Counted::reset();
   }
 
   // Using `reverse_view`.

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/ranges_uninitialized_default_construct_n.pass.cpp

 //   requires default_initializable<iter_value_t<ForwardIterator>>
 // ForwardIterator ranges::uninitialized_default_construct_n(ForwardIterator first,
 //     iter_difference_t<ForwardIterator> n);
 
 #include <cassert>
 #include <memory>
 #include <ranges>
 
+#include "../buffer.h"
+#include "../counted.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 
-struct Counted {
-  static int current_objects;
-  static int total_objects;
-  static int throw_on;
-
-  explicit Counted() {
-    if (throw_on == total_objects) {
-      TEST_THROW(1);
-    }
-
-    ++current_objects;
-    ++total_objects;
-  }
-
-  ~Counted() { --current_objects; }
-
-  static void reset() {
-    current_objects = total_objects = 0;
-    throw_on = -1;
-  }
-
-  Counted(Counted const&) = delete;
-  friend void operator&(Counted) = delete;
-};
-int Counted::current_objects = 0;
-int Counted::total_objects = 0;
-int Counted::throw_on = -1;
-
-template <typename T, int N>
-struct Buffer {
-  alignas(T) char buffer[sizeof(T) * N] = {};
-
-  T* begin() { return reinterpret_cast<T*>(buffer); }
-  T* end() { return begin() + N; }
-  const T* cbegin() const { return reinterpret_cast<const T*>(buffer); }
-  const T* cend() const { return cbegin() + N; }
-};
-
 // 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::uninitialized_default_construct_n)>);
 
 struct NotDefaultCtrable { NotDefaultCtrable() = delete; };
 static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_default_construct_n),
     NotDefaultCtrable*, int>);

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/ranges_uninitialized_value_construct.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>
 
 // template <nothrow-forward-iterator ForwardIterator, nothrow-sentinel-for<ForwardIterator> Sentinel>
 //   requires default_initializable<iter_value_t<ForwardIterator>>
-// ForwardIterator ranges::uninitialized_default_construct(ForwardIterator first, Sentinel last);
+// ForwardIterator ranges::uninitialized_value_construct(ForwardIterator first, Sentinel last);
 //
 // template <nothrow-forward-range ForwardRange>
 //   requires default_initializable<range_value_t<ForwardRange>>
-// borrowed_iterator_t<ForwardRange> ranges::uninitialized_default_construct(ForwardRange&& range);
+// borrowed_iterator_t<ForwardRange> ranges::uninitialized_value_construct(ForwardRange&& range);
 
 #include <cassert>
 #include <iterator>
 #include <memory>
 #include <ranges>
 #include <type_traits>
 
+#include "../buffer.h"
+#include "../counted.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 
-struct Counted {
-  static int current_objects;
-  static int total_objects;
-  static int throw_on;
-
-  explicit Counted() {
-    if (throw_on == total_objects) {
-      TEST_THROW(1);
-    }
-
-    ++current_objects;
-    ++total_objects;
-  }
-
-  ~Counted() { --current_objects; }
-
-  static void reset() {
-    current_objects = total_objects = 0;
-    throw_on = -1;
-  }
-
-  Counted(Counted const&) = delete;
-  friend void operator&(Counted) = delete;
-};
-int Counted::current_objects = 0;
-int Counted::total_objects = 0;
-int Counted::throw_on = -1;
-
-template <typename T, int N>
-struct Buffer {
-  alignas(T) char buffer[sizeof(T) * N] = {};
-
-  T* begin() { return reinterpret_cast<T*>(buffer); }
-  T* end() { return begin() + N; }
-  const T* cbegin() const { return reinterpret_cast<const T*>(buffer); }
-  const T* cend() const { return cbegin() + N; }
-};
-
 // 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::uninitialized_default_construct)>);
+LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::uninitialized_value_construct)>);
 
-struct NotDefaultCtrable { NotDefaultCtrable() = delete; };
-static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_default_construct),
-    NotDefaultCtrable*, NotDefaultCtrable*>);
+struct NotDefaultCtrable {
+  NotDefaultCtrable() = delete;
+};
+static_assert(
+    !std::is_invocable_v<decltype(std::ranges::uninitialized_value_construct), NotDefaultCtrable*, NotDefaultCtrable*>);
 
 int main(int, char**) {
   // An empty range -- no default constructors should be invoked.
   {
     Buffer<Counted, 1> buf;
 
-    std::ranges::uninitialized_default_construct(buf.begin(), buf.begin());
+    std::ranges::uninitialized_value_construct(buf.begin(), buf.begin());
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 0);
 
-    std::ranges::uninitialized_default_construct(std::ranges::empty_view<Counted>());
+    std::ranges::uninitialized_value_construct(std::ranges::empty_view<Counted>());
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 0);
 
     forward_iterator<Counted*> it(buf.begin());
     auto range = std::ranges::subrange(it, sentinel_wrapper<forward_iterator<Counted*>>(it));
-    std::ranges::uninitialized_default_construct(range.begin(), range.end());
+    std::ranges::uninitialized_value_construct(range.begin(), range.end());
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 0);
 
-    std::ranges::uninitialized_default_construct(range);
+    std::ranges::uninitialized_value_construct(range);
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 0);
   }
 
   // A range containing several objects, (iter, sentinel) overload.
   {
     constexpr int N = 5;
-    Buffer<Counted, 5> buf;
+    Buffer<Counted, N> buf;
 
-    std::ranges::uninitialized_default_construct(buf.begin(), buf.end());
+    std::ranges::uninitialized_value_construct(buf.begin(), buf.end());
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
 
     std::destroy(buf.begin(), buf.end());
     Counted::reset();
   }
 
   // A range containing several objects, (range) overload.
   {
     constexpr int N = 5;
     Buffer<Counted, N> buf;
 
     auto range = std::ranges::subrange(buf.begin(), buf.end());
-    std::ranges::uninitialized_default_construct(range);
+    std::ranges::uninitialized_value_construct(range);
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
 
     std::destroy(buf.begin(), buf.end());
     Counted::reset();
   }
 
   // Using `counted_iterator`.
   {
     constexpr int N = 3;
     Buffer<Counted, 5> buf;
 
-    std::ranges::uninitialized_default_construct(
-        std::counted_iterator(buf.begin(), N), std::default_sentinel);
+    std::ranges::uninitialized_value_construct(std::counted_iterator(buf.begin(), N), std::default_sentinel);
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
 
     std::destroy(buf.begin(), buf.begin() + N);
     Counted::reset();
   }
 
   // Using `views::counted`.
   {
     constexpr int N = 3;
     Buffer<Counted, 5> buf;
 
-    auto counted_range = std::views::counted(buf.begin(), N);
-    std::ranges::uninitialized_default_construct(counted_range);
+    std::ranges::uninitialized_value_construct(std::views::counted(buf.begin(), N));
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
 
     std::destroy(buf.begin(), buf.begin() + N);
     Counted::reset();
   }
 
   // Using `reverse_view`.
   {
     constexpr int N = 3;
     Buffer<Counted, 5> buf;
 
     auto range = std::ranges::subrange(buf.begin(), buf.begin() + N);
-    std::ranges::uninitialized_default_construct(std::ranges::reverse_view(range));
+    std::ranges::uninitialized_value_construct(std::ranges::reverse_view(range));
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
 
     std::destroy(buf.begin(), buf.begin() + N);
     Counted::reset();
   }
 
+  // Any existing values should be overwritten by value constructors.
+  {
+    constexpr int N = 5;
+    int buffer[N] = {42, 42, 42, 42, 42};
+
+    std::ranges::uninitialized_value_construct(buffer, buffer + 1);
+    assert(buffer[0] == 0);
+    assert(buffer[1] == 42);
+
+    std::ranges::uninitialized_value_construct(buffer, buffer + N);
+    assert(buffer[0] == 0);
+    assert(buffer[1] == 0);
+    assert(buffer[2] == 0);
+    assert(buffer[3] == 0);
+    assert(buffer[4] == 0);
+  }
+
   // An exception is thrown while objects are being created -- the existing objects should stay
   // valid. (iterator, sentinel) overload.
 #ifndef TEST_HAS_NO_EXCEPTIONS
   {
     Buffer<Counted, 5> buf;
 
     Counted::throw_on = 3; // When constructing the fourth object (counting from one).
     try {
-      std::ranges::uninitialized_default_construct(buf.begin(), buf.end());
-    } catch(...) {}
+      std::ranges::uninitialized_value_construct(buf.begin(), buf.end());
+    } catch (...) {
+    }
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 3);
     std::destroy(buf.begin(), buf.begin() + Counted::total_objects);
     Counted::reset();
   }
 
   // An exception is thrown while objects are being created -- the existing objects should stay
   // valid. (range) overload.
   {
     Buffer<Counted, 5> buf;
 
     Counted::throw_on = 3; // When constructing the fourth object.
     try {
       auto range = std::ranges::subrange(buf.begin(), buf.end());
-      std::ranges::uninitialized_default_construct(range);
-    } catch(...) {}
+      std::ranges::uninitialized_value_construct(range);
+    } catch (...) {
+    }
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 3);
     std::destroy(buf.begin(), buf.begin() + Counted::total_objects);
     Counted::reset();
   }
-#endif  // TEST_HAS_NO_EXCEPTIONS
+#endif // TEST_HAS_NO_EXCEPTIONS
 
   // Works with const iterators, (iter, sentinel) overload.
   {
     constexpr int N = 5;
     Buffer<Counted, N> buf;
 
-    std::ranges::uninitialized_default_construct(buf.cbegin(), buf.cend());
+    std::ranges::uninitialized_value_construct(buf.cbegin(), buf.cend());
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
     std::destroy(buf.begin(), buf.end());
     Counted::reset();
   }
 
   // Works with const iterators, (range) overload.
   {
     constexpr int N = 5;
     Buffer<Counted, N> buf;
-    auto range = std::ranges::subrange(buf.cbegin(), buf.cend());
 
-    std::ranges::uninitialized_default_construct(range);
+    auto range = std::ranges::subrange(buf.cbegin(), buf.cend());
+    std::ranges::uninitialized_value_construct(range);
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
     std::destroy(buf.begin(), buf.end());
     Counted::reset();
   }
 
   return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/ranges_uninitialized_value_construct_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>
 
 // template <nothrow-forward-iterator ForwardIterator>
 //   requires default_initializable<iter_value_t<ForwardIterator>>
-// ForwardIterator ranges::uninitialized_default_construct_n(ForwardIterator first,
+// ForwardIterator ranges::uninitialized_value_construct_n(ForwardIterator first,
 //     iter_difference_t<ForwardIterator> n);
 
 #include <cassert>
 #include <memory>
 #include <ranges>
 
+#include "../buffer.h"
+#include "../counted.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 
-struct Counted {
-  static int current_objects;
-  static int total_objects;
-  static int throw_on;
-
-  explicit Counted() {
-    if (throw_on == total_objects) {
-      TEST_THROW(1);
-    }
-
-    ++current_objects;
-    ++total_objects;
-  }
-
-  ~Counted() { --current_objects; }
-
-  static void reset() {
-    current_objects = total_objects = 0;
-    throw_on = -1;
-  }
-
-  Counted(Counted const&) = delete;
-  friend void operator&(Counted) = delete;
-};
-int Counted::current_objects = 0;
-int Counted::total_objects = 0;
-int Counted::throw_on = -1;
-
-template <typename T, int N>
-struct Buffer {
-  alignas(T) char buffer[sizeof(T) * N] = {};
-
-  T* begin() { return reinterpret_cast<T*>(buffer); }
-  T* end() { return begin() + N; }
-  const T* cbegin() const { return reinterpret_cast<const T*>(buffer); }
-  const T* cend() const { return cbegin() + N; }
-};
-
 // 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::uninitialized_default_construct_n)>);
+LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::uninitialized_value_construct_n)>);
 
-struct NotDefaultCtrable { NotDefaultCtrable() = delete; };
-static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_default_construct_n),
-    NotDefaultCtrable*, int>);
+struct NotDefaultCtrable {
+  NotDefaultCtrable() = delete;
+};
+static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_value_construct_n), NotDefaultCtrable*, int>);
 
 int main(int, char**) {
   // An empty range -- no default constructors should be invoked.
   {
     Buffer<Counted, 1> buf;
 
-    std::ranges::uninitialized_default_construct_n(buf.begin(), 0);
+    std::ranges::uninitialized_value_construct_n(buf.begin(), 0);
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 0);
   }
 
   // A range containing several objects.
   {
     constexpr int N = 5;
     Buffer<Counted, N> buf;
 
-    std::ranges::uninitialized_default_construct_n(buf.begin(), N);
+    std::ranges::uninitialized_value_construct_n(buf.begin(), N);
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
 
     std::destroy(buf.begin(), buf.end());
     Counted::reset();
   }
 
+  // Any existing values should be overwritten by value constructors.
+  {
+    constexpr int N = 5;
+    int buffer[N] = {42, 42, 42, 42, 42};
+
+    std::ranges::uninitialized_value_construct_n(buffer, 1);
+    assert(buffer[0] == 0);
+    assert(buffer[1] == 42);
+
+    std::ranges::uninitialized_value_construct_n(buffer, N);
+    assert(buffer[0] == 0);
+    assert(buffer[1] == 0);
+    assert(buffer[2] == 0);
+    assert(buffer[3] == 0);
+    assert(buffer[4] == 0);
+  }
+
   // An exception is thrown while objects are being created -- the existing objects should stay
   // valid.
 #ifndef TEST_HAS_NO_EXCEPTIONS
   {
     constexpr int N = 5;
     Buffer<Counted, N> buf;
 
     Counted::throw_on = 3; // When constructing the fourth object (counting from one).
     try {
-      std::ranges::uninitialized_default_construct_n(buf.begin(), N);
-    } catch(...) {}
+      std::ranges::uninitialized_value_construct_n(buf.begin(), N);
+    } catch (...) {
+    }
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 3);
     std::destroy(buf.begin(), buf.begin() + Counted::total_objects);
     Counted::reset();
   }
-#endif  // TEST_HAS_NO_EXCEPTIONS
+#endif // TEST_HAS_NO_EXCEPTIONS
 
   // Works with const iterators.
   {
     constexpr int N = 5;
     Buffer<Counted, N> buf;
 
-    std::ranges::uninitialized_default_construct_n(buf.cbegin(), N);
+    std::ranges::uninitialized_value_construct_n(buf.cbegin(), N);
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
     std::destroy(buf.begin(), buf.end());
     Counted::reset();
   }
 
   return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.fill.n/ranges_uninitialized_fill_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>
 
-// template <nothrow-forward-iterator ForwardIterator>
-//   requires default_initializable<iter_value_t<ForwardIterator>>
-// ForwardIterator ranges::uninitialized_default_construct_n(ForwardIterator first,
-//     iter_difference_t<ForwardIterator> n);
+// template <nothrow-forward-iterator ForwardIterator, class T>
+//   requires constructible_from<iter_value_t<ForwardIterator>, const T&>
+// ForwardIterator ranges::uninitialized_fill_n(ForwardIterator first, iter_difference_t<ForwardIterator> n);
 
+#include <algorithm>
 #include <cassert>
+#include <iterator>
 #include <memory>
 #include <ranges>
+#include <type_traits>
 
+#include "../buffer.h"
+#include "../counted.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 
-struct Counted {
-  static int current_objects;
-  static int total_objects;
-  static int throw_on;
-
-  explicit Counted() {
-    if (throw_on == total_objects) {
-      TEST_THROW(1);
-    }
-
-    ++current_objects;
-    ++total_objects;
-  }
-
-  ~Counted() { --current_objects; }
-
-  static void reset() {
-    current_objects = total_objects = 0;
-    throw_on = -1;
-  }
-
-  Counted(Counted const&) = delete;
-  friend void operator&(Counted) = delete;
-};
-int Counted::current_objects = 0;
-int Counted::total_objects = 0;
-int Counted::throw_on = -1;
-
-template <typename T, int N>
-struct Buffer {
-  alignas(T) char buffer[sizeof(T) * N] = {};
-
-  T* begin() { return reinterpret_cast<T*>(buffer); }
-  T* end() { return begin() + N; }
-  const T* cbegin() const { return reinterpret_cast<const T*>(buffer); }
-  const T* cend() const { return cbegin() + N; }
-};
-
 // 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::uninitialized_default_construct_n)>);
+LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::uninitialized_fill_n)>);
 
-struct NotDefaultCtrable { NotDefaultCtrable() = delete; };
-static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_default_construct_n),
-    NotDefaultCtrable*, int>);
+struct NotConvertibleFromInt {};
+static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_fill_n), NotConvertibleFromInt*,
+                                   NotConvertibleFromInt*, int>);
 
 int main(int, char**) {
+  constexpr int value = 42;
+  Counted x(value);
+  Counted::reset();
+  auto pred = [](const Counted& e) { return e.value == value; };
+
   // An empty range -- no default constructors should be invoked.
   {
     Buffer<Counted, 1> buf;
 
-    std::ranges::uninitialized_default_construct_n(buf.begin(), 0);
+    std::ranges::uninitialized_fill_n(buf.begin(), 0, x);
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 0);
   }
 
   // A range containing several objects.
   {
     constexpr int N = 5;
     Buffer<Counted, N> buf;
 
-    std::ranges::uninitialized_default_construct_n(buf.begin(), N);
+    std::ranges::uninitialized_fill_n(buf.begin(), N, x);
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
+    assert(std::all_of(buf.begin(), buf.end(), pred));
 
     std::destroy(buf.begin(), buf.end());
     Counted::reset();
   }
 
+  // Any existing values should be overwritten by value constructors.
+  {
+    constexpr int N = 5;
+    int buffer[N] = {value, value, value, value, value};
+
+    std::ranges::uninitialized_fill_n(buffer, 1, 0);
+    assert(buffer[0] == 0);
+    assert(buffer[1] == value);
+
+    std::ranges::uninitialized_fill_n(buffer, N, 0);
+    assert(buffer[0] == 0);
+    assert(buffer[1] == 0);
+    assert(buffer[2] == 0);
+    assert(buffer[3] == 0);
+    assert(buffer[4] == 0);
+  }
+
   // An exception is thrown while objects are being created -- the existing objects should stay
-  // valid.
+  // valid. (iterator, sentinel) overload.
 #ifndef TEST_HAS_NO_EXCEPTIONS
   {
     constexpr int N = 5;
     Buffer<Counted, N> buf;
 
-    Counted::throw_on = 3; // When constructing the fourth object (counting from one).
+    Counted::throw_on = 3; // When constructing the fourth object.
     try {
-      std::ranges::uninitialized_default_construct_n(buf.begin(), N);
-    } catch(...) {}
+      std::ranges::uninitialized_fill_n(buf.begin(), N, x);
+    } catch (...) {
+    }
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 3);
-    std::destroy(buf.begin(), buf.begin() + Counted::total_objects);
+
+    std::destroy(buf.begin(), buf.begin() + 3);
     Counted::reset();
   }
-#endif  // TEST_HAS_NO_EXCEPTIONS
+#endif // TEST_HAS_NO_EXCEPTIONS
 
   // Works with const iterators.
   {
     constexpr int N = 5;
     Buffer<Counted, N> buf;
 
-    std::ranges::uninitialized_default_construct_n(buf.cbegin(), N);
+    std::ranges::uninitialized_fill_n(buf.cbegin(), N, x);
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
+    assert(std::all_of(buf.begin(), buf.end(), pred));
+
     std::destroy(buf.begin(), buf.end());
     Counted::reset();
   }
 
   return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.fill/ranges_uninitialized_fill.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>
 
-// template <nothrow-forward-iterator ForwardIterator, nothrow-sentinel-for<ForwardIterator> Sentinel>
-//   requires default_initializable<iter_value_t<ForwardIterator>>
-// ForwardIterator ranges::uninitialized_default_construct(ForwardIterator first, Sentinel last);
+// template <nothrow-forward-iterator ForwardIterator, nothrow-sentinel-for<ForwardIterator> Sentinel, class T>
+//   requires constructible_from<iter_value_t<ForwardIterator>, const T&>
+// ForwardIterator ranges::uninitialized_fill(ForwardIterator first, Sentinel last, const T& x);
 //
-// template <nothrow-forward-range ForwardRange>
-//   requires default_initializable<range_value_t<ForwardRange>>
-// borrowed_iterator_t<ForwardRange> ranges::uninitialized_default_construct(ForwardRange&& range);
+// template <nothrow-forward-range ForwardRange, class T>
+//   requires constructible_from<range_value_t<ForwardRange>, const T&>
+// borrowed_iterator_t<ForwardRange> ranges::uninitialized_fill(ForwardRange&& range, const T& x);
 
+#include <algorithm>
 #include <cassert>
 #include <iterator>
 #include <memory>
 #include <ranges>
 #include <type_traits>
 
+#include "../buffer.h"
+#include "../counted.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 
-struct Counted {
-  static int current_objects;
-  static int total_objects;
-  static int throw_on;
-
-  explicit Counted() {
-    if (throw_on == total_objects) {
-      TEST_THROW(1);
-    }
-
-    ++current_objects;
-    ++total_objects;
-  }
-
-  ~Counted() { --current_objects; }
-
-  static void reset() {
-    current_objects = total_objects = 0;
-    throw_on = -1;
-  }
-
-  Counted(Counted const&) = delete;
-  friend void operator&(Counted) = delete;
-};
-int Counted::current_objects = 0;
-int Counted::total_objects = 0;
-int Counted::throw_on = -1;
-
-template <typename T, int N>
-struct Buffer {
-  alignas(T) char buffer[sizeof(T) * N] = {};
-
-  T* begin() { return reinterpret_cast<T*>(buffer); }
-  T* end() { return begin() + N; }
-  const T* cbegin() const { return reinterpret_cast<const T*>(buffer); }
-  const T* cend() const { return cbegin() + N; }
-};
-
 // 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::uninitialized_default_construct)>);
+LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::uninitialized_fill)>);
 
-struct NotDefaultCtrable { NotDefaultCtrable() = delete; };
-static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_default_construct),
-    NotDefaultCtrable*, NotDefaultCtrable*>);
+struct NotConvertibleFromInt {};
+static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_fill), NotConvertibleFromInt*,
+                                   NotConvertibleFromInt*, int>);
 
 int main(int, char**) {
+  constexpr int value = 42;
+  Counted x(value);
+  Counted::reset();
+  auto pred = [](const Counted& e) { return e.value == value; };
+
   // An empty range -- no default constructors should be invoked.
   {
     Buffer<Counted, 1> buf;
 
-    std::ranges::uninitialized_default_construct(buf.begin(), buf.begin());
+    std::ranges::uninitialized_fill(buf.begin(), buf.begin(), x);
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 0);
 
-    std::ranges::uninitialized_default_construct(std::ranges::empty_view<Counted>());
+    std::ranges::uninitialized_fill(std::ranges::empty_view<Counted>(), x);
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 0);
 
     forward_iterator<Counted*> it(buf.begin());
     auto range = std::ranges::subrange(it, sentinel_wrapper<forward_iterator<Counted*>>(it));
-    std::ranges::uninitialized_default_construct(range.begin(), range.end());
+    std::ranges::uninitialized_fill(range.begin(), range.end(), x);
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 0);
+    Counted::reset();
 
-    std::ranges::uninitialized_default_construct(range);
+    std::ranges::uninitialized_fill(range, x);
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 0);
+    Counted::reset();
   }
 
   // A range containing several objects, (iter, sentinel) overload.
   {
     constexpr int N = 5;
-    Buffer<Counted, 5> buf;
+    Buffer<Counted, N> buf;
 
-    std::ranges::uninitialized_default_construct(buf.begin(), buf.end());
+    std::ranges::uninitialized_fill(buf.begin(), buf.end(), x);
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
+    assert(std::all_of(buf.begin(), buf.end(), pred));
 
     std::destroy(buf.begin(), buf.end());
     Counted::reset();
   }
 
   // A range containing several objects, (range) overload.
   {
     constexpr int N = 5;
     Buffer<Counted, N> buf;
 
     auto range = std::ranges::subrange(buf.begin(), buf.end());
-    std::ranges::uninitialized_default_construct(range);
+    std::ranges::uninitialized_fill(range, x);
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
+    assert(std::all_of(buf.begin(), buf.end(), pred));
 
     std::destroy(buf.begin(), buf.end());
     Counted::reset();
   }
 
   // Using `counted_iterator`.
   {
     constexpr int N = 3;
     Buffer<Counted, 5> buf;
 
-    std::ranges::uninitialized_default_construct(
-        std::counted_iterator(buf.begin(), N), std::default_sentinel);
+    std::ranges::uninitialized_fill(std::counted_iterator(buf.begin(), N), std::default_sentinel, x);
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
+    assert(std::all_of(buf.begin(), buf.begin() + N, pred));
 
     std::destroy(buf.begin(), buf.begin() + N);
     Counted::reset();
   }
 
   // Using `views::counted`.
   {
     constexpr int N = 3;
     Buffer<Counted, 5> buf;
 
-    auto counted_range = std::views::counted(buf.begin(), N);
-    std::ranges::uninitialized_default_construct(counted_range);
+    std::ranges::uninitialized_fill(std::views::counted(buf.begin(), N), x);
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
+    assert(std::all_of(buf.begin(), buf.begin() + N, pred));
 
     std::destroy(buf.begin(), buf.begin() + N);
     Counted::reset();
   }
 
   // Using `reverse_view`.
   {
     constexpr int N = 3;
     Buffer<Counted, 5> buf;
 
     auto range = std::ranges::subrange(buf.begin(), buf.begin() + N);
-    std::ranges::uninitialized_default_construct(std::ranges::reverse_view(range));
+    std::ranges::uninitialized_fill(std::ranges::reverse_view(range), x);
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
+    assert(std::all_of(buf.begin(), buf.begin() + N, pred));
 
     std::destroy(buf.begin(), buf.begin() + N);
     Counted::reset();
   }
 
+  // Any existing values should be overwritten by value constructors.
+  {
+    constexpr int N = 5;
+    int buffer[N] = {value, value, value, value, value};
+
+    std::ranges::uninitialized_fill(buffer, buffer + 1, 0);
+    assert(buffer[0] == 0);
+    assert(buffer[1] == value);
+
+    std::ranges::uninitialized_fill(buffer, buffer + N, 0);
+    assert(buffer[0] == 0);
+    assert(buffer[1] == 0);
+    assert(buffer[2] == 0);
+    assert(buffer[3] == 0);
+    assert(buffer[4] == 0);
+  }
+
   // An exception is thrown while objects are being created -- the existing objects should stay
   // valid. (iterator, sentinel) overload.
 #ifndef TEST_HAS_NO_EXCEPTIONS
   {
+    constexpr int N = 3;
     Buffer<Counted, 5> buf;
 
-    Counted::throw_on = 3; // When constructing the fourth object (counting from one).
+    Counted::throw_on = N; // When constructing the fourth object.
     try {
-      std::ranges::uninitialized_default_construct(buf.begin(), buf.end());
-    } catch(...) {}
+      std::ranges::uninitialized_fill(buf.begin(), buf.end(), x);
+    } catch (...) {
+    }
     assert(Counted::current_objects == 0);
-    assert(Counted::total_objects == 3);
-    std::destroy(buf.begin(), buf.begin() + Counted::total_objects);
+    assert(Counted::total_objects == N);
+
+    std::destroy(buf.begin(), buf.begin() + N);
     Counted::reset();
   }
 
   // An exception is thrown while objects are being created -- the existing objects should stay
   // valid. (range) overload.
   {
+    constexpr int N = 3;
     Buffer<Counted, 5> buf;
 
-    Counted::throw_on = 3; // When constructing the fourth object.
+    Counted::throw_on = N; // When constructing the fourth object.
     try {
       auto range = std::ranges::subrange(buf.begin(), buf.end());
-      std::ranges::uninitialized_default_construct(range);
-    } catch(...) {}
+      std::ranges::uninitialized_fill(range, x);
+    } catch (...) {
+    }
     assert(Counted::current_objects == 0);
-    assert(Counted::total_objects == 3);
-    std::destroy(buf.begin(), buf.begin() + Counted::total_objects);
+    assert(Counted::total_objects == N);
+
+    std::destroy(buf.begin(), buf.begin() + N);
     Counted::reset();
   }
-#endif  // TEST_HAS_NO_EXCEPTIONS
+#endif // TEST_HAS_NO_EXCEPTIONS
 
   // Works with const iterators, (iter, sentinel) overload.
   {
     constexpr int N = 5;
     Buffer<Counted, N> buf;
 
-    std::ranges::uninitialized_default_construct(buf.cbegin(), buf.cend());
+    std::ranges::uninitialized_fill(buf.cbegin(), buf.cend(), x);
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
+    assert(std::all_of(buf.begin(), buf.end(), pred));
+
     std::destroy(buf.begin(), buf.end());
     Counted::reset();
   }
 
   // Works with const iterators, (range) overload.
   {
     constexpr int N = 5;
     Buffer<Counted, N> buf;
-    auto range = std::ranges::subrange(buf.cbegin(), buf.cend());
 
-    std::ranges::uninitialized_default_construct(range);
+    auto range = std::ranges::subrange(buf.cbegin(), buf.cend());
+    std::ranges::uninitialized_fill(range, x);
     assert(Counted::current_objects == N);
     assert(Counted::total_objects == N);
+    assert(std::all_of(buf.begin(), buf.end(), pred));
+
     std::destroy(buf.begin(), buf.end());
     Counted::reset();
   }
 
   return 0;
 }