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

[cjdb]

Summary

Depends on D104980.

[cjdb]

adds missing header (not sure why it wasn't caught earlier)

[cjdb]

rebases to activate CI

[cjdb]

fixes C++03 mode

[cjdb]

rebases to activate CI

[ldionne]

LGTM assuming you rebase onto the other reviews (which means that things like the 10 includes of __functional/<operation>.h will turn into a single include).

[cjdb]

rebases, catches a few stragglers, removes headers <functional> directly pulls in (ATTN @ldionne)

[cjdb]

rebases to activate CI

[cjdb]

rebases onto main

[cjdb]

Blocked by D104980.

libcxx/include/__ranges/drop_view.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___RANGES_DROP_VIEW_H
 #define _LIBCPP___RANGES_DROP_VIEW_H
 
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/concepts.h>
+#include <__iterator/next.h>
 #include <__ranges/access.h>
 #include <__ranges/view_interface.h>
 #include <__ranges/all.h>
 #include <__utility/declval.h>
 #include <__utility/move.h>
 #include <type_traits>
 #include <optional>
 

libcxx/include/algorithm

 
 */
 
 #include <__config>
 #include <__debug>
 #include <__bits> // __libcpp_clz
 #include <cstddef>
 #include <cstring>
-#include <functional>
 #include <initializer_list>
 #include <memory>
 #include <iterator>
 #include <memory>
 #include <type_traits>
 #include <version>
 
 #include <__algorithm/adjacent_find.h>

libcxx/include/ext/hash_map

template <class Key, class T, class Hash, class Pred, class Alloc>
     operator!=(const hash_multimap<Key, T, Hash, Pred, Alloc>& x,
                const hash_multimap<Key, T, Hash, Pred, Alloc>& y);
 
 }  // __gnu_cxx
 
 */
 
 #include <__config>
+#include <__functional/equal_to.h>
 #include <__hash_table>
 #include <__utility/pair.h>
-#include <functional>
 #include <stdexcept>
 #include <type_traits>
 #include <ext/__hash>
 
 #if defined(__DEPRECATED) && __DEPRECATED
 #if defined(_LIBCPP_WARNING)
     _LIBCPP_WARNING("Use of the header <ext/hash_map> is deprecated.  Migrate to <unordered_map>")
 #else

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 <__config>
+#include <__functional/equal_to.h>
 #include <__hash_table>
 #include <__utility/pair.h>
-#include <functional>
 #include <ext/__hash>
 
 #if defined(__DEPRECATED) && __DEPRECATED
 #if defined(_LIBCPP_WARNING)
     _LIBCPP_WARNING("Use of the header <ext/hash_set> is deprecated.  Migrate to <unordered_set>")
 #else
 #   warning Use of the header <ext/hash_set> is deprecated.  Migrate to <unordered_set>
 #endif

libcxx/include/map

 
 }  // std
 
 */
 
 #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>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/piecewise_construct.h>
 #include <__utility/swap.h>
 #include <compare>
-#include <functional>
 #include <initializer_list>
 #include <iterator> // __libcpp_erase_if_container
 #include <memory>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

libcxx/include/mutex

 */
 
 #include <__config>
 #include <__mutex_base>
 #include <__threading_support>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <cstdint>
-#include <functional>
 #include <memory>
 #ifndef _LIBCPP_CXX03_LANG
 # include <tuple>
 #endif
 #include <type_traits> // __invoke
 #include <version>
 
 

libcxx/include/numeric

template<class T>
     constexpr T* midpoint(T* a, T* b);        // C++20
 
 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
+#include <__functional/multiplies.h>
+#include <__functional/plus.h>
 #include <__utility/move.h>
 #include <cmath> // for isnormal
-#include <functional>
 #include <iterator>
 #include <limits> // for numeric_limits
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 

libcxx/include/optional

 
 } // namespace std
 
 */
 
 #include <__availability>
 #include <__config>
 #include <__debug>
+#include <__functional/hash.h>
+#include <__memory/construct_at.h>
+#include <__tuple>
 #include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <compare>
-#include <functional>
 #include <initializer_list>
 #include <new>
 #include <stdexcept>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

libcxx/include/queue

