[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/CMakeLists.txt

set(files
   __bsd_locale_defaults.h
   __bsd_locale_fallbacks.h
   __config
   __debug
   __errc
   __format/format_error.h
   __format/format_parse_context.h
   __function_like.h
-  __functional_base
   __functional/binary_function.h
   __functional/binary_negate.h
   __functional/bind_front.h
   __functional/bind.h
   __functional/binder1st.h
   __functional/binder2nd.h
   __functional/default_searcher.h
   __functional/function.h

libcxx/include/__functional/bind.h

 
 #include <__config>
 #include <__functional/weak_result_type.h>
 #include <__functional/invoke.h>
 #include <__utility/forward.h>
 #include <cstddef>
 #include <tuple>
 #include <type_traits>
+#include <typeinfo>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template<class _Tp> struct __is_bind_expression : public false_type {};

libcxx/include/__functional_base

-// -*- 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_FUNCTIONAL_BASE
-#define _LIBCPP_FUNCTIONAL_BASE
-
-#include <__config>
-#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 <type_traits>
-#include <typeinfo>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#pragma GCC system_header
-#endif
-
-#endif // _LIBCPP_FUNCTIONAL_BASE

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 <__bits> // __libcpp_clz
 #include <__config>
 #include <__debug>
+#include <__functional/hash.h>
 #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>

libcxx/include/__memory/shared_ptr.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_SHARED_PTR_H
 #define _LIBCPP___MEMORY_SHARED_PTR_H
 
 #include <__availability>
 #include <__config>
-#include <__functional_base>
 #include <__functional/binary_function.h>
 #include <__functional/operations.h>
 #include <__functional/reference_wrapper.h>
 #include <__memory/addressof.h>
 #include <__memory/allocation_guard.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/allocator.h>
 #include <__memory/compressed_pair.h>

libcxx/include/__memory/unique_ptr.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_UNIQUE_PTR_H
 #define _LIBCPP___MEMORY_UNIQUE_PTR_H
 
 #include <__config>
-#include <__functional_base>
 #include <__functional/hash.h>
 #include <__functional/operations.h>
 #include <__memory/allocator_traits.h> // __pointer
 #include <__memory/compressed_pair.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <cstddef>
 #include <type_traits>

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/bitset

 template <size_t N> struct hash<std::bitset<N>>;
 
 }  // std
 
 */
 
 #include <__config>
 #include <__bit_reference>
-#include <__functional_base>
+#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/concepts

namespace std {
   template<class R, class T, class U>
     concept strict_weak_order = see below;
 }
 
 */
 
 #include <__config>
 #include <__functional/invoke.h>
-#include <__functional_base>
 #include <__utility/declval.h>
 #include <__utility/exchange.h>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif

libcxx/include/experimental/__memory

 // -*- 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_EXPERIMENTAL___MEMORY
 #define _LIBCPP_EXPERIMENTAL___MEMORY
 
 #include <__memory/allocator_arg_t.h>
 #include <__memory/uses_allocator.h>
 #include <experimental/__config>
 #include <experimental/utility> // for erased_type
-#include <__functional_base>
 #include <type_traits>
 
 _LIBCPP_BEGIN_NAMESPACE_LFTS
 
 template <
     class _Tp, class _Alloc
   , bool = uses_allocator<_Tp, _Alloc>::value
   , bool = __has_allocator_type<_Tp>::value

libcxx/include/experimental/propagate_const

 
 #include <experimental/__config>
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 11
 
-#include <type_traits>
+#include <__utility/forward.h>
+#include <__utility/move.h>
 #include <functional>
+#include <type_traits>
 
 _LIBCPP_BEGIN_NAMESPACE_LFTS_V2
 
 
 template <class _Tp>
 class propagate_const;
 
 template <class _Up>

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/operations.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/operations.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/functional

 }  // std
 
 POLICY:  For non-variadic implementations, the number of arguments is limited
          to 3.  It is hoped that the need for non-variadic implementations
          will be minimal.
 
 */
 
