[libc++] Granularize <utility> includes

[• Quuxplusone]

libcxx/include/vector

311

As in the previous PR, please do the removal of these lines in a separate commit (and optionally in a whole separate PR). Because adding #include <__utility/move.h> probably can't break anything, and adding #include <utility> to some tests can't break anything, but removing #include <utility> from existing headers like <vector> and <typeindex> can definitely break users, and if they complain we might want to git revert just that one part. So it should be isolated in its own commit.

Actually, looking at your changes in <variant>, it seems like you intended to do what I'm saying here, and this diff just slipped through the cracks? I think what you did in <variant>, adding a line #include <utility> // TODO: Remove this, is good.

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.ranges.pass.cpp

18–19 ↗

(On Diff #411045)

This is an interesting case. @var-const, this was your test originally, right? Does including <tuple> here nerf the point of this test? IIRC, you wanted the point of the test to be

• Including <ranges> makes a declaration of std::tuple_element available.

Whereas I'm personally happy with scaling that back to

• Including <ranges> makes structured binding work. (If the library user intends to refer to std::tuple_element by name, they should #include <tuple>.)

So I would personally approve of adding #include <tuple> here, and then also remove the comment on lines 20-21. But if the point of the test is the first bullet above, then adding new #includes to this file seems like a bad idea.

[Mordante]

libcxx/include/vector

311

+1
Also please update the release notes in the removal PR.

[EricWF]

I know I'm late to the party on this, but is there a document explaining the benefits of modularizing the headers? Cuz I see a bunch of downsides to it. The most recent of which I ran into was diagnostic error messages. I'm almost certain it's a lot slower to hit the file system this many times too. It also causes the compiler to emit incorrect Fix i suggestions?

If there isn't a document describing this, we need one.

[philnik]

• Address comments

[philnik]

Rebased

[var-const]

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.ranges.pass.cpp

18–19 ↗

(On Diff #411045)

Thanks for the heads-up!

I think this file should be left unchanged. Adding this include is unnecessary, defeats (a part of) the purpose of the test and doesn't seem to be related to the main intention of this patch.

If the library user intends to refer to std::tuple_element by name, they should #include <tuple>.

If I understand the Standard correctly, it explicitly says that including <ranges> should be enough for this case. It can be argued that user code might not want to rely on this subtle detail, but nevertheless it should work.

[EricWF]

Do we have a document describing why we're doing this?

[ldionne]

In D120466#3351831, @EricWF wrote:

Do we have a document describing why we're doing this?

Eric, we've been doing this for roughly 1 year now. Arthur has already explained some of the reasons to you, like reducing/removing circular dependencies and being easier to understand (now you don't have to wonder why in the world is std::swap defined in <type_traits>. As a side benefit, it also makes our headers include fewer things transitively, which enforces slightly better IWYU for users.

Regarding compile-times: the right way to speed things up is to use modules and have more minimal headers, not to try to reduce the number of filesystem accesses by reducing the number of files.
Regarding diagnostics, I'm not sure how they are really made worse by this. If we wanted, we could also piggy-back on the include_instead pragma to tweak error messages. Clang fix-it should definitely listen to include_instead, at the very least.

[philnik]

• Address comments

[EricWF]

In D120466#3352007, @ldionne wrote:

In D120466#3351831, @EricWF wrote:

Do we have a document describing why we're doing this?

Eric, we've been doing this for roughly 1 year now. Arthur has already explained some of the reasons to you, like reducing/removing circular dependencies and being easier to understand (now you don't have to wonder why in the world is std::swap defined in <type_traits>. As a side benefit, it also makes our headers include fewer things transitively, which enforces slightly better IWYU for users.

Cool. I'm suprised we don't have a document describing why we're doing it. And I would like one. I was unaware of circular dependencies prior to this change. And I personally don't find it easier to understand. The "side benefit" of including fewer things will break our users, and at Google IWYU has been adding includes for internal headers (which is not good).

Regarding compile-times: the right way to speed things up is to use modules and have more minimal headers, not to try to reduce the number of filesystem accesses by reducing the number of files.

The right way to speed up compile times is the way that speeds up compile times. Measurement is key.

Regarding diagnostics, I'm not sure how they are really made worse by this. If we wanted, we could also piggy-back on the include_instead pragma to tweak error messages. Clang fix-it should definitely listen to include_instead, at the very least.

When the compiler tells you to include the wrong header, or diagnostics expose implementation details (and hide what user-visible component is responsible for the breakage); it's not good for our users.

I'm not interested in litigating this. I am interested in documenting the rational for doing it. With concrete examples of how it makes the code better. I'm going to stand firm on this. We NEED to document large design decisions like this.

[var-const]

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.ranges.pass.cpp

20 ↗

(On Diff #412417)

Looks like this line needs to be restored as well.

[philnik]

• Address comment

[ldionne]

LGTM when CI passes. I think everybody's comments have been addressed now, except for @EricWF 's request for a design document. I spoke with Eric offline and explained why we were doing this, and why we didn't have a design document (TLDR we had Discord discussions about this and all ended up agreeing on the direction, but we didn't record it formally in a design doc). I think a design doc explaining the rationale for this change is a fair ask, however we can address it separately and I don't think this specific patch should be blocked on that task.

libcxx/include/__algorithm/rotate.h

 
 #include <__algorithm/move.h>
 #include <__algorithm/move_backward.h>
 #include <__algorithm/swap_ranges.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/next.h>
 #include <__iterator/prev.h>
+#include <__utility/move.h>
 #include <__utility/swap.h>
 #include <iterator>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__format/formatter.h

 #include <__algorithm/transform.h>
 #include <__assert>
 #include <__availability>
 #include <__config>
 #include <__format/format_error.h>
 #include <__format/format_fwd.h>
 #include <__format/format_string.h>
 #include <__format/parser_std_format_spec.h>
+#include <__utility/move.h>
 #include <__utility/unreachable.h>
 #include <string_view>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__functional/function.h

 #include <__functional/unary_function.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/shared_ptr.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
+#include <__utility/swap.h>
 #include <exception>
 #include <memory> // TODO: replace with <__memory/__builtin_new_allocator.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/__hash_table

 
 #include <__algorithm/max.h>
 #include <__algorithm/min.h>
 #include <__assert>
 #include <__bits> // __libcpp_clz
 #include <__config>
 #include <__debug>
 #include <__functional/hash.h>
+#include <__utility/swap.h>
 #include <cmath>
 #include <initializer_list>
 #include <iterator>
 #include <memory>
 #include <type_traits>
-#include <utility>
+
+#include <utility> // TODO: Remove this
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__locale

 #include <__availability>
 #include <__config>
 #include <cctype>
 #include <cstdint>
 #include <locale.h>
 #include <memory>
 #include <mutex>
 #include <string>
-#include <utility>
+
+#include <utility> // TODO: Remove this
 
 #if defined(_LIBCPP_MSVCRT_LIKE)
 # include <__support/win32/locale_win32.h>
 # include <cstring>
 #elif defined(_AIX) || defined(__MVS__)
 # include <__support/ibm/xlocale.h>
 #elif defined(__ANDROID__)
 # include <__support/android/locale_bionic.h>

libcxx/include/__memory/shared_ptr.h

 #include <__memory/allocation_guard.h>
 #include <__memory/allocator.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/unique_ptr.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
+#include <__utility/swap.h>
 #include <cstddef>
 #include <cstdlib> // abort
 #include <iosfwd>
 #include <stdexcept>
 #include <type_traits>
 #include <typeinfo>
 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 #  include <atomic>

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/swap.h>
 #include <iterator>
 #include <limits>
 #include <memory>
 #include <stdexcept>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/algorithm

 #include <__debug>
 #include <cstddef>
 #include <cstring>
 #include <functional>
 #include <initializer_list>
 #include <iterator>
 #include <memory>
 #include <type_traits>
-#include <utility>
 #include <version>
 
+#include <utility> // TODO: Remove this
+
 #include <__algorithm/adjacent_find.h>
 #include <__algorithm/all_of.h>
 #include <__algorithm/any_of.h>
 #include <__algorithm/binary_search.h>
 #include <__algorithm/clamp.h>
 #include <__algorithm/comp.h>
 #include <__algorithm/comp_ref_type.h>
 #include <__algorithm/copy.h>

libcxx/include/any

 
 } // namespace std
 
 */
 
 #include <__availability>
 #include <__config>
 #include <__utility/forward.h>
+#include <__utility/in_place.h>
+#include <__utility/move.h>
 #include <cstdlib>
 #include <memory>
 #include <type_traits>
 #include <typeinfo>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

libcxx/include/array

 
 #include <__algorithm/equal.h>
 #include <__algorithm/fill_n.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/swap_ranges.h>
 #include <__assert>
 #include <__config>
 #include <__tuple>
+#include <__utility/integer_sequence.h>
+#include <__utility/move.h>
 #include <__utility/unreachable.h>
 #include <iterator>
 #include <stdexcept>
 #include <type_traits>
-#include <utility>
 #include <version>
 
+#include <utility> // TODO: Remove this
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp, size_t _Size>
 struct _LIBCPP_TEMPLATE_VIS array

libcxx/include/deque

 #include <__algorithm/remove.h>
 #include <__algorithm/remove_if.h>
 #include <__algorithm/unwrap_iter.h>
 #include <__assert>
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__split_buffer>
 #include <__utility/forward.h>
+#include <__utility/move.h>
+#include <__utility/swap.h>
 #include <compare>
 #include <initializer_list>
 #include <iterator>
 #include <limits>
 #include <stdexcept>
 #include <type_traits>
 #include <version>
 

libcxx/include/experimental/memory_resource

 } // namespace fundamentals_v1
 } // namespace experimental
 } // namespace std
 
  */
 
 #include <__assert>
 #include <__tuple>
