[libc++] Alphabetize header inclusions. NFCI

[• Quuxplusone]

Summary

This should be a trivial NFC.
It's worth remarking that historically libc++ includes <__config> before all other headers (in case some header depends on <__config> macros). However, if all our headers include <__config>, then it doesn't really matter — maybe we include <__bit> first, but then <__bit> includes <__config>, so it all works out.

I'm not sure what's going on with the errors in https://buildkite.com/llvm-project/libcxx-ci/builds/3355 (on the Apple builds only).

[• Quuxplusone]

Roll in "alphabetize all headers." Poke buildkite.

[• Quuxplusone]

Merge the __wrap_iter part; keep this open for the alphabetize-headers part.

[ldionne]

LGTM but let's fix the Apple issue before committing this.

[zoecarver]

Not exactly sure why the tests are failing... I couldn't reproduce locally :(

Anyway, this lgtm as well, assuming you fix the tests.

[• Quuxplusone]

Move <__config> to the top of every file again (although I still don't see a physical reason that should matter). FWIW, I can't reproduce the Apple failures locally on my Macbook.
Poke buildbot.

[• Quuxplusone]

git checkout main -- all of the headers involved in the Apple modules failure, https://buildkite.com/llvm-project/libcxx-ci/builds/3355
This presumably leaves some kind of trap for the next refactorer, but at least maybe it'll narrow down where the trap is.

[• Quuxplusone]

Add __threading_support to the modulemap. I think this is going to work!

[teemperor]

I wonder if the stds_include.sh.cpp should also use the -fmodules-local-submodule-visibility flag. The default -fmodules can't really handle top modules that include textual headers. We're using the same flag in LLVM to build since D74892 (see also rG82b47b2978405f802a33b00d046e6f18ef6a47be for why)

[• Quuxplusone]

libcxx/include/module.modulemap

548

@teemperor wrote:

I wonder if the stds_include.sh.cpp should also use the -fmodules-local-submodule-visibility flag. The default -fmodules can't really handle top modules that include textual headers. We're using the same flag in LLVM to build since D74892 (see also rG82b47b2978405f802a33b00d046e6f18ef6a47be for why)

I don't know enough modules to say whether that flag would help. However, I don't think the problem here is related to textual headers at all (I mean, it's not because of headers like <cassert>). The problem here seems to be that e.g. <mutex> and <thread> both #include <__threading_support>; and so the contents of header "__threading_support" were winding up duplicated in both module std.mutex and module std.thread. (We see random heisenbuggy duplication issues with other headers too, e.g. the partial specializations in "__iterator/iterator_traits.h" end up duplicated and thus ambiguous.)

What we really need is a way to "share" the common helper header __threading_support between mutex and thread (and so on). My impression is that the only(?) tool we have right now for doing that is to make __threading_support a whole module in its own right.

Personally I would be quite happy to replace all of module.modulemap with a single umbrella module std that simply includes everything; and then worry about "modularizing the STL" sometime down the road. This year in particular we seem to be having our hands full merely "headerizing" it! :)

[teemperor]

libcxx/include/module.modulemap

548

Sorry, I think I should have made clear that I meant 'headers that are not in a module' when I said 'textual' (as those headers behave similar to the actual textual headers declared in a modulemap).

And yes, having all the headers (even helpers) in their own submodule would probably help a lot with the bugs caused by the duplication. I'm not familiar enough with libc++ to say how much work that would be. Just commenting as I pushed for that specific test and I don't just want to leave it to others to keep it green :)

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 <type_traits>
-#include <typeinfo>
 #include <exception>
 #include <new>
+#include <type_traits>
+#include <typeinfo>
 #include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

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 <initializer_list>
-#include <memory>
-#include <iterator>
+#include <__debug>
 #include <algorithm>
 #include <cmath>
-#include <utility>
+#include <initializer_list>
+#include <iterator>
+#include <memory>
 #include <type_traits>
-
-#include <__debug>
+#include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__locale

 // -*- 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___LOCALE
 #define _LIBCPP___LOCALE
 
-#include <__config>
 #include <__availability>
