[libcxx][NFC] replaces `<algorithm>` includes with specific headers

[cjdb]

Summary

Depends on D104982.

[cjdb]

rebases to cancel and reactivate CI

[cjdb]

rebases to activate CI

[cjdb]

rebases to reactivate CI

[cjdb]

rebases to activate CI

[cjdb]

fixes a C++03 only failure

[cjdb]

fixes inclusion issues that weren't being replicated locally

The libc++abi test diff is literally + #include <algorithm>\n, but Arcanist said the following and forced it to be treated as a binary:

Diff for 'libcxxabi/test/test_demangle.pass.cpp' with context is
5,403,317 bytes in length. Generally, source changes should not be this
large. If the file is not a text file, you can mark it 'binary'. Mark
this file as 'binary' and continue?

[ldionne]

LGTM but I'd like to understand the modulemap changes.

libcxx/include/module.modulemap

235

Why do those export unwrap_iter?

[cjdb]

libcxx/include/module.modulemap

235

Something to do with Clang modules not exporting them properly, which leads to linker errors regarding __rewrap_iter. I don't have a good answer.

[cjdb]

rebases to activate CI

[cjdb]

rebases to activate CI

[cjdb]

rebases onto main

[cjdb]

Blocked by D104980.

libcxx/include/__bit_reference

 // -*- 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___BIT_REFERENCE
 #define _LIBCPP___BIT_REFERENCE
 
+#include <__algorithm/min.h>
+#include <__iterator/iterator_traits.h>
+#include <__memory/pointer_traits.h>
 #include <__config>
 #include <__bits>
-#include <algorithm>
+#include <cstring>
+#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__hash_table

 // -*- 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__HASH_TABLE
 #define _LIBCPP__HASH_TABLE
 
+#include <__algorithm/min.h>
+#include <__algorithm/max.h>
 #include <__bits> // __libcpp_clz
 #include <__config>
 #include <__debug>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/swap.h>
-#include <algorithm>
 #include <cmath>
 #include <initializer_list>
 #include <iterator>
 #include <memory>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

libcxx/include/__split_buffer

 // -*- C++ -*-
 #ifndef _LIBCPP_SPLIT_BUFFER
 #define _LIBCPP_SPLIT_BUFFER
 
+#include <__algorithm/max.h>
+#include <__algorithm/move.h>
+#include <__algorithm/move_backward.h>
 #include <__config>
+#include <__memory/allocator_traits.h>
+#include <__memory/compressed_pair.h>
 #include <__utility/move.h>
 #include <__utility/forward.h>
 #include <__utility/swap.h>
-#include <algorithm>
+#include <iterator> // distance
+#include <memory> // __swap_allocator
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/__tree

 // -*- 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___TREE
 #define _LIBCPP___TREE
 
+#include <__algorithm/min.h>
 #include <__config>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/swap.h>
-#include <algorithm>
 #include <iterator>
 #include <limits>
 #include <memory>
 #include <stdexcept>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif

libcxx/include/array

 template <size_t I, class T, size_t N> const T& get(const array<T, N>&) noexcept;   // constexpr in C++14
 template <size_t I, class T, size_t N> T&& get(array<T, N>&&) noexcept;             // constexpr in C++14
 template <size_t I, class T, size_t N> const T&& get(const array<T, N>&&) noexcept; // constexpr in C++14
 
 }  // std
 
 */
 
+#include <__algorithm/equal.h>
+#include <__algorithm/fill_n.h>
+#include <__algorithm/lexicographical_compare.h>
+#include <__algorithm/swap_ranges.h>
 #include <__config>
 #include <__debug>
 #include <__tuple>
 #include <__utility/integer_sequence.h>
 #include <__utility/move.h>
-#include <algorithm>
 #include <cstdlib> // for _LIBCPP_UNREACHABLE
 #include <iterator>
 #include <stdexcept>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

libcxx/include/bitset

 operator<<(basic_ostream<charT, traits>& os, const bitset<N>& x);
 
 template <size_t N> struct hash<std::bitset<N>>;
 
 }  // std
 
 */
 