void swap(priority_queue<T, Container, Compare>& x,
             priority_queue<T, Container, Compare>& y)
             noexcept(noexcept(x.swap(y)));
 
 }  // std
 
 */
 
 #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 <functional>
 #include <vector>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/set

 
 }  // std
 
 */
 
 #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>
 #include <__utility/pair.h>
 #include <compare>
-#include <functional>
 #include <initializer_list>
 #include <iterator> // __libcpp_erase_if_container
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 

libcxx/include/thread

 #include <__debug>
 #include <__mutex_base>
 #include <__threading_support>
 #include <__utility/__decay_copy.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <chrono>
 #include <cstddef>
-#include <functional>
 #include <iosfwd>
 #include <memory>
 #include <system_error>
 #include <tuple>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

libcxx/include/unordered_map

 
 }  // std
 
 */
 
 #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>
 #include <__utility/pair.h>
 #include <__utility/piecewise_construct.h>
 #include <compare>
-#include <functional>
 #include <iterator> // __libcpp_erase_if_container
 #include <stdexcept>
 #include <tuple>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif

libcxx/include/unordered_set

operator!=(const unordered_multiset<Value, Hash, Pred, Alloc>& x,
                const unordered_multiset<Value, Hash, Pred, Alloc>& y);
 }  // std
 
 */
 
 #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>
 #include <__utility/pair.h>
 #include <__utility/move.h>
 #include <compare>
-#include <functional>
 #include <iterator> // __libcpp_erase_if_container
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/valarray

 template <class T> unspecified1 end(valarray<T>& v);
 template <class T> unspecified2 end(const valarray<T>& v);
 
 }  // std
 
 */
 
 #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 <cmath>
 #include <cstddef>
-#include <functional>
 #include <initializer_list>
 #include <new>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/variant

namespace std {
   template <> struct hash<monostate>;
 
 } // namespace std
 
 */
 
 #include <__availability>
 #include <__config>
+#include <__functional/equal_to.h>
+#include <__functional/greater.h>
+#include <__functional/greater_equal.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>
 #include <__tuple>
 #include <array>
 #include <compare>
 #include <exception>
-#include <functional>
 #include <initializer_list>
 #include <limits>
 #include <new>
 #include <tuple>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/test/libcxx/numerics/numeric.ops/midpoint.integer.pass.cpp

 // <numeric>
 
 // template <class _Tp>
 // _Tp midpoint(_Tp __a, _Tp __b) noexcept
 //
 
 #include <numeric>
 #include <cassert>
+#include <cstdint>
 #include "test_macros.h"
 
 //  Users are not supposed to provide template argument lists for
 //  functions in the standard library (there's an exception for min and max)
 //  However, libc++ protects against this for pointers, so we check to make
 //  sure that our protection is working here.
 //  In some cases midpoint<int>(0,0) might get deduced as the pointer overload.
 

libcxx/test/std/algorithms/alg.nonmodifying/alg.foreach/for_each_n.pass.cpp

 
 // template<class InputIterator, class Size, class Function>
 //    constexpr InputIterator      // constexpr after C++17
 //    for_each_n(InputIterator first, Size n, Function f);
 
 
 #include <algorithm>
 #include <cassert>
