[libc++] Mark standard-mandated includes as such

[jloser]

This seems reasonable to me. Do you think it's worth adding a test for this behavior to avoid regression in the future, or do you think it's overkill?

[philnik]

• Try to find out what the correct values are on AIX

[philnik]

Upload correct patch

[Mordante]

Thanks for working on this!

In D127953#3588836, @jloser wrote:

This seems reasonable to me. Do you think it's worth adding a test for this behavior to avoid regression in the future, or do you think it's overkill?

I would like that. Maybe we can make automatically generated tests for some parts, like we already do for the feature-test macros.

libcxx/include/array

124

Should we add <version> to the mandatory list too? It provides __cpp_lib_array_constexpr which this header must provide.

127

Since these aren't obvious how do you feel about adding a comment like // [iterator.range]/1 to give a hint why it's needed.

<compare> and <initializer_list> are obvious, so I don't feel to strong about these.

[jloser]

In D127953#3589266, @Mordante wrote:

Thanks for working on this!

In D127953#3588836, @jloser wrote:

This seems reasonable to me. Do you think it's worth adding a test for this behavior to avoid regression in the future, or do you think it's overkill?

I would like that. Maybe we can make automatically generated tests for some parts, like we already do for the feature-test macros.

Yeah, that's along the lines of what I was thinking for the (proposed) generated test for this sort of thing. I'd be in favor of that direction as it yields long-term value IMO.

[MaskRay]

How about mentioning D127675 in the summary (commit message)?

[saugustine]

It would be good to get this committed, as it fixes a previous break of otherwise correct source code and therefore anything testing against libc++ top of trunk.

[philnik]

• Address comments

[philnik]

@jloser @Mordante Do you have suggestions for how such a test would look like? I don't think it's feasible to check for every symbol that should be provided for each header and checking that header X is included in Y sounds a bit fragile to me.

libcxx/include/array

124

I don't think we want to add <version> because it provides more than by the standard required. We might want to only add the macros needed for each header in them, like libstdc++ and the MSVC STL do. (Although that's not very high on my priority list)

127

I think it's a good idea to say which section mandates them. Added comments for all headers.

[saugustine]

I can't speak to the testing issues--perhaps it would be good to add them in a subsequent change. But getting correct code working again would be really good, and what is here addresses that.

[Mordante]

In D127953#3590508, @saugustine wrote:

I can't speak to the testing issues--perhaps it would be good to add them in a subsequent change. But getting correct code working again would be really good, and what is here addresses that.

Agreed it was not my intention to block this review until there are tests. But it's good to think about how we can prevent this from happening in the future.

In D127953#3590246, @philnik wrote:

@jloser @Mordante Do you have suggestions for how such a test would look like? I don't think it's feasible to check for every symbol that should be provided for each header and checking that header X is included in Y sounds a bit fragile to me.

I don't think we need to test everything. But for initializer list just that an std::initializer<int> is valid, something similar for operator<=>. For the containers we can probably craft something that creates a container<T> and validates whether std::size, std::ssize etc. works. I think these can be compile tests without looking at the results.

There's one nice to have comment, otherwise LGTM! Thanks for the fix and improvement!

libcxx/include/array

124

I still think it would be nice, but I don't feel to strong about it. Especially since the CI validates whether the required includes are available.

127

Thanks!

libcxx/include/coroutine

50

I think it would be nice for these too, but they are not as "hidden" as the partial iterator requirements.

[ldionne]

Let's land this. I think it's somewhat difficult to test this properly, so I'm fine as-is.

[JamesNagurne]

I'm curious about how we handle proposals in the working group.

https://cplusplus.github.io/LWG/issue3378

Suggests that some of the same language applies to the tuple helpers when including array, etc. Some industry-standard conformance tests are checking for the behavior defined in issue 3378.

[Mordante]

In D127953#3609091, @JamesNagurne wrote:

I'm curious about how we handle proposals in the working group.

https://cplusplus.github.io/LWG/issue3378

Suggests that some of the same language applies to the tuple helpers when including array, etc. Some industry-standard conformance tests are checking for the behavior defined in issue 3378.