+#include <__algorithm/fill.h>
 #include <__config>
 #include <__bit_reference>
+#include <__functional/unary_function.h>
 #include <climits>
 #include <cstddef>
 #include <iosfwd>
 #include <stdexcept>
 #include <string>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

libcxx/include/deque

 template <class T, class Allocator, class Predicate>
     typename deque<T, Allocator>::size_type
     erase_if(deque<T, Allocator>& c, Predicate pred);    // C++20
 
 }  // std
 
 */
 
+#include <__algorithm/copy.h>
+#include <__algorithm/copy_backward.h>
+#include <__algorithm/equal.h>
+#include <__algorithm/fill_n.h>
+#include <__algorithm/lexicographical_compare.h>
+#include <__algorithm/min.h>
+#include <__algorithm/remove.h>
+#include <__algorithm/remove_if.h>
 #include <__config>
 #include <__debug>
 #include <__split_buffer>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
-#include <algorithm>
 #include <compare>
 #include <initializer_list>
 #include <iterator>
 #include <limits>
 #include <stdexcept>
 #include <type_traits>
 #include <version>
 

libcxx/include/ext/hash_map

template <class Key, class T, class Hash, class Pred, class Alloc>
     bool
     operator!=(const hash_multimap<Key, T, Hash, Pred, Alloc>& x,
                const hash_multimap<Key, T, Hash, Pred, Alloc>& y);
 
 }  // __gnu_cxx
 
 */
 
+#include <__algorithm/is_permutation.h>
 #include <__config>
 #include <__functional/equal_to.h>
 #include <__hash_table>
 #include <__utility/pair.h>
 #include <stdexcept>
 #include <type_traits>
 #include <ext/__hash>
 

libcxx/include/ext/hash_set

 template <class Value, class Hash, class Pred, class Alloc>
     bool
     operator!=(const hash_multiset<Value, Hash, Pred, Alloc>& x,
                const hash_multiset<Value, Hash, Pred, Alloc>& y);
 }  // __gnu_cxx
 
 */
 
+#include <__algorithm/is_permutation.h>
 #include <__config>
 #include <__functional/equal_to.h>
 #include <__hash_table>
 #include <__utility/pair.h>
 #include <ext/__hash>
 
 #if defined(__DEPRECATED) && __DEPRECATED
 #if defined(_LIBCPP_WARNING)

libcxx/include/forward_list

 template <class T, class Allocator, class Predicate>
     typename forward_list<T, Allocator>::size_type
     erase_if(forward_list<T, Allocator>& c, Predicate pred);    // C++20
 
 }  // std
 
 */
 
+#include <__algorithm/comp.h>
+#include <__algorithm/lexicographical_compare.h>
+#include <__algorithm/min.h>
 #include <__config>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
-#include <algorithm>
 #include <initializer_list>
 #include <iterator>
 #include <limits>
 #include <memory>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

libcxx/include/list

 template <class T, class Allocator, class Predicate>
     typename list<T, Allocator>::size_type
     erase_if(list<T, Allocator>& c, Predicate pred);    // C++20
 
 }  // std
 
 */
 
+#include <__algorithm/equal.h>
+#include <__algorithm/comp.h>
+#include <__algorithm/lexicographical_compare.h>
+#include <__algorithm/min.h>
 #include <__config>
 #include <__debug>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
-#include <algorithm>
 #include <initializer_list>
 #include <iterator>
 #include <limits>
 #include <memory>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/locale

 class messages_base;
 template <class charT> class messages;
 template <class charT> class messages_byname;
 
 }  // std
 
 */
 
+#include <__algorithm/equal.h>
+#include <__algorithm/find.h>
+#include <__algorithm/reverse.h>
 #include <__config>
 #include <__debug>
 #include <__locale>
 #include <__utility/move.h>
-#include <algorithm>
 #ifndef __APPLE__
 # include <cstdarg>
 #endif
 #include <cstdio>
 #include <cstdlib>
 #include <ctime>
 #include <ios>
 #include <iterator>
#endif
     {
         if (__g_end-__g < __num_get_buf_sz)
         {
             *__g_end++ = __dc;
             __dc = 0;
         }
         return 0;
     }