+#include <functional>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 #if TEST_STD_VER > 17
 TEST_CONSTEXPR bool test_constexpr() {
     int ia[] = {1, 3, 6, 7};
     int expected[] = {3, 5, 8, 9};

libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp

 
 // template<RandomAccessIterator Iter>
 //   requires ShuffleIterator<Iter> && LessThanComparable<Iter::value_type>
 //   constexpr void  // constexpr in C++20
 //   sort_heap(Iter first, Iter last, Compare comp);
 
 #include <algorithm>
 #include <cassert>
+#include <functional>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "MoveOnly.h"
 

libcxx/test/std/concepts/concepts.callable/concept.invocable/invocable.compile.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
 
 // template<class T, class U>
 // concept invocable;
 
-#include <chrono>
 #include <concepts>
+
+#include <chrono>
+#include <functional>
 #include <memory>
 #include <random>
 #include <type_traits>
 
 template <class R, class... Args>
 [[nodiscard]] constexpr bool check_invocable() {
   constexpr bool result = std::invocable<R(Args...), Args...>;
   static_assert(std::invocable<R(Args...) noexcept, Args...> == result);

libcxx/test/std/concepts/concepts.callable/concept.regularinvocable/regular_invocable.compile.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
 
 // template<class T, class U>
 // concept regular_invocable;
 
-#include <chrono>
 #include <concepts>
+
+#include <chrono>
+#include <functional>
 #include <memory>
 #include <random>
 #include <type_traits>
 
 template <class R, class... Args>
 [[nodiscard]] constexpr bool check_invocable() {
   constexpr bool result = std::regular_invocable<R(Args...), Args...>;
   static_assert(std::regular_invocable<R(Args...) noexcept, Args...> == result);

libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.fail.cpp

 // UNSUPPORTED: c++03, c++11, c++14
 // UNSUPPORTED: libcpp-no-deduction-guides
 
 #include <queue>
 #include <deque>
 #include <iterator>
 #include <cassert>
 #include <cstddef>
+#include <functional>
 
 
 int main(int, char**)
 {
 //  Test the explicit deduction guides
     {
 //  queue(Compare, Container, const Alloc);
 //  The '45' is not an allocator

libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons/deduct.pass.cpp

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

libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/remove_if.pass.cpp

 
 // template <class Predicate> void      remove_if(Predicate pred); // C++17 and before
 // template <class Predicate> size_type remove_if(Predicate pred); // C++20 and after
 
 #include <forward_list>
 #include <iterator>
 #include <cassert>
 #include <cstddef>
+#include <functional>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "counting_predicates.h"
 
 
 template <class L, class Predicate>
 void do_remove_if(L &l, Predicate pred, typename L::size_type expected)

libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/unique_pred.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
 //
 //===----------------------------------------------------------------------===//
 
 // <forward_list>
 
 // template <class BinaryPredicate> void unique(BinaryPredicate binary_pred);      // C++17 and before
 // template <class BinaryPredicate> size_type unique(BinaryPredicate binary_pred); // C++20 and after
 
 #include <forward_list>
 #include <iterator>
 #include <cassert>
+#include <functional>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class L, class Predicate>
 void do_unique(L &l, Predicate pred, typename L::size_type expected)
 {
     typename L::size_type old_size = std::distance(l.begin(), l.end());

libcxx/test/std/containers/sequences/list/list.ops/unique_pred.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>
 
 // template <class BinaryPred> void      unique(BinaryPred pred); // before C++20
 // template <class BinaryPred> size_type unique(BinaryPred pred); // C++20 and later
 
 #include <list>
 #include <cassert>
+#include <functional>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 bool g(int x, int y)
 {
     return x == y;
 }

libcxx/test/std/experimental/memory/memory.resource.aliases/header_map_synop.pass.cpp

 //     ::std::multimap<K, V, Compare, polymorphic_allocator<pair<const K, V>>>
 //
 // }}} // namespace std::experimental::pmr
 
 #include <experimental/map>
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
+#include <functional>
 
 #include "test_macros.h"
 
 namespace pmr = std::experimental::pmr;
 
 int main(int, char**)
 {
     using K = int;

libcxx/test/std/experimental/memory/memory.resource.aliases/header_set_synop.pass.cpp

 //     ::std::multiset<V, Compare, polymorphic_allocator<V>>
 //
 // }}} // namespace std::experimental::pmr
 
 #include <experimental/set>
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
+#include <functional>
 
 #include "test_macros.h"
 
 namespace pmr = std::experimental::pmr;
 
 int main(int, char**)
 {
     using V = char;

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_optional_U.pass.cpp

 // <optional>
 
 // template <class U>
 //   explicit optional(optional<U>&& rhs);
 
 #include <optional>
 #include <type_traits>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 
 using std::optional;
 
 template <class T, class U>
 TEST_CONSTEXPR_CXX20 void test(optional<U>&& rhs, bool is_going_to_throw = false)
 {

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.pass.cpp

 // template<class R, class T>
 //   constexpr bool in_range(T t) noexcept;               // C++20
 
 #include <utility>
 #include <limits>
 #include <numeric>
 #include <tuple>
 #include <cassert>
+#include <cstdint>
 
 #include "test_macros.h"
 
 template <typename T>
 struct Tuple {
   T min;
   T max;
   T mid;