-#include <__algorithm/search.h>
-#include <__config>
-#include <__debug>
 #include <__functional/binary_function.h> // TODO: deprecate
 #include <__functional/binary_negate.h>
 #include <__functional/bind_front.h>
 #include <__functional/bind.h>
 #include <__functional/binder1st.h>
 #include <__functional/binder2nd.h>
 #include <__functional/default_searcher.h>
 #include <__functional/function.h>
 #include <__functional/hash.h>
 #include <__functional/identity.h>
 #include <__functional/invoke.h>
 #include <__functional/mem_fn.h> // TODO: deprecate
 #include <__functional/mem_fun_ref.h>
 #include <__functional/not_fn.h>
 #include <__functional/operations.h>
 #include <__functional/pointer_to_binary_function.h>
 #include <__functional/pointer_to_unary_function.h>
 #include <__functional/ranges_operations.h>
 #include <__functional/reference_wrapper.h>
 #include <__functional/unary_function.h> // TODO: deprecate
 #include <__functional/unary_negate.h>
 #include <__functional/unwrap_ref.h>
-#include <__utility/forward.h>
-#include <concepts>
-#include <exception>
-#include <memory>
-#include <tuple>
-#include <type_traits>
-#include <typeinfo>
+
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_FUNCTIONAL

libcxx/include/iterator

 template <class E> constexpr const E* data(initializer_list<E> il) noexcept;      // C++17
 
 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
-#include <__functional_base>
 #include <__iterator/advance.h>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/concepts.h>
 #include <__iterator/default_sentinel.h>
 #include <__iterator/front_insert_iterator.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/insert_iterator.h>
 #include <__iterator/istream_iterator.h>

libcxx/include/map

 
 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
 #include <__functional/is_transparent.h>
+#include <__functional/binary_function.h>
+#include <__functional/operations.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/memory

 
 void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
 
 }  // std
 
 */
 
 #include <__config>
-#include <__functional_base>
 #include <__memory/addressof.h>
 #include <__memory/allocation_guard.h>
 #include <__memory/allocator.h>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/construct_at.h>
 #include <__memory/pointer_safety.h>

libcxx/include/module.modulemap

module std [system] {
   }
   module functional {
     header "functional"
     export *
 
     module __functional {
       module binary_function            { header "__functional/binary_function.h" }
       module binary_negate              { header "__functional/binary_negate.h" }
-      module bind                       { header "__functional/bind.h" }
+      module bind {
+        export typeinfo // TODO: investigate whether this is necessary or a hack
+                        //       (requires in-depth knowledge of `std::bind`)
+        header "__functional/bind.h"
+      }
       module bind_front                 { header "__functional/bind_front.h" }
       module binder1st                  { header "__functional/binder1st.h" }
       module binder2nd                  { header "__functional/binder2nd.h" }
       module default_searcher           { header "__functional/default_searcher.h" }
       module function                   { header "__functional/function.h" }
       module hash                       { header "__functional/hash.h" }
       module identity                   { header "__functional/identity.h" }
       module invoke                     { header "__functional/invoke.h" }

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>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/numeric

template<class T>
     constexpr T* midpoint(T* a, T* b);        // C++20
 
 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
+#include <__functional/operations.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_base>
+#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/operations.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/operations.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/string

 basic_string<char32_t> operator "" s( const char32_t *str, size_t len ); // C++14
 
 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
-#include <__functional_base>
+#include <__functional/hash.h>
+#include <__functional/unary_function.h>
 #include <__iterator/wrap_iter.h>
 #include <__utility/move.h>
 #include <algorithm>
 #include <compare>
 #include <cstdio>  // EOF
 #include <cstring>
 #include <cwchar>
 #include <initializer_list>

libcxx/include/string_view

 
 }  // namespace std
 
 
 */
 
 #include <__config>
 #include <__debug>
+#include <__functional/hash.h>
+#include <__functional/unary_function.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__string>
 #include <algorithm>
 #include <compare>
 #include <iosfwd>
 #include <iterator>
 #include <limits>

libcxx/include/system_error

 
 }  // std
 
 */
 
 #include <__config>
 #include <__errc>
 #include <__functional/unary_function.h>