+#include <__config>
 #include <string>
 #include <memory>
 #include <utility>
 #include <mutex>
 #include <cstdint>
 #include <cctype>
 #include <locale.h>
 #if defined(_LIBCPP_MSVCRT_LIKE)

libcxx/include/__mutex_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___MUTEX_BASE
 #define _LIBCPP___MUTEX_BASE
 
 #include <__config>
+#include <__threading_support>
 #include <chrono>
 #include <system_error>
-#include <__threading_support>
-
 #include <time.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/__split_buffer

 // -*- C++ -*-
 #ifndef _LIBCPP_SPLIT_BUFFER
 #define _LIBCPP_SPLIT_BUFFER
 
 #include <__config>
-#include <type_traits>
 #include <algorithm>
+#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__std_stream

 // -*- 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___STD_STREAM
 #define _LIBCPP___STD_STREAM
 
 #include <__config>
-#include <ostream>
-#include <istream>
 #include <__locale>
 #include <cstdio>
+#include <istream>
+#include <ostream>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__threading_support

 // -*- 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_THREADING_SUPPORT
 #define _LIBCPP_THREADING_SUPPORT
 
-#include <__config>
 #include <__availability>
+#include <__config>
 #include <chrono>
-#include <iosfwd>
 #include <errno.h>
+#include <iosfwd>
 #include <limits>
 
 #ifdef __MVS__
 # include <__support/ibm/nanosleep.h>
 #endif
 
 #ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
 #pragma GCC system_header

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 <__config>
+#include <algorithm>
 #include <iterator>
 #include <memory>
 #include <stdexcept>
-#include <algorithm>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/algorithm

template <class BidirectionalIterator, class Compare>
     constexpr bool     // constexpr in C++20
     prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);
 
 }  // std
 
 */
 
 #include <__config>
-#include <initializer_list>
-#include <type_traits>
+#include <__bits> // __libcpp_clz
+#include <cstddef>
 #include <cstring>
-#include <utility> // needed to provide swap_ranges.
-#include <memory>
 #include <functional>
+#include <initializer_list>
 #include <iterator>
-#include <cstddef>
-#include <bit>
+#include <memory>
+#include <type_traits>
+#include <utility> // swap_ranges
 #include <version>
 
 #include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 

libcxx/include/any

template<class ValueType>
     const ValueType* any_cast(const any* operand) noexcept;
   template<class ValueType>
     ValueType* any_cast(any* operand) noexcept;
 
 } // namespace std
 
 */
 
-#include <__config>
 #include <__availability>
+#include <__config>
+#include <cstdlib>
 #include <memory>
-#include <typeinfo>
 #include <type_traits>
-#include <cstdlib>
+#include <typeinfo>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 namespace std {
 class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_ANY_CAST bad_any_cast : public bad_cast

libcxx/include/array

 template <size_t I, class T, size_t N> T&& get(array<T, N>&&) noexcept;             // constexpr in C++14
 template <size_t I, class T, size_t N> const T&& get(const array<T, N>&&) noexcept; // constexpr in C++14
 
 }  // std
 
 */
 
 #include <__config>
+#include <__debug>
 #include <__tuple>
-#include <type_traits>
-#include <utility>
-#include <iterator>
 #include <algorithm>
-#include <stdexcept>
 #include <cstdlib> // for _LIBCPP_UNREACHABLE
+#include <iterator>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
 #include <version>
-#include <__debug>
 
 #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
 {
     // types:
     typedef array __self;
     typedef _Tp                                   value_type;
     typedef value_type&                           reference;
     typedef const value_type&                     const_reference;

libcxx/include/atomic

 #define ATOMIC_VAR_INIT(value) see below
 
 #define ATOMIC_FLAG_INIT see below
 
 }  // std
 
 */
 
-#include <__config>
 #include <__availability>
+#include <__config>
 #include <__threading_support>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/barrier

namespace std
   private:
     CompletionFunction completion; // exposition only
   };
 
 }
 
 */
 
-#include <__config>
 #include <__availability>
+#include <__config>
 #include <atomic>
 #ifndef _LIBCPP_HAS_NO_TREE_BARRIER
 # include <memory>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif

libcxx/include/bit

enum class endian {
     native = see below         // C++20
 };
 
 } // namespace std
 
 */
 
 #include <__config>
-#include <__bits>
+#include <__bits> // __libcpp_clz
 #include <__debug>
 #include <limits>
 #include <type_traits>
 #include <version>
 
 #if defined(__IBMCPP__)
 #include "__support/ibm/support.h"
 #endif

libcxx/include/bitset

 template <size_t N> struct hash<std::bitset<N>>;
 
 }  // std
 
 */
 
 #include <__config>
 #include <__bit_reference>
-#include <cstddef>
+#include <__functional_base>
 #include <climits>
-#include <string>
-#include <stdexcept>
+#include <cstddef>
 #include <iosfwd>
-#include <__functional_base>
+#include <stdexcept>
+#include <string>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/charconv

namespace std {
   from_chars_result from_chars(const char* first, const char* last,
                                long double& value,
                                chars_format fmt = chars_format::general);
 
 } // namespace std
 
 */
 
-#include <__config>
 #include <__availability>
+#include <__config>
 #include <__errc>
 #include <__utility/to_underlying.h>
 #include <cmath> // for log2f
 #include <cstdint>
 #include <cstdlib> // for _LIBCPP_UNREACHABLE
 #include <cstring>
 #include <limits>
 #include <type_traits>

libcxx/include/chrono

 constexpr chrono::day                                   operator ""d(unsigned long long d) noexcept; // C++20
 constexpr chrono::year                                  operator ""y(unsigned long long y) noexcept; // C++20
 }  // chrono_literals
 }  // literals
 
 }  // std
 */
 
-#include <__config>
 #include <__availability>
+#include <__config>
 #include <compare>
 #include <ctime>
-#include <type_traits>
-#include <ratio>
 #include <limits>
+#include <ratio>
+#include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/complex

 template<class T> complex<T> tan (const complex<T>&);
 template<class T> complex<T> tanh (const complex<T>&);
 
 }  // std
 
 */
 
 #include <__config>
-#include <type_traits>
-#include <stdexcept>
 #include <cmath>
 #include <iosfwd>
+#include <stdexcept>
+#include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <sstream> // for std::basic_ostringstream
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

libcxx/include/exception

 
 template <class T> [[noreturn]] void throw_with_nested(T&& t);
 template <class E> void rethrow_if_nested(const E& e);
 
 }  // std
 
 */
 
-#include <__config>
 #include <__availability>
+#include <__config>
 #include <__memory/addressof.h>
 #include <cstddef>
 #include <cstdlib>
 #include <type_traits>
 #include <version>
 
 #if defined(_LIBCPP_ABI_VCRUNTIME)
 #include <vcruntime_exception.h>

libcxx/include/filesystem

/*
     path weakly_canonical(path const& p);
     path weakly_canonical(path const& p, error_code& ec);
 
 
 } }  // namespaces std::filesystem
 
 */
 
-#include <__config>
 #include <__availability>
-#include <cstddef>
-#include <cstdlib>
+#include <__config>
+#include <__debug>
 #include <chrono>
 #include <compare>
-#include <iterator>
+#include <cstddef>
+#include <cstdlib>
 #include <iosfwd>
+#include <iterator>
 #include <memory>
 #include <stack>
 #include <string>
+#include <string_view>
 #include <system_error>
 #include <utility>
-#include <string_view>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 # include <locale>
 # include <iomanip> // for quoted
 #endif
 
-#include <__debug>
-
 #if defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
 # error "The Filesystem library is not supported by this configuration of libc++"
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 

libcxx/include/forward_list

template <class T, class Allocator, class Predicate>
     typename forward_list<T, Allocator>::size_type
     erase_if(forward_list<T, Allocator>& c, Predicate pred);    // C++20
 
 }  // std
 
 */
 
 #include <__config>
+#include <algorithm>
 #include <initializer_list>
-#include <memory>
-#include <limits>
 #include <iterator>
-#include <algorithm>
+#include <limits>
+#include <memory>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/fstream

 
 typedef basic_fstream<char>    fstream;
 typedef basic_fstream<wchar_t> wfstream;
 
 }  // std
 
 */
 