Usually we wait for an LWG issue to be accepted by the committee before implementing them. An issue might be closed as NAD or get a different resolution as proposed. I'm a bit surprised that a standard conformance test is testing for something not in the WP yet.

Just curious which tool flags this?

[JamesNagurne]

In D127953#3610109, @Mordante wrote:

Usually we wait for an LWG issue to be accepted by the committee before implementing them. An issue might be closed as NAD or get a different resolution as proposed. I'm a bit surprised that a standard conformance test is testing for something not in the WP yet.

Just curious which tool flags this?

I'm not precisely sure what you mean by 'which tool', but here's a reproduction using a cut-down reproduction of the standard test using clang trunk with libc++

https://godbolt.org/z/jYs7Pz8qj

Note that the proposal, adds the following clause to tuple.helper

"In addition to being available via inclusion of the <tuple> header, the entities defined in this subclause [tuple.helper] are available when any of the headers <array> (24.3.2 [array.syn]), <ranges> (26.2 [ranges.syn]), <span> (24.7.2 [span.syn]), or <utility> (22.2.1 [utility.syn]) are included."

I can see why the standards body received this request. Since array, pair, etc. also have tuple_size specializations, it's very similar in reasoning to including iterator helpers for STL containers that support iterators.
We currently have a request for comment out to the company providing the test suite, and don't really require upstream changes as we're capable of excluding the test(s) until such time that the issue is either resolved or rejected. I just wondered if there was a process in place for such things, since I can't imagine my team being the only ones using popular standard conformance test suites.

As an aside, I apologize for being vague about the actual suite. I'm not entirely sure what our license says about providing that information to external parties.

[Mordante]

In D127953#3610485, @JamesNagurne wrote:

In D127953#3610109, @Mordante wrote:

I'm not precisely sure what you mean by 'which tool', but here's a reproduction using a cut-down reproduction of the standard test using clang trunk with libc++

https://godbolt.org/z/jYs7Pz8qj

The example you provided is rightly rejected. You use std::pair, which is provided by <utility>. The standard doesn't require <array> to include <utility>. The example also fails without using std::tuple_size:

https://godbolt.org/z/Excc13Gs6

Using the required header instead works:

https://godbolt.org/z/7xYb645Ys

Alternatively if you intended to get the std::tuple_size of std::array that works when only using <array>:

https://godbolt.org/z/ror9n16vG

Note that the proposal, adds the following clause to tuple.helper

I can see why the standards body received this request. Since array, pair, etc. also have tuple_size specializations, it's very similar in reasoning to including iterator helpers for STL containers that support iterators.

I'm not saying the LWG issue isn't valid. I've glossed over it and it seems sensible.
I just explained what the normal libc++ procedure is.

As an aside, I apologize for being vague about the actual suite. I'm not entirely sure what our license says about providing that information to external parties.

I can understand that. But not being able to provide that information makes it harder for me to understand what the real issue is.

[JamesNagurne]

Interesting, I didn't catch that; so the test is even more contrived than I had first thought! I wonder if their interpretation is that all of the specializations should be available when any header referenced in the issue is included. That's certainly something that's not very sensible.

You've fairly answered my question on the process, and thank you for the continued discussion as well. I'll wait for the response from the test suite writers and forward their thoughts through discourse or a followup diff if there's anything interesting to discuss more.

Thanks and regards.

[Mordante]

In D127953#3611215, @JamesNagurne wrote:

Interesting, I didn't catch that; so the test is even more contrived than I had first thought! I wonder if their interpretation is that all of the specializations should be available when any header referenced in the issue is included. That's certainly something that's not very sensible.

You've fairly answered my question on the process, and thank you for the continued discussion as well. I'll wait for the response from the test suite writers and forward their thoughts through discourse or a followup diff if there's anything interesting to discuss more.

You're welcome. I'm more active on Discord and might miss messages on Discourse.

libcxx/include/algorithm

 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__bits>
 #include <__config>
 #include <__debug>
 #include <cstddef>
 #include <cstring>