+#include <__utility/move.h>
 #include <cstddef>
 #include <cstdlib>
 #include <experimental/__config>
 #include <experimental/__memory>
 #include <limits>
 #include <memory>
 #include <new>
 #include <stdexcept>
 #include <type_traits>
-#include <utility>
+
+#include <utility> // TODO: Remove this
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/experimental/propagate_const

/*
   template <class T> struct greater<experimental::fundamentals_v2::propagate_const<T>>;
   template <class T> struct less_equal<experimental::fundamentals_v2::propagate_const<T>>;
   template <class T> struct greater_equal<experimental::fundamentals_v2::propagate_const<T>>;
 
 } // namespace std
 
 */
 
+#include <__utility/move.h>
+#include <__utility/swap.h>
 #include <experimental/__config>
 #include <functional>
 #include <type_traits>
-#include <utility>
+
+#include <utility> // TODO: Remove this
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 11
 
 _LIBCPP_BEGIN_NAMESPACE_LFTS_V2

libcxx/include/fstream

 
 */
 
 #include <__algorithm/max.h>
 #include <__assert>
 #include <__availability>
 #include <__config>
 #include <__locale>
+#include <__utility/move.h>
+#include <__utility/swap.h>
 #include <__utility/unreachable.h>
 #include <cstdio>
 #include <cstdlib>