-#include <__config>
 #include <__availability>
+#include <__config>
 #include <__debug>
 #include <__locale>
 #include <cstdio>
 #include <cstdlib>
 #include <istream>
 #include <ostream>
 
 #if !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)

libcxx/include/functional

 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 <__config>
 #include <__debug>
+#include <__functional_base>
 #include <concepts>
-#include <type_traits>
-#include <typeinfo>
 #include <exception>
 #include <memory>
 #include <tuple>
+#include <type_traits>
+#include <typeinfo>
 #include <utility>
 #include <version>
 
-#include <__functional_base>
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>

libcxx/include/future

template <class R>
   void swap(packaged_task<R(ArgTypes...)&, packaged_task<R(ArgTypes...)>&) noexcept;
 
 template <class R, class Alloc> struct uses_allocator<packaged_task<R>, Alloc>;
 
 }  // std
 
 */
 
-#include <__config>
 #include <__availability>
+#include <__config>
 #include <__debug>
 #include <chrono>
 #include <exception>
 #include <memory>
 #include <mutex>
 #include <system_error>
 #include <thread>
 

libcxx/include/ios

 error_condition make_error_condition(io_errc e) noexcept;
 storage-class-specifier const error_category& iostream_category() noexcept;
 
 }  // std
 
 */
 
 #include <__config>
-#include <iosfwd>
 #include <__locale>
+#include <iosfwd>
 #include <system_error>
 
 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 #include <atomic>     // for __xindex_
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

libcxx/include/iostream

 // -*- C++ -*-
 //===--------------------------- iostream ---------------------------------===//
 //
 // 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_IOSTREAM
 #define _LIBCPP_IOSTREAM
 
 /*
     iostream synopsis
 
 #include <ios>
-#include <streambuf>
 #include <istream>
 #include <ostream>
+#include <streambuf>
 
 namespace std {
 
 extern istream cin;
 extern ostream cout;
 extern ostream cerr;
 extern ostream clog;
 extern wistream wcin;
 extern wostream wcout;
 extern wostream wcerr;
 extern wostream wclog;
 
 }  // std
 
 */
 
 #include <__config>
 #include <ios>
-#include <streambuf>
 #include <istream>
 #include <ostream>
+#include <streambuf>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifndef _LIBCPP_HAS_NO_STDIN

libcxx/include/istream

 template <class Stream, class T>
   Stream&& operator>>(Stream&& is, T&& x);
 
 }  // std
 
 */
 
 #include <__config>
-#include <version>
 #include <ostream>
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/latch

namespace std
   private:
     ptrdiff_t __counter; // exposition only
   };
 
 }
 
 */
 
-#include <__config>
 #include <__availability>
+#include <__config>
 #include <atomic>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 #ifdef _LIBCPP_HAS_NO_THREADS
 # error <latch> is not supported on this single threaded system

libcxx/include/list

template <class T, class Allocator, class Predicate>
     typename list<T, Allocator>::size_type
     erase_if(list<T, Allocator>& c, Predicate pred);    // C++20
 
 }  // std
 
 */
 
 #include <__config>
-
-#include <memory>
-#include <limits>
+#include <__debug>
+#include <algorithm>
 #include <initializer_list>
 #include <iterator>
-#include <algorithm>
+#include <limits>
+#include <memory>
 #include <type_traits>
 #include <version>
 
-#include <__debug>
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 

libcxx/include/locale

 template <class charT> class messages;
 template <class charT> class messages_byname;
 
 }  // std
 
 */
 
 #include <__config>
-#include <__locale>
 #include <__debug>
+#include <__locale>
 #include <algorithm>
-#include <memory>
-#include <ios>
-#include <streambuf>
-#include <iterator>
-#include <limits>
-#include <version>
 #ifndef __APPLE__
-#include <cstdarg>
+# include <cstdarg>
 #endif
+#include <cstdio>
 #include <cstdlib>
 #include <ctime>