-#include <initializer_list>
 #include <memory>
 #include <type_traits>
 #include <version>
 
 #include <__algorithm/adjacent_find.h>
 #include <__algorithm/all_of.h>
 #include <__algorithm/any_of.h>
 #include <__algorithm/binary_search.h>

 #include <__algorithm/stable_sort.h>
 #include <__algorithm/swap_ranges.h>
 #include <__algorithm/transform.h>
 #include <__algorithm/unique.h>
 #include <__algorithm/unique_copy.h>
 #include <__algorithm/unwrap_iter.h>
 #include <__algorithm/upper_bound.h>
 
+// standard-mandated includes
+#include <initializer_list>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
 #   include <__pstl_algorithm>
 #endif
 
 #endif // _LIBCPP_ALGORITHM

libcxx/include/array

 #include <__algorithm/swap_ranges.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__iterator/reverse_iterator.h>
 #include <__tuple>
 #include <__utility/integer_sequence.h>
 #include <__utility/move.h>
 #include <__utility/unreachable.h>
-#include <compare>
 #include <stdexcept>
 #include <type_traits>
 #include <version>
 
+// standard-mandated includes
+
+// [iterator.range]
+#include <__iterator/access.h>
+#include <__iterator/data.h>
+#include <__iterator/empty.h>
+#include <__iterator/reverse_access.h>
+#include <__iterator/size.h>
+
+// [array.syn]
+#include <compare>
+#include <initializer_list>
+
 #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/bitset

 #include <__algorithm/fill.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__bit_reference>
 #include <__config>
 #include <__functional/hash.h>
 #include <__functional/unary_function.h>
 #include <climits>
 #include <cstddef>
-#include <iosfwd>
 #include <stdexcept>
-#include <string>
 #include <version>
 
+// standard-mandated includes
+#include <iosfwd>
+#include <string>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 

libcxx/include/coroutine

 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__coroutine/coroutine_handle.h>
 #include <__coroutine/coroutine_traits.h>
 #include <__coroutine/noop_coroutine_handle.h>
 #include <__coroutine/trivial_awaitables.h>
 #include <version>
 
+// standard-mandated includes
+#include <compare>
+
 #ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_COROUTINE

libcxx/include/deque

 #include <__iterator/iterator_traits.h>
 #include <__iterator/next.h>
 #include <__iterator/prev.h>
 #include <__iterator/reverse_iterator.h>
 #include <__split_buffer>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
-#include <compare>
-#include <initializer_list>
 #include <limits>
 #include <stdexcept>
 #include <type_traits>
 #include <version>
 
+// standard-mandated includes
+
+// [iterator.range]
+#include <__iterator/access.h>
+#include <__iterator/data.h>
+#include <__iterator/empty.h>
+#include <__iterator/reverse_access.h>
+#include <__iterator/size.h>
+
+// [deque.syn]
+#include <compare>
+#include <initializer_list>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 

libcxx/include/filesystem

 #include <__filesystem/operations.h>
 #include <__filesystem/path.h>
 #include <__filesystem/path_iterator.h>
 #include <__filesystem/perm_options.h>
 #include <__filesystem/perms.h>
 #include <__filesystem/recursive_directory_iterator.h>
 #include <__filesystem/space_info.h>
 #include <__filesystem/u8path.h>
-#include <compare>
 #include <version>
 
+// standard-mandated includes
+#include <compare>
+
 #if defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
 # error "The <filesystem> library is not supported since libc++ has been configured without support for a filesystem."
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_FILESYSTEM

libcxx/include/forward_list

 #include <__algorithm/min.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/move_iterator.h>
 #include <__iterator/next.h>
 #include <__utility/forward.h>
-#include <initializer_list>
 #include <limits>
 #include <memory>
 #include <type_traits>
 #include <version>
 
+// standard-mandated includes
+
+// [iterator.range]
+#include <__iterator/access.h>
+#include <__iterator/data.h>
+#include <__iterator/empty.h>
+#include <__iterator/reverse_access.h>
+#include <__iterator/size.h>
+
+// [forward.list.syn]
+#include <compare>
+#include <initializer_list>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 