-#include <__functional_base>
 #include <compare>
 #include <stdexcept>
 #include <string>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif

libcxx/include/thread

 }  // this_thread
 
 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
-#include <__functional_base>
 #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/tuple

template <class... Types>
   swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(noexcept(x.swap(y)));
 
 }  // std
 
 */
 
 #include <__config>
 #include <__functional/unwrap_ref.h>
-#include <__functional_base>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/uses_allocator.h>
 #include <__tuple>
 #include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/piecewise_construct.h>
+#include <__utility/swap.h>
 #include <compare>
 #include <cstddef>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif

libcxx/include/typeindex

 };
 
 }  // std
 
 */
 
 #include <__config>
 #include <__functional/unary_function.h>
-#include <__functional_base>
 #include <compare>
 #include <typeinfo>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/unordered_map

operator!=(const unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
                const unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
 
 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
+#include <__functional/hash.h>
 #include <__functional/is_transparent.h>
+#include <__functional/operations.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

template <class Value, class Hash, class Pred, class Alloc>
     operator!=(const unordered_multiset<Value, Hash, Pred, Alloc>& x,
                const unordered_multiset<Value, Hash, Pred, Alloc>& y);
 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
+#include <__functional/hash.h>
 #include <__functional/is_transparent.h>
+#include <__functional/operations.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/operations.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/hash.h>
+#include <__functional/operations.h>
+#include <__functional/unary_function.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/include/vector

 
 }  // std
 
 */
 
 #include <__config>
 #include <__bit_reference>
 #include <__debug>
-#include <__functional_base>
+#include <__functional/hash.h>
+#include <__functional/unary_function.h>
 #include <__iterator/wrap_iter.h>
 #include <__split_buffer>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <algorithm>
 #include <climits>
 #include <compare>
 #include <cstring>

libcxx/test/libcxx/depr/depr.function.objects/depr.adaptors.cxx1z.pass.cpp

 //  However, for backwards compatibility, if _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
 //  is defined before including <functional>, then they will be restored.
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 #include <functional>
 #include <cassert>