-    ptrdiff_t __f = find(__atoms, __atoms + 26, __ct) - __atoms;
+    ptrdiff_t __f = _VSTD::find(__atoms, __atoms + 26, __ct) - __atoms;
     if (__f >= 24)
         return -1;
     switch (__base)
     {
     case 8:
     case 10:
         if (__f >= __base)
             return -1;
if (__ct == __thousands_sep && __grouping.size() != 0)
             return -1;
         if (__g_end-__g < __num_get_buf_sz)
         {
             *__g_end++ = __dc;
             __dc = 0;
         }
         return 0;
     }
-    ptrdiff_t __f = find(__atoms, __atoms + 32, __ct) - __atoms;
+    ptrdiff_t __f = _VSTD::find(__atoms, __atoms + 32, __ct) - __atoms;
     if (__f >= 32)
         return -1;
     char __x = __src[__f];
     if (__x == '-' || __x == '+')
     {
         if (__a_end == __a || (__a_end[-1] & 0x5F) == (__exp & 0x7F))
         {
             *__a_end++ = __x;
else
         if (*__nf == '-' || *__nf == '+')
             *__oe++ = __ct.widen(*__nf++);
         if (__ne - __nf >= 2 && __nf[0] == '0' && (__nf[1] == 'x' ||
                                                    __nf[1] == 'X'))
         {
             *__oe++ = __ct.widen(*__nf++);
             *__oe++ = __ct.widen(*__nf++);
         }
-        reverse(__nf, __ne);
+        _VSTD::reverse(__nf, __ne);
         _CharT __thousands_sep = __npt.thousands_sep();
         unsigned __dc = 0;
         unsigned __dg = 0;
         for (char* __p = __nf; __p < __ne; ++__p)
         {
             if (static_cast<unsigned>(__grouping[__dg]) > 0 &&
                 __dc == static_cast<unsigned>(__grouping[__dg]))
             {
                 *__oe++ = __thousands_sep;
                 __dc = 0;
                 if (__dg < __grouping.size()-1)
                     ++__dg;
             }
             *__oe++ = __ct.widen(*__p);
             ++__dc;
         }
-        reverse(__ob + (__nf - __nb), __oe);
+        _VSTD::reverse(__ob + (__nf - __nb), __oe);
     }
     if (__np == __ne)
         __op = __oe;
     else
         __op = __ob + (__np - __nb);
 }
 
 template <class _CharT>