+#include <cstring>
 #include <istream>
 #include <ostream>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
 #   include <filesystem>
 #endif
 

libcxx/include/functional

 #include <__functional/unwrap_ref.h>
 #include <__utility/forward.h>
 #include <concepts>
 #include <exception>
 #include <memory>
 #include <tuple>
 #include <type_traits>
 #include <typeinfo>
-#include <utility>
 #include <version>
 
+#include <utility> // TODO: Remove this
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_FUNCTIONAL

libcxx/include/future

 #include <__availability>
 #include <__chrono/duration.h>
 #include <__chrono/time_point.h>
 #include <__config>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/uses_allocator.h>
 #include <__utility/auto_cast.h>
 #include <__utility/forward.h>
+#include <__utility/move.h>
 #include <exception>
 #include <memory>
 #include <mutex>
 #include <system_error>
 #include <thread>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/ios

 
 }  // std
 
 */
 
 #include <__config>
 #include <__ios/fpos.h>
 #include <__locale>
+#include <__utility/swap.h>
 #include <iosfwd>
 #include <system_error>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 #include <atomic>     // for __xindex_
 #endif
 

libcxx/include/iterator

 #include <__iterator/wrap_iter.h>
 #include <__memory/addressof.h>
 #include <__memory/pointer_traits.h>
 #include <compare>
 #include <concepts> // Mandated by the Standard.
 #include <cstddef>
 #include <initializer_list>
 #include <type_traits>
