[libc++] Remove unused __functional includes

[philnik]

• Fix CI

[ldionne]

I don't understand this review's title in relationship with the diff. Is it an error?

[philnik]

@ldionne Oops, looks like I uploaded the wrong diff once.

[ldionne]

This needs a release note to mention that we removed some includes of <functional>, since this may break users. Other than that, LGTM.

[philnik]

In D126098#3543159, @ldionne wrote:

This needs a release note to mention that we removed some includes of <functional>, since this may break users. Other than that, LGTM.

We've already added a release note in D124123.

libcxx/include/__algorithm/sort.h

 #define _LIBCPP___ALGORITHM_SORT_H
 
 #include <__algorithm/comp.h>
 #include <__algorithm/comp_ref_type.h>
 #include <__algorithm/min_element.h>
 #include <__algorithm/partial_sort.h>
 #include <__algorithm/unwrap_iter.h>
 #include <__config>
+#include <__functional/operations.h>
 #include <__utility/swap.h>
 #include <memory>
 
 #if defined(_LIBCPP_DEBUG_RANDOMIZE_UNSPECIFIED_STABILITY)
 #  include <__algorithm/shuffle.h>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/__format/format_arg.h

 #define _LIBCPP___FORMAT_FORMAT_ARG_H
 
 #include <__assert>
 #include <__concepts/arithmetic.h>
 #include <__config>
 #include <__format/format_error.h>
 #include <__format/format_fwd.h>
 #include <__format/format_parse_context.h>
+#include <__functional/invoke.h>
 #include <__memory/addressof.h>
+#include <__utility/forward.h>
 #include <__utility/unreachable.h>
 #include <__variant/monostate.h>
 #include <string>
 #include <string_view>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/experimental/coroutine

 } // namespace coroutines_v1
 } // namespace experimental
 } // namespace std
 
  */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__functional/hash.h>
+#include <__functional/operations.h>
 #include <cstddef>
 #include <experimental/__config>
 #include <memory> // for hash<T*>
 #include <new>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

libcxx/include/ext/hash_map

 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__hash_table>
 #include <algorithm>
 #include <ext/__hash>
+#include <functional>
 #include <stdexcept>
 #include <type_traits>
 
 #if defined(__DEPRECATED) && __DEPRECATED
 #if defined(_LIBCPP_WARNING)
     _LIBCPP_WARNING("Use of the header <ext/hash_map> is deprecated.  Migrate to <unordered_map>")
 #else
 #   warning Use of the header <ext/hash_map> is deprecated.  Migrate to <unordered_map>

libcxx/include/ext/hash_set

 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__hash_table>
 #include <algorithm>
 #include <ext/__hash>
+#include <functional>
 
 #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
 #endif

libcxx/include/iterator

 #include <compare>
 #include <concepts> // Mandated by the Standard.
 #include <cstddef>
 #include <initializer_list>
 #include <type_traits>
 #include <version>
 
 // TODO: remove these headers
-#include <__functional/binary_function.h>
-#include <__functional/invoke.h>
-#include <__functional/operations.h>
-#include <__functional/reference_wrapper.h>
-#include <__functional/unary_function.h>
-#include <__functional/weak_result_type.h>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/uses_allocator.h>
 #include <exception>
 #include <new>
 #include <typeinfo>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_ITERATOR

libcxx/include/map

 }  // std
 
 */
 
 #include <__algorithm/equal.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__functional/binary_function.h>
 #include <__functional/is_transparent.h>
+#include <__functional/operations.h>
 #include <__iterator/iterator_traits.h>
 #include <__node_handle>
 #include <__tree>
 #include <__utility/forward.h>
 #include <__utility/swap.h>
 #include <compare>
 #include <initializer_list>
 #include <iterator> // __libcpp_erase_if_container

libcxx/include/memory

 #include <iterator>
 #include <new>
 #include <stdexcept>
 #include <tuple>
 #include <type_traits>
 #include <typeinfo>
 #include <version>
 
-// TODO: remove these headers
-#include <__functional/binary_function.h>
-#include <__functional/invoke.h>
-#include <__functional/operations.h>
-#include <__functional/reference_wrapper.h>
-#include <__functional/unary_function.h>
-#include <__functional/weak_result_type.h>
-
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
 #   include <__memory/auto_ptr.h>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/queue

 
 */
 
 #include <__algorithm/make_heap.h>
 #include <__algorithm/pop_heap.h>
 #include <__algorithm/push_heap.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__functional/operations.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/uses_allocator.h>
 #include <__utility/forward.h>
 #include <compare>
 #include <deque>
 #include <type_traits>
 #include <vector>
 #include <version>

libcxx/include/set

 
 */
 
 #include <__algorithm/equal.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__functional/is_transparent.h>