__num_put<_CharT>::__widen_and_group_float(char* __nb, char* __np, char* __ne,
     }
     if (__grouping.empty())
     {
         __ct.widen(__nf, __ns, __oe);
         __oe += __ns - __nf;
     }
     else
     {
-        reverse(__nf, __ns);
+        _VSTD::reverse(__nf, __ns);
         _CharT __thousands_sep = __npt.thousands_sep();
         unsigned __dc = 0;
         unsigned __dg = 0;
         for (char* __p = __nf; __p < __ns; ++__p)
         {
             if (__grouping[__dg] > 0 && __dc == static_cast<unsigned>(__grouping[__dg]))
             {
                 *__oe++ = __thousands_sep;
                 __dc = 0;
                 if (__dg < __grouping.size()-1)
                     ++__dg;
             }
             *__oe++ = __ct.widen(*__p);
             ++__dc;
         }
-        reverse(__ob + (__nf - __nb), __oe);
+        _VSTD::reverse(__ob + (__nf - __nb), __oe);
     }
     for (__nf = __ns; __nf < __ne; ++__nf)
     {
         if (*__nf == '.')
         {
             *__oe++ = __npt.decimal_point();
             ++__nf;
             break;
for (unsigned __p = 0; __p < 4 && __b != __e; ++__p)
                                 __pat.field[__p - 1] == money_base::space)) {
                     // Match spaces we've already read against spaces at
                     // the beginning of __sym.
                     while (__sym_space_end != __sym.end() &&
                            __ct.is(ctype_base::space, *__sym_space_end))
                         ++__sym_space_end;
                     const size_t __num_spaces = __sym_space_end - __sym.begin();
                     if (__num_spaces > __spaces.size() ||
-                        !equal(__spaces.end() - __num_spaces, __spaces.end(),
+                        !_VSTD::equal(__spaces.end() - __num_spaces, __spaces.end(),
                                       __sym.begin())) {
                         // No match. Put __sym_space_end back at the
                         // beginning of __sym, which will prevent a
                         // match in the next loop.
                         __sym_space_end = __sym.begin();
                     }
                 }
                 typename string_type::const_iterator __sym_curr_char = __sym_space_end;
                 while (__sym_curr_char != __sym.end() && __b != __e &&
if (__do_get(__b, __e, __intl, __loc, __iob.flags(), __err, __neg, __ct,
             __h.reset((char*)malloc(static_cast<size_t>(__wn - __wb.get() + 2)));
             if (__h.get() == nullptr)
                 __throw_bad_alloc();
             __nc = __h.get();
         }
         if (__neg)
             *__nc++ = '-';
         for (const char_type* __w = __wb.get(); __w < __wn; ++__w, ++__nc)
-            *__nc = __src[find(__atoms, _VSTD::end(__atoms), *__w) - __atoms];
+            *__nc = __src[_VSTD::find(__atoms, _VSTD::end(__atoms), *__w) - __atoms];
         *__nc = char();
         if (sscanf(__nbuf, "%Lf", &__v) != 1)
             __throw_runtime_error("money_get error");
     }
     if (__b == __e)
         __err |= ios_base::eofbit;
     return __b;
 }
for (unsigned __p = 0; __p < 4; ++__p)
                                         numeric_limits<unsigned>::max() :
                                         static_cast<unsigned>(__grp[__ig]);
                     }
                     *__me++ = *--__d;
                     ++__ng;
                 }
             }
             // reverse it
-            reverse(__t, __me);
+            _VSTD::reverse(__t, __me);
             }
             break;
         }
     }
     // print rest of sign, if any
     if (__sn.size() > 1)
         __me = _VSTD::copy(__sn.begin()+1, __sn.end(), __me);
     // set alignment