-#include <utility>
 #include <version>
 
+#include <utility> // TODO: Remove this
+
 // 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>

libcxx/include/list

 #include <__algorithm/comp.h>
 #include <__algorithm/equal.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/min.h>
 #include <__assert>
 #include <__config>
 #include <__debug>
 #include <__utility/forward.h>
+#include <__utility/move.h>
+#include <__utility/swap.h>
 #include <initializer_list>
 #include <iterator>
 #include <limits>
 #include <memory>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/map

 #include <__algorithm/lexicographical_compare.h>
 #include <__assert>
 #include <__config>
 #include <__functional/is_transparent.h>
 #include <__iterator/iterator_traits.h>
 #include <__node_handle>
 #include <__tree>
 #include <__utility/forward.h>
+#include <__utility/swap.h>
 #include <compare>
 #include <functional>
 #include <initializer_list>
 #include <iterator> // __libcpp_erase_if_container
 #include <memory>
 #include <type_traits>
-#include <utility>
 #include <version>
 
+#include <utility> // TODO: Remove this
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Key, class _CP, class _Compare,
           bool = is_empty<_Compare>::value && !__libcpp_is_final<_Compare>::value>

libcxx/include/memory

 #include <cstring>
 #include <iosfwd>
 #include <iterator>
 #include <new>
 #include <stdexcept>
 #include <tuple>
 #include <type_traits>
 #include <typeinfo>
-#include <utility>
 #include <version>
 
+#include <utility> // TODO: Remove this
+
 // 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>
 

libcxx/include/optional

 } // namespace std
 
 */
 
 #include <__assert>
 #include <__availability>
 #include <__concepts/invocable.h>
 #include <__config>
+#include <__utility/in_place.h>
+#include <__utility/swap.h>
 #include <compare>
 #include <functional>
 #include <initializer_list>
 #include <new>
 #include <stdexcept>
 #include <type_traits>
-#include <utility>
 #include <version>
 
+#include <utility> // TODO: Remove this
+
 // TODO: remove these headers
 #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/regex

 } // std
 */
 
 #include <__algorithm/find.h>
 #include <__assert>
 #include <__config>
 #include <__iterator/wrap_iter.h>
 #include <__locale>
+#include <__utility/move.h>
+#include <__utility/swap.h>
 #include <compare>
 #include <deque>
 #include <initializer_list>
 #include <iterator>
 #include <memory>
 #include <stdexcept>
 #include <string>
-#include <utility>
 #include <vector>
 #include <version>
 
+#include <utility> // TODO: Remove this
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 

libcxx/include/sstream

 typedef basic_stringstream<char>    stringstream;
 typedef basic_stringstream<wchar_t> wstringstream;
 
 }  // std
 
 */
 
 #include <__config>