-#include <cstdio>
+#include <ios>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <streambuf>
+#include <version>
 
 #if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
 // Most unix variants have catopen.  These are the specific ones that don't.
 #  if !defined(__BIONIC__) && !defined(_NEWLIB_VERSION)
 #    define _LIBCPP_HAS_CATOPEN 1
 #    include <nl_types.h>
 #  endif
 #endif

libcxx/include/map

 
 */
 
 #include <__config>
 #include <__debug>
 #include <__node_handle>
 #include <__tree>
 #include <compare>
+#include <functional>
 #include <initializer_list>
 #include <iterator> // __libcpp_erase_if_container
 #include <memory>
-#include <utility>
-#include <functional>
-#include <initializer_list>
 #include <type_traits>
+#include <utility>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/memory

 
 void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
 
 }  // std
 
 */
 
 #include <__config>
-#include <type_traits>
-#include <typeinfo>
-#include <compare>
-#include <cstddef>
-#include <cstdint>
-#include <new>
-#include <utility>
-#include <iterator>
 #include <__functional_base>
-#include <iosfwd>
-#include <tuple>
-#include <stdexcept>
-#include <cstring>
 #include <__memory/addressof.h>
 #include <__memory/allocation_guard.h>
 #include <__memory/allocator.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/construct_at.h>
 #include <__memory/pointer_safety.h>
 #include <__memory/pointer_traits.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 <compare>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <iosfwd>
+#include <iterator>
+#include <new>
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
+#include <typeinfo>
+#include <utility>
 #include <version>
 
 #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

libcxx/include/module.modulemap

module vector {
     export *
   }
   module version {
     header "version"
     export *
   }
 
   // FIXME: These should be private.
-  module __bits { header "__bits" export * }
   module __bit_reference { header "__bit_reference" export * }
+  module __bits { header "__bits" export * }
   module __debug { header "__debug" export * }
   module __errc { header "__errc" export * }
   module __functional_base { header "__functional_base" export * }
   module __hash_table { header "__hash_table" export * }
   module __locale { header "__locale" export * }
   module __mutex_base { header "__mutex_base" export * }
+  module __node_handle { header "__node_handle" export * }
   module __split_buffer { header "__split_buffer" export * }
   module __std_stream { header "__std_stream" export * }
   module __string { header "__string" export * }
+  module __threading_support { header "__threading_support" export * }
   module __tree { header "__tree" export * }
   module __tuple { header "__tuple" export * }
   module __undef_macros { header "__undef_macros" export * }
-  module __node_handle { header "__node_handle" export * }
 
   module experimental {
     requires cplusplus11
 
     module algorithm {
       header "experimental/algorithm"
       export *
     }

libcxx/include/mutex

template<class Callable, class ...Args>
   void call_once(once_flag& flag, Callable&& func, Args&&... args);
 
 }  // std
 
 */
 
 #include <__config>
 #include <__mutex_base>
+#include <__threading_support>
 #include <cstdint>
 #include <functional>
 #include <memory>
 #ifndef _LIBCPP_CXX03_LANG
-#include <tuple>
+# include <tuple>
 #endif
 #include <version>
-#include <__threading_support>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/new

 
 void* operator new  (std::size_t size, void* ptr) noexcept;             // nodiscard in C++20
 void* operator new[](std::size_t size, void* ptr) noexcept;             // nodiscard in C++20
 void  operator delete  (void* ptr, void*) noexcept;
 void  operator delete[](void* ptr, void*) noexcept;
 
 */
 
-#include <__config>
 #include <__availability>
+#include <__config>
 #include <cstddef>
 #include <cstdlib>
 #include <exception>
 #include <type_traits>
 #include <version>
 
 #if defined(_LIBCPP_ABI_VCRUNTIME)
 #include <new.h>

libcxx/include/numbers

namespace std::numbers {
   inline constexpr double sqrt3      = sqrt3_v<double>;
   inline constexpr double inv_sqrt3  = inv_sqrt3_v<double>;
   inline constexpr double egamma     = egamma_v<double>;
   inline constexpr double phi        = phi_v<double>;
 }
 */
 
 #include <__config>