else if (__cm_ & ios_base::in)
             int __width = __cv_->encoding();
             __c = __extbufend_ - __extbufnext_;
             if (__width > 0)
                 __c += __width * (this->egptr() - this->gptr());
             else
             {
                 if (this->gptr() != this->egptr())
                 {
-                    reverse(this->gptr(), this->egptr());
+                    _VSTD::reverse(this->gptr(), this->egptr());
                     codecvt_base::result __r;
                     const char_type* __e = this->gptr();
                     char* __extbe;
                     do
                     {
                         __r = __cv_->out(__st_, __e, this->egptr(), __e,
                                          __extbuf_, __extbuf_ + __ebs_, __extbe);
                         switch (__r)

libcxx/include/map

 template <class Key, class T, class Compare, class Allocator, class Predicate>
 typename multimap<Key, T, Compare, Allocator>::size_type
 erase_if(multimap<Key, T, Compare, Allocator>& c, Predicate pred);  // C++20
 
 }  // std
 
 */
 
+#include <__algorithm/equal.h>
+#include <__algorithm/lexicographical_compare.h>
 #include <__config>
 #include <__debug>
 #include <__functional/__is_transparent.h>
 #include <__functional/binary_function.h>
 #include <__functional/less.h>
 #include <__node_handle>
 #include <__tree>
 #include <__utility/forward.h>

libcxx/include/module.modulemap

module algorithm {
     module __algorithm {
       module adjacent_find            { header "__algorithm/adjacent_find.h" }
       module all_of                   { header "__algorithm/all_of.h" }
       module any_of                   { header "__algorithm/any_of.h" }
       module binary_search            { header "__algorithm/binary_search.h" }
       module clamp                    { header "__algorithm/clamp.h" }
       module comp                     { header "__algorithm/comp.h" }
       module comp_ref_type            { header "__algorithm/comp_ref_type.h" }
-      module copy                     { header "__algorithm/copy.h" }
-      module copy_backward            { header "__algorithm/copy_backward.h" }
+      module copy                     {
+        header "__algorithm/copy.h"
+        export unwrap_iter
+      }
+      module copy_backward            {
+        header "__algorithm/copy_backward.h"
+        export unwrap_iter
+      }
       module copy_if                  { header "__algorithm/copy_if.h" }
       module copy_n                   { header "__algorithm/copy_n.h" }
       module count                    { header "__algorithm/count.h" }
       module count_if                 { header "__algorithm/count_if.h" }
       module equal                    { header "__algorithm/equal.h" }
       module equal_range              { header "__algorithm/equal_range.h" }
       module fill_n                   { header "__algorithm/fill_n.h" }
       module fill                     { header "__algorithm/fill.h" }
module __algorithm {
       module max                      { header "__algorithm/max.h" }
       module max_element              { header "__algorithm/max_element.h" }
       module merge                    { header "__algorithm/merge.h" }
       module min                      { header "__algorithm/min.h" }
       module min_element              { header "__algorithm/min_element.h" }
       module minmax                   { header "__algorithm/minmax.h" }
       module minmax_element           { header "__algorithm/minmax_element.h" }
       module mismatch                 { header "__algorithm/mismatch.h" }
-      module move                     { header "__algorithm/move.h" }
-      module move_backward            { header "__algorithm/move_backward.h" }
+      module move                     {
+        header "__algorithm/move.h"
+        export unwrap_iter
+      }
+      module move_backward            {
+        header "__algorithm/move_backward.h"
+        export unwrap_iter
+      }
       module next_permutation         { header "__algorithm/next_permutation.h" }
       module none_of                  { header "__algorithm/none_of.h" }
       module nth_element              { header "__algorithm/nth_element.h" }
       module partial_sort             { header "__algorithm/partial_sort.h" }
       module partial_sort_copy        { header "__algorithm/partial_sort_copy.h" }
       module partition                { header "__algorithm/partition.h" }
       module partition_copy           { header "__algorithm/partition_copy.h" }
       module partition_point          { header "__algorithm/partition_point.h" }

libcxx/include/queue

template <class T, class Container, class Compare>
   void swap(priority_queue<T, Container, Compare>& x,
             priority_queue<T, Container, Compare>& y)
             noexcept(noexcept(x.swap(y)));
 
 }  // std
 
 */
 
+#include <__algorithm/make_heap.h>
+#include <__algorithm/pop_heap.h>
+#include <__algorithm/push_heap.h>
 #include <__config>
 #include <__functional/binary_function.h>
 #include <__functional/less.h>
 #include <__memory/uses_allocator.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
-#include <algorithm>
 #include <compare>
 #include <deque>
 #include <vector>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 

libcxx/include/random

class piecewise_linear_distribution
     basic_istream<charT, traits>&
     operator>>(basic_istream<charT, traits>& is,
                piecewise_linear_distribution& x);
 };
 
 } // std
 */
 
+#include <__algorithm/equal.h>
+#include <__algorithm/fill.h>
+#include <__algorithm/upper_bound.h>
 #include <__config>
 #include <__random/uniform_int_distribution.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
-#include <algorithm>
 #include <cmath>
 #include <concepts>
 #include <cstddef>
 #include <cstdint>
 #include <initializer_list>
 #include <iosfwd>
 #include <limits>
 #include <numeric>

libcxx/include/regex

 typedef regex_token_iterator<const char*>             cregex_token_iterator;
 typedef regex_token_iterator<const wchar_t*>          wcregex_token_iterator;
 typedef regex_token_iterator<string::const_iterator>  sregex_token_iterator;
 typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
 
 } // std
 */
 
+#include <__algorithm/move.h>
+#include <__algorithm/find.h>
+#include <__algorithm/search.h>
 #include <__config>
 #include <__debug>
 #include <__functional/search.h>
 #include <__locale>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/swap.h>
 #include <compare>

libcxx/include/set

 template <class Key, class Compare, class Allocator, class Predicate>
 typename multiset<Key, Compare, Allocator>::size_type
 erase_if(multiset<Key, Compare, Allocator>& c, Predicate pred);  // C++20
 
 }  // std
 
 */
 