libcxx/include/ios

 #if defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   error "The iostreams library is not supported since libc++ has been configured without support for localization."
 #endif
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__ios/fpos.h>
 #include <__locale>
 #include <__utility/swap.h>
-#include <iosfwd>
 #include <system_error>
 #include <version>
 
+// standard-mandated includes
+#include <iosfwd>
+
 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 #include <atomic>     // for __xindex_
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/iostream

 extern wostream wclog;
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <version>
+
+// standard-mandated includes
 #include <ios>
 #include <istream>
 #include <ostream>
 #include <streambuf>
-#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 extern _LIBCPP_FUNC_VIS istream cin;

libcxx/include/list

 #include <__iterator/iterator_traits.h>
 #include <__iterator/move_iterator.h>
 #include <__iterator/next.h>
 #include <__iterator/prev.h>
 #include <__iterator/reverse_iterator.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
-#include <initializer_list>
 #include <limits>
 #include <memory>
 #include <type_traits>
 #include <version>
 
+// standard-mandated includes
+
+// [iterator.range]
+#include <__iterator/access.h>
+#include <__iterator/data.h>
+#include <__iterator/empty.h>
+#include <__iterator/reverse_access.h>
+#include <__iterator/size.h>
+
+// [list.syn]
+#include <compare>
+#include <initializer_list>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 

libcxx/include/map

 #include <__functional/operations.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__node_handle>
 #include <__tree>
 #include <__utility/forward.h>
 #include <__utility/swap.h>
-#include <compare>
-#include <initializer_list>
 #include <memory>
 #include <type_traits>
 #include <version>
 
+// standard-mandated includes
+
+// [iterator.range]
+#include <__iterator/access.h>
+#include <__iterator/data.h>
+#include <__iterator/empty.h>
+#include <__iterator/reverse_access.h>
+#include <__iterator/size.h>
+
+// [associative.map.syn]
+#include <compare>
+#include <initializer_list>
+
 #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 <__memory/ranges_construct_at.h>
 #include <__memory/ranges_uninitialized_algorithms.h>
 #include <__memory/raw_storage_iterator.h>
 #include <__memory/shared_ptr.h>
 #include <__memory/temporary_buffer.h>
 #include <__memory/uninitialized_algorithms.h>
 #include <__memory/unique_ptr.h>
 #include <__memory/uses_allocator.h>
-#include <compare>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <iosfwd>
 #include <new>
 #include <stdexcept>
 #include <tuple>
 #include <type_traits>
 #include <typeinfo>
 #include <version>
 
+// standard-mandated includes
+#include <compare>
+
 #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/optional

 #include <__functional/invoke.h>
 #include <__functional/unary_function.h>
 #include <__memory/construct_at.h>
 #include <__tuple>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
-#include <compare>
 #include <initializer_list>
 #include <new>
 #include <stdexcept>
 #include <type_traits>
 #include <version>
 
+// standard-mandated includes
+#include <compare>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 namespace std  // purposefully not using versioning namespace
 {
 
 class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS bad_optional_access

libcxx/include/queue

 #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>
 
+// standard-mandated includes
+#include <compare>
+#include <initializer_list>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp, class _Container = deque<_Tp> > class _LIBCPP_TEMPLATE_VIS queue;
 

libcxx/include/random

 #include <__random/seed_seq.h>
 #include <__random/shuffle_order_engine.h>
 #include <__random/student_t_distribution.h>
 #include <__random/subtract_with_carry_engine.h>
 #include <__random/uniform_int_distribution.h>
 #include <__random/uniform_random_bit_generator.h>
 #include <__random/uniform_real_distribution.h>
 #include <__random/weibull_distribution.h>
-#include <initializer_list>
 #include <version>
 
+// standard-mandated includes
+#include <initializer_list>
+
 #include <cmath>       // for backward compatibility; TODO remove it
 #include <cstddef>     // for backward compatibility; TODO remove it
 #include <cstdint>     // for backward compatibility; TODO remove it
 #include <iosfwd>      // for backward compatibility; TODO remove it
 #include <limits>      // for backward compatibility; TODO remove it
 #include <numeric>     // for backward compatibility; TODO remove it
 #include <string>      // for backward compatibility; TODO remove it
 #include <type_traits> // for backward compatibility; TODO remove it
 #include <vector>      // for backward compatibility; TODO remove it
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_RANDOM

libcxx/include/regex

 
 } // std
 */
 
 #include <__algorithm/find.h>
 #include <__algorithm/search.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