+#include <type_traits>
 
 #include "test_macros.h"
 
 int identity(int v) { return v; }
 int sum(int a, int b) { return a + b; }
 
 struct Foo {
   int zero() { return 0; }

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/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp

 //   6) All types that dereference to T or a type derived from T can be used
 //      as the call object.
 //   7) Pointers to T or a type derived from T can be used as the call object.
 //   8) reference_wrapper's are properly unwrapped before invoking the function.
 
 #include <functional>
 #include <type_traits>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 #include "invoke_helpers.h"
 
 template <class Tp>
 struct TestMemberObject {
     TestMemberObject() : object() {}
     Tp object;

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.cons/deduct.pass.cpp

 // template <class InputIterator, class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
 //    forward_list(InputIterator, InputIterator, Allocator = Allocator())
 //    -> forward_list<typename iterator_traits<InputIterator>::value_type, Allocator>;
 //
 
 
 #include <forward_list>
 #include <iterator>
+#include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <climits> // INT_MAX
+#include <type_traits>
 
 #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/ranges/range.adaptors/range.drop/dangling.cache.pass.cpp

 // UNSUPPORTED: gcc-10
 
 // If we have a copy-propagating cache, when we copy ZeroOnDestroy, we will get a
 // dangling reference to the copied-from object. This test ensures that we do not
 // propagate the cache on copy.
 
 #include <ranges>
 
+#include <cstring>
+
 #include "test_macros.h"
 #include "types.h"
 
 struct ZeroOnDestroy : std::ranges::view_base {
   unsigned count = 0;
   int buff[8] = {1, 2, 3, 4, 5, 6, 7, 8};
 
   constexpr ForwardIter begin() { return ForwardIter(buff); }

libcxx/test/std/re/re.results/re.results.const/copy_assign.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
 //
 //===----------------------------------------------------------------------===//
 
 // <regex>
 
 // class match_results<BidirectionalIterator, Allocator>
 
 // match_results& operator=(const match_results& m);
 
 #include <regex>
 #include <cassert>
+#include <memory>
+#include <type_traits>
 #include "test_macros.h"
 #include "test_allocator.h"
 
 template <class CharT, class Allocator>
 void
 test(const Allocator& a)
 {
     typedef std::match_results<const CharT*, Allocator> SM;

libcxx/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/bind_return_type.pass.cpp

 
 // Check that the call operators have the proper return type and that they
 // only SFINAE away when too few arguments are provided. Otherwise they should
 // be well formed and should ignore any additional arguments.
 
 #include <functional>
 #include <type_traits>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 
 int dummy = 42;
 
 int return_value(int) { return dummy; }
 int& return_lvalue(int) { return dummy; }
 const int& return_const_lvalue(int) { return dummy; }

libcxx/test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp

 //   unspecified bind(Fn, Types...);
 // template<Returnable R, CopyConstructible Fn, CopyConstructible... Types>
 //   unspecified bind(Fn, Types...);
 
 // https://llvm.org/PR22003
 
 #include <functional>
 
+#include <type_traits>
+
 #include "test_macros.h"
 
 struct DummyUnaryFunction
 {
     template <typename S>
     int operator()(S const &) const { return 0; }
 };
 

libcxx/test/std/utilities/function.objects/func.identity/identity.pass.cpp

 // UNSUPPORTED: libcpp-no-concepts
 
 // struct identity;
 
 #include <functional>
 
 #include <cassert>
 #include <concepts>
+#include <utility>
 
 #include "MoveOnly.h"
 
 static_assert(std::semiregular<std::identity>);
 static_assert(requires { typename std::identity::is_transparent; });
 
 constexpr bool test() {
   std::identity id;

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.badcall/bad_function_call.pass.cpp

 //     : public exception
 // {
 // public:
 //   // 20.7.16.1.1, constructor:
 //   bad_function_call();
 // };
 
 #include <functional>
+#include <exception>
 #include <type_traits>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     static_assert((std::is_base_of<std::exception, std::bad_function_call>::value), "");
 
   return 0;
 }

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_incomplete.pass.cpp

 
 // Allow incomplete argument types in the __is_callable check
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 #include <functional>
 #include <cassert>
+#include <type_traits>
 
 #include "test_macros.h"
 
 struct X{
     typedef std::function<void(X&)> callback_type;
     virtual ~X() {}
 private:
     callback_type _cb;

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.verify.cpp

 // class function<R(ArgTypes...)>
 
 // template<class F, class A> function(allocator_arg_t, const A&, F);
 //
 // This signature was removed in C++17
 
 #include <functional>
 #include <cassert>
+#include <memory>
 
 #include "test_macros.h"
 
 void foo(int) {}
 
 int main(int, char**)
 {
     std::function<void(int)> f(std::allocator_arg, std::allocator<int>(), foo); // expected-error {{no matching constructor for initialization of}}
     return 0;
 }

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.verify.cpp

 // class function<R(ArgTypes...)>
 
 // template<class A> function(allocator_arg_t, const A&, const function&);
 //
 // This signature was removed in C++17
 
 #include <functional>
 #include <cassert>
+#include <memory>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     typedef std::function<void(int)> F;
     F f1;
     F f2(std::allocator_arg, std::allocator<int>(), f1); // expected-error {{no matching constructor for initialization of}}
     return 0;
 }

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp

 
 // function& operator=(const function& f);
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 #include <functional>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 #include "count_new.h"
 
 class A {
   int data_[10];
 
 public:

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/noncopyable_return_type.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
 
 // XFAIL: LIBCXX-WINDOWS-FIXME
 
 // <functional>
 
 #include <functional>
 #include <cassert>
+#include <type_traits>
 
 #include "test_macros.h"
 
 // Prevent warning on the `const NonCopyable()` function type.
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic ignored "-Wignored-qualifiers"
 #endif
 

libcxx/test/std/utilities/function.objects/range.cmp/equal_to.pass.cpp

 
 // <functional>
 
 // ranges::equal_to
 
 #include <functional>
 #include <type_traits>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 #include "compare_types.h"
 #include "MoveOnly.h"
 #include "pointer_comparison_test_helper.h"
 
 struct NotEqualityComparable {
   friend bool operator==(const NotEqualityComparable&, const NotEqualityComparable&);

libcxx/test/std/utilities/function.objects/range.cmp/greater.pass.cpp

 
 // <functional>
 
 // ranges::greater
 
 #include <functional>
 #include <type_traits>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 #include "compare_types.h"
 #include "MoveOnly.h"
 #include "pointer_comparison_test_helper.h"
 
 struct NotTotallyOrdered {
   friend bool operator<(const NotTotallyOrdered&, const NotTotallyOrdered&);

libcxx/test/std/utilities/function.objects/range.cmp/greater_equal.pass.cpp

 
 // <functional>
 
 // ranges::greater_equal
 
 #include <functional>
 #include <type_traits>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 #include "compare_types.h"
 #include "MoveOnly.h"
 #include "pointer_comparison_test_helper.h"
 
 struct NotTotallyOrdered {
   friend bool operator<(const NotTotallyOrdered&, const NotTotallyOrdered&);

libcxx/test/std/utilities/function.objects/range.cmp/less.pass.cpp

 
 // <functional>
 
 // ranges::less
 
 #include <functional>
 #include <type_traits>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 #include "compare_types.h"
 #include "MoveOnly.h"
 #include "pointer_comparison_test_helper.h"
 
 struct NotTotallyOrdered {
   friend bool operator<(const NotTotallyOrdered&, const NotTotallyOrdered&);

libcxx/test/std/utilities/function.objects/range.cmp/less_equal.pass.cpp

 
 // <functional>
 
 // ranges::less_equal
 
 #include <functional>
 #include <type_traits>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 #include "compare_types.h"
 #include "MoveOnly.h"
 #include "pointer_comparison_test_helper.h"
 
 struct NotTotallyOrdered {
   friend bool operator<(const NotTotallyOrdered&, const NotTotallyOrdered&);

libcxx/test/std/utilities/function.objects/range.cmp/not_equal_to.pass.cpp

 
 // <functional>
 
 // ranges::not_equal_to
 
 #include <functional>
 #include <type_traits>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 #include "compare_types.h"
 #include "MoveOnly.h"
 #include "pointer_comparison_test_helper.h"
 
 struct NotEqualityComparable {
   friend bool operator==(const NotEqualityComparable&, const NotEqualityComparable&);

libcxx/test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // reference_wrapper
 
 // reference_wrapper& operator=(const reference_wrapper<T>& x);
 
 #include <functional>
 #include <cassert>
+#include <type_traits>
 
 #include "test_macros.h"
 
 class functor1
 {
 };
 
 struct convertible_to_int_ref {

libcxx/test/std/utilities/function.objects/refwrap/refwrap.const/deduct.pass.cpp

 
 // <functional>
 
 // template <class T>
 //   reference_wrapper(T&) -> reference_wrapper<T>;
 
 #include <functional>
 
+#include <type_traits>
+
 int main()
 {
     int i = 0;
     std::reference_wrapper ri(i);
     static_assert(std::is_same_v<decltype(ri), std::reference_wrapper<int>>);
     std::reference_wrapper ri2(ri);
     static_assert(std::is_same_v<decltype(ri2), std::reference_wrapper<int>>);
     const int j = 0;
     std::reference_wrapper rj(j);
     static_assert(std::is_same_v<decltype(rj), std::reference_wrapper<const int>>);
     std::reference_wrapper rj2(rj);
     static_assert(std::is_same_v<decltype(rj2), std::reference_wrapper<const int>>);
 }

libcxx/test/std/utilities/function.objects/refwrap/refwrap.const/type_conv_ctor.pass.cpp

 //
 // reference_wrapper
 //
 // template <class U>
 //   reference_wrapper(U&&) noexcept(see below);
 
 #include <functional>
 #include <cassert>
+#include <type_traits>
 
 struct convertible_to_int_ref {
     int val = 0;
     operator int&() { return val; }
     operator int const&() const { return val; }
 };
 
 template <bool IsNothrow>

libcxx/test/std/utilities/function.objects/refwrap/refwrap.const/type_conv_ctor2.pass.cpp

 //
 // reference_wrapper
 //
 // template <class U>
 //   reference_wrapper(U&&);
 
 #include <functional>
 #include <cassert>
+#include <type_traits>
 
 #include "test_macros.h"
 
 struct B {} b;
 
 struct A1 {
     operator B& () const { return b; }
 };

libcxx/test/std/utilities/function.objects/unord.hash/enum.pass.cpp

 
 // make sure that we can hash enumeration values
 // Not very portable
 
 #include "test_macros.h"
 
 #include <functional>
 #include <cassert>
+#include <cstdint>
 #include <type_traits>
 #include <limits>
 
 enum class Colors { red, orange, yellow, green, blue, indigo, violet };
 enum class Cardinals { zero, one, two, three, five=5 };
 enum class LongColors : short { red, orange, yellow, green, blue, indigo, violet };
 enum class ShortColors : long { red, orange, yellow, green, blue, indigo, violet };
 enum class EightBitColors : uint8_t { red, orange, yellow, green, blue, indigo, violet };

libcxx/test/std/utilities/function.objects/unord.hash/integral.pass.cpp

 // {
 //     size_t operator()(T val) const;
 // };
 
 #include <functional>
 #include <cassert>
 #include <type_traits>
 #include <cstddef>
+#include <cstdint>
 #include <limits>
 
 #include "test_macros.h"
 
 template <class T>
 void
 test()
 {

libcxx/test/std/utilities/optional/optional.hash/enabled_hash.pass.cpp

 
 // <optional>
 
 // Test that <optional> provides all of the arithmetic, enum, and pointer
 // hash specializations.
 
 #include <optional>
 
+#include <functional>
+
 #include "poisoned_hash_helper.h"
 
 #include "test_macros.h"
 
 int main(int, char**) {
   test_library_hash_specializations_available();
   {
 
   }
 
   return 0;
 }

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/tuple/tuple.tuple/tuple.cnstr/alloc_UTypes.pass.cpp

 
 // template <class Alloc, class... UTypes>
 //   tuple(allocator_arg_t, const Alloc& a, UTypes&&...);
 
 // UNSUPPORTED: c++03
 
 #include <tuple>
 #include <cassert>
+#include <memory>
 
 #include "test_macros.h"
 #include "MoveOnly.h"
 #include "allocators.h"
 #include "../alloc_first.h"
 #include "../alloc_last.h"
 
 template <class T = void>

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move.pass.cpp

 
 // tuple(tuple&& u);
 
 // UNSUPPORTED: c++03
 
 #include <tuple>
 #include <utility>
 #include <cassert>
+#include <memory>
 
 #include "test_macros.h"
 #include "MoveOnly.h"
 
 struct ConstructsWithTupleLeaf
 {
     ConstructsWithTupleLeaf() {}
 

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;