+#include <__utility/swap.h>
 #include <istream>
 #include <ostream>
 #include <string>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/string

 #include <__algorithm/min.h>
 #include <__algorithm/remove.h>
 #include <__algorithm/remove_if.h>
 #include <__assert>
 #include <__config>
 #include <__debug>
 #include <__ios/fpos.h>
 #include <__iterator/wrap_iter.h>
+#include <__utility/auto_cast.h>
+#include <__utility/move.h>
+#include <__utility/swap.h>
 #include <compare>
 #include <cstdio>  // EOF
 #include <cstdlib>
 #include <cstring>
 #include <initializer_list>
 #include <iosfwd>
 #include <iterator>
 #include <memory>
 #include <stdexcept>
 #include <string_view>
 #include <type_traits>
-#include <utility>
 #include <version>
 
+#include <utility> // TODO: Remove this
+
 // 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>

libcxx/include/tuple

 #include <__config>
 #include <__functional/unwrap_ref.h>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/uses_allocator.h>
 #include <__tuple>
 #include <__utility/forward.h>
 #include <__utility/integer_sequence.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 <utility>
 #include <version>
 
+#include <utility> // TODO: Remove this
+
 // 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>

libcxx/include/typeindex

 */
 
 #include <__config>
 #include <__functional/unary_function.h>
 #include <compare>
 #include <typeinfo>
 #include <version>
 
+#include <utility> // TODO: Remove this
+
 // 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>
-#include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 class _LIBCPP_TEMPLATE_VIS type_index

libcxx/include/variant

 
 #include <__availability>
 #include <__config>
 #include <__functional/hash.h>
 #include <__functional/operations.h>
 #include <__functional/unary_function.h>
 #include <__tuple>
 #include <__utility/forward.h>
+#include <__utility/in_place.h>
+#include <__utility/move.h>
+#include <__utility/swap.h>
 #include <__variant/monostate.h>
 #include <compare>
 #include <exception>
 #include <initializer_list>
 #include <limits>
 #include <new>
 #include <tuple>
 #include <type_traits>
-#include <utility>
 #include <version>
 
+#include <utility> // TODO: Remove this
+
 // 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>

libcxx/include/vector

 #include <__bit_reference>
 #include <__config>
 #include <__debug>
 #include <__functional/hash.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/wrap_iter.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>
 
+#include <utility> // TODO: Remove this
+
 // 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>
-#include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/test/libcxx/ranges/range.access/end.incomplete_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, c++17
 // UNSUPPORTED: libcpp-no-concepts
 
 // Test the libc++-specific behavior that we handle the IFNDR case for ranges::end
 // by being SFINAE-friendly.
 
-#include <ranges>
 #include <cassert>
+#include <ranges>
 #include <type_traits>