-
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
-
 #include <concepts>
 #include <type_traits>
 #include <version>
 
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
 #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/optional

 
 template<class T>
   optional(T) -> optional<T>;
 
 } // namespace std
 
 */
 
-#include <__config>
 #include <__availability>
+#include <__config>
 #include <__debug>
 #include <__functional_base>
 #include <compare>
 #include <functional>
 #include <initializer_list>
 #include <new>
 #include <stdexcept>
 #include <type_traits>

libcxx/include/ostream

 template <class Stream, class T>
   Stream&& operator<<(Stream&& os, const T& x);
 
 }  // std
 
 */
 
 #include <__config>
+#include <bitset>
 #include <ios>
-#include <streambuf>
-#include <locale>
 #include <iterator>
-#include <bitset>
+#include <locale>
+#include <streambuf>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

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 <algorithm>
 #include <compare>
 #include <deque>
-#include <vector>
 #include <functional>
-#include <algorithm>
+#include <vector>
 
 #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

     operator>>(basic_istream<charT, traits>& is,
                piecewise_linear_distribution& x);
 };
 
 } // std
 */
 
 #include <__config>
-#include <cstddef>
-#include <cstdint>
+#include <algorithm>
 #include <cmath>
 #include <concepts>
-#include <type_traits>
+#include <cstddef>
+#include <cstdint>
 #include <initializer_list>
+#include <iosfwd>
 #include <limits>
-#include <algorithm>
 #include <numeric>
-#include <vector>
 #include <string>
-#include <iosfwd>
+#include <type_traits>
+#include <vector>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/ranges

 */
 
 #include <__config>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/data.h>
 #include <__ranges/empty.h>
 #include <__ranges/enable_borrowed_range.h>
-#include <__ranges/view.h>
 #include <__ranges/size.h>
+#include <__ranges/view.h>
 #include <compare>          // Required by the standard.
 #include <initializer_list> // Required by the standard.
 #include <iterator>         // Required by the standard.
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

libcxx/include/ratio

typedef ratio<1000000000000000000000000, 1> yotta;  // not supported
   template <class R1, class R2> inline constexpr bool ratio_greater_v
     = ratio_greater<R1, R2>::value;                                     // C++17
   template <class R1, class R2> inline constexpr bool ratio_greater_equal_v
     = ratio_greater_equal<R1, R2>::value;                               // C++17
 }
 */
 
 #include <__config>
-#include <cstdint>
 #include <climits>
+#include <cstdint>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/semaphore

 };
 
 using binary_semaphore = counting_semaphore<1>;
 
 }
 
 */
 
-#include <__config>
 #include <__availability>
+#include <__config>
 #include <__threading_support>
 #include <atomic>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 #ifdef _LIBCPP_HAS_NO_THREADS

libcxx/include/shared_mutex

 
 template <class Mutex>
     void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
 
 }  // std
 
 */
 
-#include <__config>
 #include <__availability>
+#include <__config>
 #include <version>
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 
 #if _LIBCPP_STD_VER > 11 || defined(_LIBCPP_BUILDING_LIBRARY)
 

libcxx/include/sstream

 typedef basic_stringstream<char>    stringstream;
 typedef basic_stringstream<wchar_t> wstringstream;
 
 }  // std
 
 */
 
 #include <__config>
-#include <ostream>
 #include <istream>
+#include <ostream>
 #include <string>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/stdexcept

public:
     virtual const char* what() const noexcept // returns what_arg
 };
 
 }  // std
 
 */
 
 #include <__config>
-#include <cstdlib>
 #include <exception>
 #include <iosfwd>  // for string forward decl
+#include <cstdlib>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifndef _LIBCPP_ABI_VCRUNTIME

libcxx/include/streambuf

protected:
     virtual int_type overflow (int_type c = traits_type::eof());
 };
 
 }  // std
 
 */
 
 #include <__config>
-#include <iosfwd>
 #include <ios>
+#include <iosfwd>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/string

 basic_string<char16_t> operator "" s( const char16_t *str, size_t len ); // C++14
 basic_string<char32_t> operator "" s( const char32_t *str, size_t len ); // C++14
 
 }  // std
 
 */
 
 #include <__config>