+#include <__algorithm/equal.h>
+#include <__algorithm/lexicographical_compare.h>
 #include <__config>
 #include <__debug>
 #include <__functional/__is_transparent.h>
 #include <__functional/less.h>
 #include <__node_handle>
 #include <__tree>
 #include <__utility/forward.h>
 #include <__utility/move.h>

libcxx/include/string

 basic_string<char8_t>  operator "" s( const char8_t *str,  size_t len ); // C++20
 basic_string<char16_t> operator "" s( const char16_t *str, size_t len ); // C++14
 basic_string<char32_t> operator "" s( const char32_t *str, size_t len ); // C++14
 
 }  // std
 
 */
 
+#include <__algorithm/min.h>
+#include <__algorithm/max.h>
+#include <__algorithm/remove.h>
+#include <__algorithm/remove_if.h>
 #include <__config>
 #include <__debug>
 #include <__utility/move.h>
-#include <algorithm>
 #include <compare>
 #include <cstdio>  // EOF
 #include <cstring>
 #include <cwchar>
 #include <initializer_list>
 #include <iosfwd>
 #include <iterator>
 #include <memory>

libcxx/include/string_view

namespace std {
   constexpr basic_string_view<char16_t> operator "" sv( const char16_t *str, size_t len ) noexcept;
   constexpr basic_string_view<char32_t> operator "" sv( const char32_t *str, size_t len ) noexcept;
 
 }  // namespace std
 
 
 */
 
+#include <__algorithm/min.h>
 #include <__config>
 #include <__debug>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__string>
-#include <algorithm>
 #include <compare>
 #include <iosfwd>
 #include <iterator>
 #include <limits>
 #include <stdexcept>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/unordered_map

template <class Key, class T, class Hash, class Pred, class Alloc>
     bool
     operator!=(const unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
                const unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
 
 }  // std
 
 */
 
+#include <__algorithm/is_permutation.h>
 #include <__config>
 #include <__debug>
 #include <__functional/__is_transparent.h>
 #include <__functional/equal_to.h>
 #include <__hash_table>
 #include <__node_handle>
 #include <__utility/forward.h>
 #include <__utility/move.h>

libcxx/include/unordered_set

 template <class Value, class Hash, class Pred, class Alloc>
     bool
     operator!=(const unordered_multiset<Value, Hash, Pred, Alloc>& x,
                const unordered_multiset<Value, Hash, Pred, Alloc>& y);
 }  // std
 
 */
 
+#include <__algorithm/is_permutation.h>
 #include <__config>
 #include <__debug>
 #include <__functional/__is_transparent.h>
 #include <__functional/equal_to.h>
 #include <__hash_table>
 #include <__node_handle>
 #include <__utility/declval.h>
 #include <__utility/forward.h>

libcxx/include/valarray

 template <class T> unspecified2 begin(const valarray<T>& v);
 template <class T> unspecified1 end(valarray<T>& v);
 template <class T> unspecified2 end(const valarray<T>& v);
 
 }  // std
 
 */
 
+#include <__algorithm/copy.h>
+#include <__algorithm/count.h>
+#include <__algorithm/fill.h>
+#include <__algorithm/fill_n.h>
+#include <__algorithm/max_element.h>
+#include <__algorithm/min.h>
+#include <__algorithm/min_element.h>
 #include <__config>
 #include <__functional/bit_and.h>
 #include <__functional/bit_or.h>
 #include <__functional/bit_xor.h>
 #include <__functional/equal_to.h>
 #include <__functional/divides.h>
 #include <__functional/greater.h>
 #include <__functional/greater_equal.h>
 #include <__functional/less.h>
 #include <__functional/less_equal.h>
 #include <__functional/logical_and.h>
 #include <__functional/logical_not.h>
 #include <__functional/logical_or.h>
 #include <__functional/minus.h>
 #include <__functional/modulus.h>
 #include <__functional/multiplies.h>
 #include <__functional/negate.h>
 #include <__functional/not_equal_to.h>
 #include <__functional/plus.h>