-#include <__iterator/access.h>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/wrap_iter.h>
 #include <__locale>
 #include <__utility/move.h>
 #include <__utility/swap.h>
-#include <compare>
 #include <deque>
-#include <initializer_list>
 #include <memory>
 #include <stdexcept>
 #include <string>
 #include <vector>
 #include <version>
 
+// standard-mandated includes
+
+// [iterator.range]
+#include <__iterator/access.h>
+#include <__iterator/data.h>
+#include <__iterator/empty.h>
+#include <__iterator/reverse_access.h>
+#include <__iterator/size.h>
+
+// [re.syn]
+#include <compare>
+#include <initializer_list>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 

libcxx/include/set

 #include <__functional/is_transparent.h>
 #include <__functional/operations.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__node_handle>
 #include <__tree>
 #include <__utility/forward.h>
+#include <version>
+
+// standard-mandated includes
+
+// [iterator.range]
+#include <__iterator/access.h>
+#include <__iterator/data.h>
+#include <__iterator/empty.h>
+#include <__iterator/reverse_access.h>
+#include <__iterator/size.h>
+
+// [associative.set.syn]
 #include <compare>
 #include <initializer_list>
-#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Key, class _Compare, class _Allocator>

libcxx/include/span

 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__debug>
 #include <__fwd/span.h>
 #include <__iterator/concepts.h>
-#include <__iterator/data.h>
 #include <__iterator/iterator_traits.h>
-#include <__iterator/size.h>
 #include <__iterator/wrap_iter.h>
 #include <__memory/pointer_traits.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 <__utility/forward.h>
 #include <array>        // for array
 #include <cstddef>      // for byte
 #include <limits>
 #include <type_traits>  // for remove_cv, etc
 #include <version>
 
+// standard-mandated includes
+
+// [iterator.range]
+#include <__iterator/access.h>
+#include <__iterator/data.h>
+#include <__iterator/empty.h>
+#include <__iterator/reverse_access.h>
+#include <__iterator/size.h>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/stack

 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__memory/uses_allocator.h>
 #include <__utility/forward.h>
 #include <deque>
 #include <type_traits>
 #include <version>
 
+// standard-mandated includes
+#include <compare>
+#include <initializer_list>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp, class _Container = deque<_Tp> > class _LIBCPP_TEMPLATE_VIS stack;
 

libcxx/include/string

 #include <__memory/allocate_at_least.h>
 #include <__string/char_traits.h>
 #include <__string/extern_template_lists.h>
 #include <__utility/auto_cast.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <__utility/unreachable.h>
 #include <climits>
-#include <compare>
 #include <cstdint>
 #include <cstdio>  // EOF
 #include <cstdlib>
 #include <cstring>
-#include <initializer_list>
 #include <iosfwd>
 #include <limits>
 #include <memory>
 #include <stdexcept>
 #include <string_view>
 #include <type_traits>
 #include <version>
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #  include <cwchar>
 #endif
 
+// standard-mandated includes
+
+// [iterator.range]
+#include <__iterator/access.h>
+#include <__iterator/data.h>
+#include <__iterator/empty.h>
+#include <__iterator/reverse_access.h>
+#include <__iterator/size.h>
+
+// [string.syn]
+#include <compare>
+#include <initializer_list>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 

libcxx/include/string_view

 #include <__iterator/reverse_iterator.h>
 #include <__memory/pointer_traits.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/char_traits.h>
-#include <compare>
 #include <iosfwd>
 #include <limits>
 #include <stdexcept>
 #include <type_traits>
 #include <version>
 