+#include <utility>
 
 struct Incomplete;
 
 constexpr bool test()
 {
     {
     extern Incomplete bounded[10];
     assert((!std::is_invocable_v<decltype(std::ranges::end), decltype((bounded))>));

libcxx/test/std/ranges/range.adaptors/range.drop/ctad.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
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // template<class R>
 //   drop_view(R&&, range_difference_t<R>) -> drop_view<views::all_t<R>>;
 
-#include <ranges>
 #include <cassert>
 #include <concepts>
+#include <ranges>
+#include <utility>
 
 struct View : std::ranges::view_base {
   int *begin() const;
   int *end() const;
 };
 
 struct Range {
   int *begin() const;

libcxx/test/std/ranges/range.adaptors/range.join.view/ctad.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
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // template<class R>
 //   explicit join_view(R&&) -> join_view<views::all_t<R>>;
 
 #include <ranges>
+#include <utility>
 
 struct Child {
   int *begin() const;
   int *end() const;
 };
 
 struct View : std::ranges::view_base {
   Child *begin() const;

libcxx/test/std/ranges/range.adaptors/range.take/ctad.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
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // template<class R>
 //   take_view(R&&, range_difference_t<R>) -> take_view<views::all_t<R>>;
 
-#include <ranges>
 #include <cassert>
 #include <concepts>
+#include <ranges>
+#include <utility>
 
 struct View : std::ranges::view_base {
   int *begin() const;
   int *end() const;
 };
 
 struct Range {
   int *begin() const;

libcxx/test/std/ranges/range.adaptors/range.transform/ctad.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
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // template<class R, class F>
 //   transform_view(R&&, F) -> transform_view<views::all_t<R>, F>;
 
-#include <ranges>
 #include <cassert>
 #include <concepts>
+#include <ranges>
+#include <utility>
 
 struct PlusOne {
     int operator()(int x) const;
 };
 
 struct View : std::ranges::view_base {
   int *begin() const;
   int *end() const;

libcxx/test/std/ranges/range.factories/range.iota.view/begin.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
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // constexpr iterator begin() const;
 
-#include <ranges>
 #include <cassert>
+#include <ranges>
+#include <utility>
 
 #include "test_macros.h"
 #include "types.h"
 
 template<class T>
 constexpr void testType() {
   {
     std::ranges::iota_view<T> io(T(0));

libcxx/test/std/ranges/range.factories/range.iota.view/end.pass.cpp

 #pragma GCC diagnostic ignored "-Wsign-compare"
 #elif defined(TEST_COMPILER_MSVC)
 #pragma warning(disable: 4018 4389) // various "signed/unsigned mismatch"
 #endif
 
 // constexpr auto end() const;
 // constexpr iterator end() const requires same_as<W, Bound>;
 
-#include <ranges>
 #include <cassert>
+#include <ranges>
+#include <utility>
 
 #include "types.h"
 
 template<class T, class U>
 constexpr void testType(U u) {
   {
     std::ranges::iota_view<T, U> io(T(0), u);
     assert(std::ranges::next(io.begin(), 10) == io.end());

libcxx/test/std/ranges/range.factories/range.single.view/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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-11
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // Tests that <value_> is a <copyable-box>.
 
-#include <ranges>
 #include <cassert>
+#include <ranges>
+#include <utility>
 
 #include "test_macros.h"
 
 struct NotAssignable {
   NotAssignable() = default;
   NotAssignable(const NotAssignable&) = default;
   NotAssignable(NotAssignable&&) = default;
 

libcxx/test/std/ranges/range.factories/range.single.view/ctor.in_place.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
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // template<class... Args>
 //   requires constructible_from<T, Args...>
 // constexpr explicit single_view(in_place_t, Args&&... args);
 
-#include <ranges>
 #include <cassert>
+#include <ranges>
+#include <utility>
 
 #include "test_macros.h"
 
 struct TakesTwoInts {
   int a_, b_;
   constexpr TakesTwoInts(int a, int b) : a_(a), b_(b) {}
 };
 

libcxx/test/std/ranges/range.factories/range.single.view/ctor.value.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
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // constexpr explicit single_view(const T& t);
 // constexpr explicit single_view(T&& t);
 
-#include <ranges>
 #include <cassert>
+#include <ranges>
+#include <utility>
 
 #include "test_macros.h"
 
 struct Empty {};
 struct BigType { char buffer[64] = {10}; };
 
 constexpr bool test() {
   {

libcxx/test/std/ranges/range.utility/range.subrange/structured_bindings.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
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // class std::ranges::subrange;
 
+#include <cassert>
 #include <ranges>
+#include <utility>
 
-#include <cassert>
 #include "test_macros.h"
 
 constexpr void test_sized_subrange()
 {
     int a[4] = {1,2,3,4};
     auto r = std::ranges::subrange(a, a+4);
     assert(std::ranges::sized_range<decltype(r)>);
     {

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/optional_U.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
 // <optional>
 
 // template <class U>
 //   optional(optional<U>&& rhs);
 
+#include <cassert>
+#include <memory>
 #include <optional>
 #include <type_traits>
-#include <memory>
-#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)