+#include <__functional/operations.h>
 #include <__iterator/iterator_traits.h>
 #include <__node_handle>
 #include <__tree>
 #include <__utility/forward.h>
 #include <compare>
 #include <initializer_list>
 #include <iterator> // __libcpp_erase_if_container
 #include <version>

libcxx/include/string

 #include <__algorithm/max.h>
 #include <__algorithm/min.h>
 #include <__algorithm/remove.h>
 #include <__algorithm/remove_if.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__debug>
 #include <__format/enable_insertable.h>
+#include <__functional/unary_function.h>
 #include <__ios/fpos.h>
 #include <__iterator/wrap_iter.h>
 #include <__memory/allocate_at_least.h>
 #include <__utility/auto_cast.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <__utility/unreachable.h>
 #include <climits>
 #include <compare>
 #include <cstdio>  // EOF
 #include <cstdlib>
 #include <cstring>
 #include <initializer_list>
 #include <iosfwd>
 #include <iterator>
 #include <limits>
 #include <memory>
 #include <stdexcept>
 #include <string_view>
 #include <type_traits>
 #include <version>
 
 // TODO: remove these headers
-#include <__functional/binary_function.h>
-#include <__functional/invoke.h>
-#include <__functional/operations.h>
-#include <__functional/reference_wrapper.h>
-#include <__functional/unary_function.h>
-#include <__functional/weak_result_type.h>
 #include <new>
 #include <typeinfo>
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #  include <cwchar>
 #endif
 
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS

libcxx/include/string_view

 }  // namespace std
 
 
 */
 
 #include <__algorithm/min.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__functional/unary_function.h>
 #include <__fwd/string_view.h>
 #include <__ranges/concepts.h>
 #include <__ranges/data.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/size.h>
 #include <__string>
 #include <compare>

libcxx/include/tuple

 #include <__utility/piecewise_construct.h>
 #include <__utility/swap.h>
 #include <compare>
 #include <cstddef>
 #include <type_traits>
 #include <version>
 
 // TODO: remove these headers
-#include <__functional/binary_function.h>
-#include <__functional/invoke.h>
-#include <__functional/operations.h>
-#include <__functional/reference_wrapper.h>
-#include <__functional/unary_function.h>
-#include <__functional/weak_result_type.h>
 #include <exception>
 #include <new>
 #include <typeinfo>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/typeindex

 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__functional/unary_function.h>
 #include <compare>
 #include <typeinfo>
 #include <version>
 
 // TODO: remove these headers
-#include <__functional/binary_function.h>
-#include <__functional/invoke.h>
-#include <__functional/operations.h>
-#include <__functional/reference_wrapper.h>
-#include <__functional/weak_result_type.h>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/uses_allocator.h>
 #include <new>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/unordered_map

 
 */
 
 #include <__algorithm/is_permutation.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__debug>
 #include <__functional/is_transparent.h>
+#include <__functional/operations.h>
 #include <__hash_table>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__node_handle>
 #include <__utility/forward.h>
 #include <compare>
 #include <iterator> // __libcpp_erase_if_container
 #include <stdexcept>

libcxx/include/unordered_set

 
 */
 
 #include <__algorithm/is_permutation.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__debug>
 #include <__functional/is_transparent.h>
+#include <__functional/operations.h>
 #include <__hash_table>
 #include <__memory/addressof.h>
 #include <__node_handle>
 #include <__utility/forward.h>
 #include <compare>
 #include <iterator> // __libcpp_erase_if_container
 #include <version>
 

libcxx/include/variant

 #include <initializer_list>
 #include <limits>
 #include <new>
 #include <tuple>
 #include <type_traits>
 #include <version>
 
 // TODO: remove these headers
-#include <__functional/binary_function.h>
-#include <__functional/invoke.h>
-#include <__functional/reference_wrapper.h>
-#include <__functional/weak_result_type.h>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/uses_allocator.h>
 #include <typeinfo>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/vector

 #include <__algorithm/rotate.h>
 #include <__algorithm/unwrap_iter.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__bit_reference>
 #include <__config>
 #include <__debug>
 #include <__format/enable_insertable.h>
 #include <__functional/hash.h>
+#include <__functional/unary_function.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/wrap_iter.h>
 #include <__memory/allocate_at_least.h>
 #include <__split_buffer>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <climits>
 #include <compare>
 #include <cstdlib>
 #include <cstring>
 #include <initializer_list>
 #include <iosfwd> // for forward declaration of vector
 #include <limits>
 #include <memory>
 #include <stdexcept>
 #include <type_traits>
 #include <version>
 
 // TODO: remove these headers