+// standard-mandated includes
+
+// [iterator.range]
+#include <__iterator/access.h>
+#include <__iterator/data.h>
+#include <__iterator/empty.h>
+#include <__iterator/reverse_access.h>
+#include <__iterator/size.h>
+
+// [string.view.synop]
+#include <compare>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 

libcxx/include/system_error

 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__errc>
 #include <__functional/hash.h>
 #include <__functional/unary_function.h>
-#include <compare>
 #include <stdexcept>
 #include <string>
 #include <type_traits>
 #include <version>
 
+// standard-mandated includes
+#include <compare>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // is_error_code_enum
 

libcxx/include/thread

 #include <cstddef>
 #include <iosfwd>
 #include <memory>
 #include <system_error>
 #include <tuple>
 #include <type_traits>
 #include <version>
 
+// standard-mandated includes
+#include <compare>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 #ifdef _LIBCPP_HAS_NO_THREADS

libcxx/include/tuple

 #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 <version>
 
+// standard-mandated includes
+#include <compare>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifndef _LIBCPP_CXX03_LANG
 

libcxx/include/typeindex

 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__functional/unary_function.h>
-#include <compare>
 #include <typeinfo>
 #include <version>
 
+// standard-mandated includes
+#include <compare>
+
 #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/unordered_map

 #include <__functional/operations.h>
 #include <__hash_table>
 #include <__iterator/distance.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__node_handle>
 #include <__utility/forward.h>
-#include <compare>
 #include <stdexcept>
 #include <tuple>
 #include <version>
 
+// standard-mandated includes
+
+// [iterator.range]
+#include <__iterator/access.h>
+#include <__iterator/data.h>
+#include <__iterator/empty.h>
+#include <__iterator/reverse_access.h>
+#include <__iterator/size.h>
+
+// [unord.map.syn]
+#include <compare>
+#include <initializer_list>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Key, class _Cp, class _Hash, class _Pred,
           bool = is_empty<_Hash>::value && !__libcpp_is_final<_Hash>::value>

libcxx/include/unordered_set

 #include <__functional/operations.h>
 #include <__hash_table>
 #include <__iterator/distance.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__node_handle>
 #include <__utility/forward.h>
-#include <compare>
 #include <version>
 
+// standard-mandated includes
+
+// [iterator.range]
+#include <__iterator/access.h>
+#include <__iterator/data.h>
+#include <__iterator/empty.h>
+#include <__iterator/reverse_access.h>
+#include <__iterator/size.h>
+
+// [unord.set.syn]
+#include <compare>
+#include <initializer_list>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 class unordered_multiset;

libcxx/include/utility

 #include <__utility/pair.h>
 #include <__utility/piecewise_construct.h>
 #include <__utility/priority_tag.h>
 #include <__utility/rel_ops.h>
 #include <__utility/swap.h>
 #include <__utility/to_underlying.h>
 #include <__utility/transaction.h>
 #include <__utility/unreachable.h>
-#include <compare>
-#include <initializer_list>
 #include <type_traits>
 #include <version>
 
+// standard-mandated includes
+#include <compare>
+#include <initializer_list>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_UTILITY

libcxx/include/valarray

 #include <__config>
 #include <__functional/operations.h>
 #include <__memory/allocator.h>
 #include <__memory/uninitialized_algorithms.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <cmath>
 #include <cstddef>
-#include <initializer_list>
 #include <new>
 #include <version>
 
+// standard-mandated includes
+#include <initializer_list>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/variant

 #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 <version>
 
+// standard-mandated includes
+#include <compare>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 namespace std { // explicitly not using versioning namespace

libcxx/include/vector

 #include <__iterator/reverse_iterator.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>
 
+// standard-mandated includes
+
+// [iterator.range]
+#include <__iterator/access.h>
+#include <__iterator/data.h>
+#include <__iterator/empty.h>
+#include <__iterator/reverse_access.h>
+#include <__iterator/size.h>
+
+// [vector.syn]
+#include <compare>
+#include <initializer_list>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>