-#include <algorithm>
+#include <__memory/allocator.h>
+#include <__memory/uninitialized_algorithms.h>
+#include <__utility/move.h>
+#include <__utility/swap.h>
 #include <cmath>
 #include <cstddef>
 #include <initializer_list>
 #include <new>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
gslice(size_t __start, const valarray<size_t>& __size,
         {__init(__start);}
 
 #ifndef _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY
     gslice(size_t __start, const valarray<size_t>&  __size,
                                  valarray<size_t>&& __stride)
         : __size_(__size),
-          __stride_(move(__stride))
+          __stride_(_VSTD::move(__stride))
         {__init(__start);}
 
     _LIBCPP_INLINE_VISIBILITY
     gslice(size_t __start,       valarray<size_t>&& __size,
                            const valarray<size_t>&  __stride)
-        : __size_(move(__size)),
+        : __size_(_VSTD::move(__size)),
           __stride_(__stride)
         {__init(__start);}
 
     _LIBCPP_INLINE_VISIBILITY
     gslice(size_t __start,       valarray<size_t>&& __size,
                                  valarray<size_t>&& __stride)
-        : __size_(move(__size)),
-          __stride_(move(__stride))
+        : __size_(_VSTD::move(__size)),
+          __stride_(_VSTD::move(__stride))
         {__init(__start);}
 
 #endif // _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY
     size_t           start()  const {return __1d_.size() ? __1d_[0] : 0;}
 
     _LIBCPP_INLINE_VISIBILITY
private:
     gslice_array(const gslice& __gs, const valarray<value_type>& __v)
         : __vp_(const_cast<value_type*>(__v.__begin_)),
           __1d_(__gs.__1d_)
         {}
 
 #ifndef _LIBCPP_CXX03_LANG
     gslice_array(gslice&& __gs, const valarray<value_type>& __v)
         : __vp_(const_cast<value_type*>(__v.__begin_)),
-          __1d_(move(__gs.__1d_))
+          __1d_(_VSTD::move(__gs.__1d_))
         {}
 #endif // _LIBCPP_CXX03_LANG
 
     template <class> friend class valarray;
 };
 
 template <class _Tp>
 template <class _Expr>
indirect_array(const valarray<size_t>& __ia, const valarray<value_type>& __v)
           __1d_(__ia)
         {}
 
 #ifndef _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY
     indirect_array(valarray<size_t>&& __ia, const valarray<value_type>& __v)
         : __vp_(const_cast<value_type*>(__v.__begin_)),
-          __1d_(move(__ia))
+          __1d_(_VSTD::move(__ia))
         {}
 
 #endif // _LIBCPP_CXX03_LANG
 
     template <class> friend class valarray;
 };
 
 template <class _Tp>
__indirect_expr(const valarray<size_t>& __ia, const _RmExpr& __e)
           __1d_(__ia)
           {}
 
 #ifndef _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY
     __indirect_expr(valarray<size_t>&& __ia, const _RmExpr& __e)
         : __expr_(__e),