+#include <__debug>
+#include <__functional_base>
+#include <algorithm>
 #include <compare>
-#include <string_view>
-#include <iosfwd>
+#include <cstdio>  // EOF
 #include <cstring>
-#include <cstdio>  // For EOF.
 #include <cwchar>
-#include <algorithm>
+#include <initializer_list>
+#include <iosfwd>
 #include <iterator>
-#include <utility>
 #include <memory>
 #include <stdexcept>
+#include <string_view>
 #include <type_traits>
-#include <initializer_list>
-#include <__functional_base>
+#include <utility>
 #include <version>
+
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-#include <cstdint>
+# include <cstdint>
 #endif
 
-#include <__debug>
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 

libcxx/include/string_view

namespace std {
   constexpr basic_string_view<char32_t> operator "" sv( const char32_t *str, size_t len ) noexcept;
 
 }  // namespace std
 
 
 */
 
 #include <__config>
+#include <__debug>
 #include <__ranges/enable_borrowed_range.h>
 #include <__string>
-#include <iosfwd>
 #include <algorithm>
 #include <compare>
+#include <iosfwd>
 #include <iterator>
 #include <limits>
 #include <stdexcept>
 #include <version>
-#include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/strstream

private:
     strstreambuf sb; // exposition only
 };
 
 }  // std
 
 */
 
 #include <__config>
-#include <ostream>
 #include <istream>
+#include <ostream>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 class _LIBCPP_TYPE_VIS strstreambuf

libcxx/include/thread

 
 }  // this_thread
 
 }  // std
 
 */
 
 #include <__config>
-#include <iosfwd>
+#include <__debug>
 #include <__functional_base>
-#include <type_traits>
+#include <__mutex_base>
+#include <__threading_support>
+#include <chrono>
 #include <cstddef>
 #include <functional>
+#include <iosfwd>
 #include <memory>
 #include <system_error>
-#include <chrono>
-#include <__mutex_base>
-#ifndef _LIBCPP_CXX03_LANG
 #include <tuple>
-#endif
-#include <__threading_support>
-#include <__debug>
+#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/tuple

template <class... Types>
   void
   swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(noexcept(x.swap(y)));
 
 }  // std
 
 */
 
 #include <__config>
+#include <__functional_base>
 #include <__tuple>
 #include <compare>
 #include <cstddef>
 #include <type_traits>
-#include <__functional_base>
 #include <utility>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/typeindex

struct hash<type_index>
     size_t operator()(type_index index) const noexcept;
 };
 
 }  // std
 
 */
 
 #include <__config>
-#include <typeinfo>
 #include <__functional_base>
 #include <compare>
+#include <typeinfo>
 
 #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/typeinfo

public:
     bad_typeid& operator=(const bad_typeid&) noexcept;
     virtual const char* what() const noexcept;
 };
 
 }  // std
 
 */
 
-#include <__config>
 #include <__availability>
-#include <exception>
+#include <__config>
 #include <cstddef>
 #include <cstdint>
+#include <exception>
 #include <type_traits>
+
 #ifdef _LIBCPP_NO_EXCEPTIONS
 #include <cstdlib>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 

libcxx/include/unordered_map

template <class Key, class T, class Hash, class Pred, class Alloc>
     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 <__hash_table>
 #include <__node_handle>
 #include <compare>
 #include <functional>
 #include <iterator> // __libcpp_erase_if_container
 #include <stdexcept>
 #include <tuple>
 #include <version>
 
-#include <__debug>
-
 #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

template <class Value, class Hash, class Pred, class Alloc>
     bool
     operator!=(const unordered_multiset<Value, Hash, Pred, Alloc>& x,
                const unordered_multiset<Value, Hash, Pred, Alloc>& y);
 }  // std
 
 */
 
 #include <__config>
+#include <__debug>
 #include <__hash_table>
 #include <__node_handle>
 #include <compare>
 #include <functional>
 #include <iterator> // __libcpp_erase_if_container
 #include <version>
 
-#include <__debug>
-
 #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

 template <class T>
     constexpr underlying_type_t<T> to_underlying( T value ) noexcept; // C++2b
 
 }  // std
 
 */
 
 #include <__config>
