[libc++][NFC] Rename multidimentional uninitialized algorithms

[Mordante]

Can you put NFC in the title?
LGTM!

libcxx/include/__memory/uninitialized_algorithms.h

407

I'm not entirely sold on the name multidimensional, maybe recursive would be a better name. WDYT?
(I did notice __allocator_destroy_multidimensional already exists.)

[philnik]

libcxx/include/__memory/uninitialized_algorithms.h

407

I think multidimensional makes it more clear that it's about dimensions, not that is calls itself recursively for constructing the types in a single dimension or something similar. I'm open to other ideas though, I mostly copied the name from __allocator_destroy_multidimensional.

[Mordante]

libcxx/include/__memory/uninitialized_algorithms.h

407

Also a fair point, I don't have a great name. When we can come up with something better we can change it later.
I still see this as an improvement since the naming is more consistent.

libcxx/include/__memory/shared_ptr.h

 {
     _LIBCPP_HIDE_FROM_ABI constexpr
     _Tp* __get_data() noexcept { return __data_; }
 
     _LIBCPP_HIDE_FROM_ABI
     explicit __unbounded_array_control_block(_Alloc const& __alloc, size_t __count, _Tp const& __arg)
         : __alloc_(__alloc), __count_(__count)
     {
-        std::__uninitialized_allocator_fill_n(__alloc_, std::begin(__data_), __count_, __arg);
+        std::__uninitialized_allocator_fill_n_multidimensional(__alloc_, std::begin(__data_), __count_, __arg);
     }
 
     _LIBCPP_HIDE_FROM_ABI
     explicit __unbounded_array_control_block(_Alloc const& __alloc, size_t __count)
         : __alloc_(__alloc), __count_(__count)
     {
-        std::__uninitialized_allocator_value_construct_n(__alloc_, std::begin(__data_), __count_);
+        std::__uninitialized_allocator_value_construct_n_multidimensional(__alloc_, std::begin(__data_), __count_);
     }
 
 #if _LIBCPP_STD_VER >= 20
     _LIBCPP_HIDE_FROM_ABI
     explicit __unbounded_array_control_block(_Alloc const& __alloc, size_t __count, __default_initialize_tag)
         : __alloc_(__alloc), __count_(__count)
     {
         // We are purposefully not using an allocator-aware default construction because the spec says so.

 struct __bounded_array_control_block<_Tp[_Count], _Alloc>
     : __shared_weak_count
 {
     _LIBCPP_HIDE_FROM_ABI constexpr
     _Tp* __get_data() noexcept { return __data_; }
 
     _LIBCPP_HIDE_FROM_ABI
     explicit __bounded_array_control_block(_Alloc const& __alloc, _Tp const& __arg) : __alloc_(__alloc) {
-        std::__uninitialized_allocator_fill_n(__alloc_, std::addressof(__data_[0]), _Count, __arg);
+        std::__uninitialized_allocator_fill_n_multidimensional(__alloc_, std::addressof(__data_[0]), _Count, __arg);
     }
 
     _LIBCPP_HIDE_FROM_ABI
     explicit __bounded_array_control_block(_Alloc const& __alloc) : __alloc_(__alloc) {
-        std::__uninitialized_allocator_value_construct_n(__alloc_, std::addressof(__data_[0]), _Count);
+        std::__uninitialized_allocator_value_construct_n_multidimensional(__alloc_, std::addressof(__data_[0]), _Count);
     }
 
 #if _LIBCPP_STD_VER >= 20
     _LIBCPP_HIDE_FROM_ABI
     explicit __bounded_array_control_block(_Alloc const& __alloc, __default_initialize_tag) : __alloc_(__alloc) {
         // We are purposefully not using an allocator-aware default construction because the spec says so.
         // There's currently no way of expressing default initialization in an allocator-aware manner anyway.
         std::uninitialized_default_construct_n(std::addressof(__data_[0]), _Count);

libcxx/include/__memory/uninitialized_algorithms.h

if constexpr (is_array_v<_ValueType>) {
             allocator_traits<_Alloc>::destroy(__alloc, std::addressof(*__last));
         } while (__last != __first);
     }
 }
 
 // Constructs the object at the given location using the allocator's construct method.
 //
 // If the object being constructed is an array, each element of the array is allocator-constructed,
 // recursively. If an exception is thrown during the construction of an array, the initialized
 // elements are destroyed in reverse order of initialization using allocator destruction.
 //
 // This function assumes that the allocator is bound to the correct type.
 template<class _Alloc, class _Tp>
 _LIBCPP_HIDE_FROM_ABI
-constexpr void __allocator_construct_at(_Alloc& __alloc, _Tp* __loc) {
+constexpr void __allocator_construct_at_multidimensional(_Alloc& __alloc, _Tp* __loc) {
     static_assert(is_same_v<typename allocator_traits<_Alloc>::value_type, _Tp>,
         "The allocator should already be rebound to the correct type");
 
     if constexpr (is_array_v<_Tp>) {
         using _Element = remove_extent_t<_Tp>;
         __allocator_traits_rebind_t<_Alloc, _Element> __elem_alloc(__alloc);
         size_t __i = 0;
         _Tp& __array = *__loc;
 
         // If an exception is thrown, destroy what we have constructed so far in reverse order.
         __exception_guard __guard([&]() {
           std::__allocator_destroy_multidimensional(__elem_alloc, __array, __array + __i);
         });
 
         for (; __i != extent_v<_Tp>; ++__i) {
-            std::__allocator_construct_at(__elem_alloc, std::addressof(__array[__i]));
+            std::__allocator_construct_at_multidimensional(__elem_alloc, std::addressof(__array[__i]));
         }
         __guard.__complete();
     } else {
         allocator_traits<_Alloc>::construct(__alloc, __loc);
     }
 }
 
 // Constructs the object at the given location using the allocator's construct method, passing along
 // the provided argument.
 //
 // If the object being constructed is an array, the argument is also assumed to be an array. Each
 // each element of the array being constructed is allocator-constructed from the corresponding
 // element of the argument array. If an exception is thrown during the construction of an array,
 // the initialized elements are destroyed in reverse order of initialization using allocator
 // destruction.
 //
 // This function assumes that the allocator is bound to the correct type.
 template<class _Alloc, class _Tp, class _Arg>
 _LIBCPP_HIDE_FROM_ABI
-constexpr void __allocator_construct_at(_Alloc& __alloc, _Tp* __loc, _Arg const& __arg) {
+constexpr void __allocator_construct_at_multidimensional(_Alloc& __alloc, _Tp* __loc, _Arg const& __arg) {
     static_assert(is_same_v<typename allocator_traits<_Alloc>::value_type, _Tp>,
         "The allocator should already be rebound to the correct type");
 
     if constexpr (is_array_v<_Tp>) {
         static_assert(is_array_v<_Arg>,
-            "Provided non-array initialization argument to __allocator_construct_at when "
+            "Provided non-array initialization argument to __allocator_construct_at_multidimensional when "
             "trying to construct an array.");
 
         using _Element = remove_extent_t<_Tp>;
         __allocator_traits_rebind_t<_Alloc, _Element> __elem_alloc(__alloc);
         size_t __i = 0;
         _Tp& __array = *__loc;
 
         // If an exception is thrown, destroy what we have constructed so far in reverse order.
         __exception_guard __guard([&]() {
           std::__allocator_destroy_multidimensional(__elem_alloc, __array, __array + __i);
         });
         for (; __i != extent_v<_Tp>; ++__i) {
-            std::__allocator_construct_at(__elem_alloc, std::addressof(__array[__i]), __arg[__i]);
+            std::__allocator_construct_at_multidimensional(__elem_alloc, std::addressof(__array[__i]), __arg[__i]);
         }
         __guard.__complete();
     } else {
         allocator_traits<_Alloc>::construct(__alloc, __loc, __arg);
     }
 }
 
 // Given a range starting at it and containing n elements, initializes each element in the
 // range from left to right using the construct method of the allocator (rebound to the
 // correct type).
 //
 // If an exception is thrown, the initialized elements are destroyed in reverse order of
 // initialization using allocator_traits destruction. If the elements in the range are C-style
 // arrays, they are initialized element-wise using allocator construction, and recursively so.
 template<class _Alloc, class _BidirIter, class _Tp, class _Size = typename iterator_traits<_BidirIter>::difference_type>
-_LIBCPP_HIDE_FROM_ABI
-constexpr void __uninitialized_allocator_fill_n(_Alloc& __alloc, _BidirIter __it, _Size __n, _Tp const& __value) {
+_LIBCPP_HIDE_FROM_ABI constexpr void
+__uninitialized_allocator_fill_n_multidimensional(_Alloc& __alloc, _BidirIter __it, _Size __n, _Tp const& __value) {
     using _ValueType = typename iterator_traits<_BidirIter>::value_type;
     __allocator_traits_rebind_t<_Alloc, _ValueType> __value_alloc(__alloc);
     _BidirIter __begin = __it;
 
     // If an exception is thrown, destroy what we have constructed so far in reverse order.
     __exception_guard __guard([&]() { std::__allocator_destroy_multidimensional(__value_alloc, __begin, __it); });
     for (; __n != 0; --__n, ++__it) {
-        std::__allocator_construct_at(__value_alloc, std::addressof(*__it), __value);
+        std::__allocator_construct_at_multidimensional(__value_alloc, std::addressof(*__it), __value);
     }
     __guard.__complete();
 }
 
-// Same as __uninitialized_allocator_fill_n, but doesn't pass any initialization argument
+// Same as __uninitialized_allocator_fill_n_multidimensional, but doesn't pass any initialization argument
 // to the allocator's construct method, which results in value initialization.
-template<class _Alloc, class _BidirIter, class _Size = typename iterator_traits<_BidirIter>::difference_type>
-_LIBCPP_HIDE_FROM_ABI
-constexpr void __uninitialized_allocator_value_construct_n(_Alloc& __alloc, _BidirIter __it, _Size __n) {
+template <class _Alloc, class _BidirIter, class _Size = typename iterator_traits<_BidirIter>::difference_type>
+_LIBCPP_HIDE_FROM_ABI constexpr void
+__uninitialized_allocator_value_construct_n_multidimensional(_Alloc& __alloc, _BidirIter __it, _Size __n) {
     using _ValueType = typename iterator_traits<_BidirIter>::value_type;
     __allocator_traits_rebind_t<_Alloc, _ValueType> __value_alloc(__alloc);
     _BidirIter __begin = __it;
 
     // If an exception is thrown, destroy what we have constructed so far in reverse order.
     __exception_guard __guard([&]() { std::__allocator_destroy_multidimensional(__value_alloc, __begin, __it); });
     for (; __n != 0; --__n, ++__it) {
-        std::__allocator_construct_at(__value_alloc, std::addressof(*__it));
+        std::__allocator_construct_at_multidimensional(__value_alloc, std::addressof(*__it));
     }
     __guard.__complete();
 }
 
 #endif // _LIBCPP_STD_VER > 14
 
 // Destroy all elements in [__first, __last) from left to right using allocator destruction.
 template <class _Alloc, class _Iter, class _Sent>