-          __1d_(move(__ia))
+          __1d_(_VSTD::move(__ia))
           {}
 
 #endif // _LIBCPP_CXX03_LANG
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     __result_type operator[](size_t __i) const
         {return __expr_[__1d_[__i]];}

 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp>
 inline
 __val_expr<__indirect_expr<const valarray<_Tp>&> >
 valarray<_Tp>::operator[](gslice&& __gs) const
 {
-    return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(move(__gs.__1d_), *this));
+    return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(_VSTD::move(__gs.__1d_), *this));
 }
 
 template <class _Tp>
 inline
 gslice_array<_Tp>
 valarray<_Tp>::operator[](gslice&& __gs)
 {
-    return gslice_array<value_type>(move(__gs), *this);
+    return gslice_array<value_type>(_VSTD::move(__gs), *this);
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp>
 inline
 __val_expr<__mask_expr<const valarray<_Tp>&> >
 valarray<_Tp>::operator[](const valarray<bool>& __vb) const

 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp>
 inline
 __val_expr<__mask_expr<const valarray<_Tp>&> >
 valarray<_Tp>::operator[](valarray<bool>&& __vb) const
 {
-    return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(move(__vb), *this));
+    return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(_VSTD::move(__vb), *this));
 }
 
 template <class _Tp>
 inline
 mask_array<_Tp>
 valarray<_Tp>::operator[](valarray<bool>&& __vb)
 {
-    return mask_array<value_type>(move(__vb), *this);
+    return mask_array<value_type>(_VSTD::move(__vb), *this);
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp>
 inline
 __val_expr<__indirect_expr<const valarray<_Tp>&> >
 valarray<_Tp>::operator[](const valarray<size_t>& __vs) const

 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp>
 inline
 __val_expr<__indirect_expr<const valarray<_Tp>&> >
 valarray<_Tp>::operator[](valarray<size_t>&& __vs) const
 {
-    return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(move(__vs), *this));
+    return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(_VSTD::move(__vs), *this));
 }
 
 template <class _Tp>
 inline
 indirect_array<_Tp>
 valarray<_Tp>::operator[](valarray<size_t>&& __vs)
 {
-    return indirect_array<value_type>(move(__vs), *this);
+    return indirect_array<value_type>(_VSTD::move(__vs), *this);
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp>
 valarray<_Tp>
 valarray<_Tp>::operator+() const
 {

libcxx/include/variant

 
 */
 
 #include <__availability>
 #include <__config>
 #include <__functional/equal_to.h>
 #include <__functional/greater.h>
 #include <__functional/greater_equal.h>
+#include <__functional/hash.h>
 #include <__functional/less.h>
 #include <__functional/less_equal.h>
 #include <__functional/not_equal_to.h>
 #include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/integer_sequence.h>
 #include <__utility/move.h>

libcxx/include/vector

 template <class T, class Allocator, class Predicate>
 typename vector<T, Allocator>::size_type
 erase_if(vector<T, Allocator>& c, Predicate pred);    // C++20
 
 }  // std
 
 */
 
+#include <__algorithm/copy.h>
+#include <__algorithm/copy_backward.h>
+#include <__algorithm/equal.h>
+#include <__algorithm/fill_n.h>
+#include <__algorithm/lexicographical_compare.h>
+#include <__algorithm/remove.h>
+#include <__algorithm/remove_if.h>
+#include <__algorithm/rotate.h>
 #include <__config>
 #include <__bit_reference>
 #include <__debug>
 #include <__split_buffer>
 #include <__utility/forward.h>
 #include <__utility/move.h>
-#include <algorithm>
 #include <climits>
 #include <compare>
 #include <cstring>
 #include <initializer_list>
 #include <iosfwd> // for forward declaration of vector
 #include <limits>
 #include <memory>
 #include <stdexcept>

libcxx/test/std/containers/sequences/array/array.data/data.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
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 
 // T *data();
 
 #include <array>
 #include <cassert>
 #include <cstddef>       // for std::max_align_t
+#include <cstdint>       // for std::uintptr_t
 
 #include "test_macros.h"
 
 // std::array is explicitly allowed to be initialized with A a = { init-list };.
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
 struct NoDefault {

libcxx/test/std/containers/sequences/array/array.data/data_const.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
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 
 // const T* data() const;
 
 #include <array>
 #include <cassert>
 #include <cstddef>       // for std::max_align_t
+#include <cstdint>       // for std::uintptr_t
 
 #include "test_macros.h"
 
 // std::array is explicitly allowed to be initialized with A a = { init-list };.
 // Disable the missing braces warning for this reason.
 #include "disable_missing_braces_warning.h"
 
 struct NoDefault {

libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/deduct.pass.cpp

 //
 
 
 #include <forward_list>
 #include <iterator>
 #include <cassert>
 #include <cstddef>
 #include <climits> // INT_MAX
+#include <algorithm> // equal
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "test_allocator.h"
 
 struct A {};
 
 int main(int, char**)

libcxx/test/std/containers/sequences/list/list.ops/sort.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
 //
 //===----------------------------------------------------------------------===//
 
 // <list>
 
 // void sort();
 
 #include <list>
+#include <algorithm>
+#include <cassert>
 #include <random>
 #include <vector>
-#include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 std::mt19937 randomness;
 
 struct Payload
 {