+#include <__debug>
 #include <__tuple>
 #include <__utility/to_underlying.h>
 #include <compare>
-#include <type_traits>
-#include <initializer_list>
 #include <cstddef>
-#include <cstring>
 #include <cstdint>
+#include <cstring>
+#include <initializer_list>
 #include <limits>
+#include <type_traits>
 #include <version>
-#include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/valarray

 template <class T> unspecified1 end(valarray<T>& v);
 template <class T> unspecified2 end(const valarray<T>& v);
 
 }  // std
 
 */
 
 #include <__config>
-#include <cstddef>
-#include <cmath>
-#include <initializer_list>
 #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
 #include <__undef_macros>
 
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template<class _Tp> class _LIBCPP_TEMPLATE_VIS valarray;
 
 class _LIBCPP_TEMPLATE_VIS slice
 {
     size_t __start_;
     size_t __size_;

libcxx/include/variant

namespace std {
   template <class T> struct hash;
   template <class... Types> struct hash<variant<Types...>>;
   template <> struct hash<monostate>;
 
 } // namespace std
 
 */
 
-#include <__config>
 #include <__availability>
+#include <__config>
 #include <__tuple>
 #include <array>
 #include <compare>
 #include <exception>
 #include <functional>
 #include <initializer_list>
+#include <limits>
 #include <new>
 #include <tuple>
 #include <type_traits>
 #include <utility>
-#include <limits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/vector

 typename vector<T, Allocator>::size_type
 erase_if(vector<T, Allocator>& c, Predicate pred);    // C++20
 
 }  // std
 
 */
 
 #include <__config>
-#include <iosfwd> // for forward declaration of vector
 #include <__bit_reference>
-#include <type_traits>
+#include <__debug>
+#include <__functional_base>
+#include <__split_buffer>
+#include <algorithm>
 #include <climits>
 #include <compare>
-#include <limits>
+#include <cstring>
 #include <initializer_list>
+#include <iosfwd> // for forward declaration of vector
+#include <limits>
 #include <memory>
 #include <stdexcept>
-#include <algorithm>
-#include <cstring>
+#include <type_traits>
 #include <version>
-#include <__split_buffer>
-#include <__functional_base>
-
-#include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/test/libcxx/modules/stds_include.sh.cpp

 
 // REQUIRES: modules-support
 
 // NOTE: The -std=XXX flag is present in %{flags}, so we overwrite it by passing it after %{flags}.
 // FIXME: Remove the `-DINVALIDATE_CACHE_FOO` macros. Their purpose is to workaround a bug in older Clang versions
 //        the same modules caches were reused across standard dialects.
 // RUN: %{cxx} %{flags} %{compile_flags} -fmodules -fcxx-modules -fsyntax-only -std=c++03 -DINVALIDATE_CACHE_CXX03 %s
 // RUN: %{cxx} %{flags} %{compile_flags} -fmodules -fcxx-modules -fsyntax-only -std=c++11 -DINVALIDATE_CACHE_CXX11 %s
-// RUN: %{cxx} %{flags} %{compile_flags} -fmodules -fcxx-modules -fsyntax-only -std=c++14 -DINVALIDATE_CACHE_CKK14 %s
+// RUN: %{cxx} %{flags} %{compile_flags} -fmodules -fcxx-modules -fsyntax-only -std=c++14 -DINVALIDATE_CACHE_CXX14 %s
 // RUN: %{cxx} %{flags} %{compile_flags} -fmodules -fcxx-modules -fsyntax-only -std=c++17 -DINVALIDATE_CACHE_CXX17 %s
-// RUN: %{cxx} %{flags} %{compile_flags} -fmodules -fcxx-modules -fsyntax-only -std=c++2a -DINVALIDATE_CACHE_CXX2A %s
+// RUN: %{cxx} %{flags} %{compile_flags} -fmodules -fcxx-modules -fsyntax-only -std=c++20 -DINVALIDATE_CACHE_CXX20 %s
 
 #include <vector>
 
 int main(int, char**) {
   return 0;
 }