-#include <__functional/binary_function.h>
-#include <__functional/invoke.h>
-#include <__functional/operations.h>
-#include <__functional/reference_wrapper.h>
-#include <__functional/unary_function.h>
-#include <__functional/weak_result_type.h>
 #include <typeinfo>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/test/libcxx/algorithms/debug_less.pass.cpp

 
 // __debug_less checks that a comparator actually provides a strict-weak ordering.
 
 // REQUIRES: has-unix-headers
 // UNSUPPORTED: libcxx-no-debug-mode, c++03
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
 
 #include <algorithm>
-#include <iterator>
 #include <cassert>
+#include <functional>
+#include <iterator>
 
 #include "test_macros.h"
 #include "check_assertion.h"
 
 template <int ID>
 struct MyType {
     int value;
     explicit MyType(int xvalue = 0) : value(xvalue) {}

libcxx/test/libcxx/algorithms/sort_stability.pass.cpp

 // Test std::sort stability randomization
 
 // UNSUPPORTED: libcxx-no-debug-mode, c++03, windows
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
 
 #include <algorithm>
 #include <array>
 #include <cassert>
+#include <functional>
 #include <iterator>
 #include <vector>
 
 #include "test_macros.h"
 
 struct EqualType {
   int value = 0;
   constexpr bool operator<(const EqualType&) const { return false; }

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/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
 
 // template<class T, class U>
 // concept invocable;
 
 #include <chrono>
 #include <concepts>
+#include <functional>
 #include <memory>
 #include <random>
 #include <type_traits>
 
 template <class R, class... Args>
 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
 
 // template<class T, class U>
 // concept regular_invocable;
 
 #include <chrono>
 #include <concepts>
+#include <functional>
 #include <memory>
 #include <random>
 #include <type_traits>
 
 template <class R, class... Args>
 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/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 <cassert>
 #include <forward_list>
+#include <functional>
 #include <iterator>
-#include <cassert>
 
 #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/language.support/support.coroutines/coroutine.handle/coroutine.handle.hash/hash.pass.cpp

 // }
 
 #include <experimental/coroutine>
 #include <type_traits>
 #include <memory>
 #include <utility>
 #include <cstdint>
 #include <cassert>
+#include <functional>
 
 #include "test_macros.h"
 
 namespace coro = std::experimental;
 
 template <class C>
 void do_test(uintptr_t LHSVal, uintptr_t RHSVal) {
   const size_t ExpectLHS = std::hash<void*>{}(reinterpret_cast<void*>(LHSVal));

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp

 // public:
 //   typedef Iter                  iterator_type;
 //   typedef Iter::difference_type difference_type;
 //   typedef Iter                  pointer;
 //   typedef Iter::value_type      value_type;
 //   typedef value_type&&          reference;
 // };
 
+#include <functional>
 #include <iterator>
 #include <type_traits>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 template <class ValueType, class Reference>
 struct DummyIt {

libcxx/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp

 // <numeric>
 
 // Became constexpr in C++20
 // template<class InputIterator, class T, class BinaryOperation>
 //   T reduce(InputIterator first, InputIterator last, T init, BinaryOperation op);
 
 #include <numeric>
 #include <cassert>
+#include <functional>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 template <class Iter, class T, class Op>
 TEST_CONSTEXPR_CXX20 void
 test(Iter first, Iter last, T init, Op op, T x)
 {

libcxx/test/std/ranges/range.adaptors/range.join.view/sentinel/eq.pass.cpp

 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // template<bool OtherConst>
 //   requires sentinel_for<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
 // friend constexpr bool operator==(const iterator<OtherConst>& x, const sentinel& y);
 
 #include <cassert>
 #include <concepts>
+#include <functional>
 #include <ranges>
 
 #include "../types.h"
 
 template <class Iter, class Sent>
 concept EqualityComparable = std::invocable<std::equal_to<>, const Iter&, const Sent&> ;
 
 using Iterator = random_access_iterator<BufferView<int*>*>;

libcxx/test/std/ranges/range.adaptors/range.zip/types.h

 //===----------------------------------------------------------------------===//
 //
 // 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 TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_ZIP_TYPES_H
 #define TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_ZIP_TYPES_H
 
+#include <functional>
 #include <ranges>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "test_range.h"
 
 #if TEST_STD_VER <= 20
 #  error "range.zip/types.h" can only be included in builds supporting C++20

libcxx/test/support/deduction_guides_sfinae_checks.h

 //===----------------------------------------------------------------------===//
 //
 // 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 TEST_SUPPORT_DEDUCTION_GUIDES_SFINAE_CHECKS_H
 #define TEST_SUPPORT_DEDUCTION_GUIDES_SFINAE_CHECKS_H
 
+#include <functional>
 #include <initializer_list>
 #include <memory>
 #include <type_traits>
 #include <utility>
 
 #include "test_macros.h"
 
 // `SFINAEs_away` template variable checks whether the template arguments for