[libc++][modules] Adds the C++23 std module.

[Mordante]

Summary

The patch is based on D144994.

D151030 added the module definitions for the module std.
This patch wires in the module and enables the basic testing.

Some notable features are missing:

• There is no test that libc++ can be fully imported as a module.
• This lacks the parts for the std.compat module.
• The module is not shipped with libc++.

Implements parts of

• P2465R3 Standard Library Modules std and std.compat

[Mordante]

libcxx/test/libcxx/module_std.sh.cpp

7 ↗

(On Diff #527066)

This file needs to be rewritten once D151654 lands.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[aaronmondal]

libcxx/CMakeLists.txt

100

For future compatiblity maybe this should be LIBCXX_ENABLE_STD_MODULES (with S) or LIBCXX_ENABLE_MODULES instead? At the moment only std is supported, but when std.compat is added later the current flag name could be misleading.

Or should there be different flags for std and std.compat? IMO they should both be covered by the same flag.

libcxx/docs/Modules.rst

66

As a safeguard we might want to add the note that the BMIs shouldn't be distributed at the moment. AFAIK BMIs still contain absolute paths to their build environment. I.e. if you build at /my/custom/build/machine this path will be printed if you run strings on the BMIs. This could leak information from a distributors build environment to the BMI.

libcxx/modules/CMakeLists.txt.in

63

I believe only https://github.com/llvm/llvm-project/issues/62844 breaks -Werror when building with C++23. Alternatively, -Wno-deprecated-declarations might also allow use of -Werror.

libcxx/utils/ci/run-buildbot

200–201

build2 encourages the extensions mxx and mpp. Adding those here might save them a downstream patch :D

libcxx/utils/generate_header_tests.py

85 ↗

(On Diff #527286)

Unrelated, to this patch. Some styleguides consider nasty as "unlikely profanity". There might be a better way to name this.

libcxx/utils/libcxx/test/dsl.py

446–447

Typo? Looks like this should fall back to std = '23' or just be std = '26'?

[Mordante]

Thanks for the review!

libcxx/CMakeLists.txt

100

They indeed should be the same flag. The reason why this is an option is due to the additional version requirements of CMake, ninja, and Clang. These are the same for std and std.compat. The intention is to remove this option at some point in the future.

I should add a TODO MODULES to make that clear.

libcxx/docs/Modules.rst

66

I'm not sure that is needed. I feel there are already quite some warnings that BMIs are not portable. At least on Debian in the past, debug packages "leaked" the same information, which didn't seem to be an issue.

Do you have reasons why this is a real issue?

libcxx/modules/CMakeLists.txt.in

63

-Werror should be removed, that's left from testing. Nice catch!

I really don't want this since users could add other compiler flags that will cause warnings to be issued.

libcxx/utils/ci/run-buildbot

200–201

This only tests formatting extensions used in libc++. For example I recently removed hxx and cxx since we don't use them. The main reason to specify these manually is that we want to format files without any extension. For example string.

libcxx/utils/libcxx/test/dsl.py

446–447

No this is intended, hence the TODO. It seems modules and C++26 fail. I haven't gotten around to investigate this further and possibly file a bug. After this patch has landed it's easier to create a nice reproducer.

[aaronmondal]

libcxx/docs/Modules.rst

66

If you have a build that indexes cached artifacts by hash this can lead to confusing cache behavior for incremental builds. Having the cache poisoned by this essentially forces you to completely delete it and rebuild everything. For LLVM this is roughly 200GB of wasted cache transfer and ~10 hours of wasted single thread CPU minutes. This probably isn't an issue for most users though and since modules are experimental anyways it's probably a non-issue.

[ChuanqiXu]

Thanks! This looks good overall.

There is no test that libc++ can be fully imported as a module.

What's the plan to add some test to use import std; in the source code? I remember you had a patch to use import std; for the coroutines tests. But I can't find it now. For me, it is better to have at least one import std; in the test of the tree. (But this is not necessary to land it in this patch, of course)

libcxx/docs/Contributing.rst

47

nit: in my imagination, in the future, this can be solved automatically:

#if ...
import std;
#else
#include <stl_headers>
#endif

use of new decl... // error if the author forget to touch std modules.

(this is not a requirement to change the note)

libcxx/docs/Modules.rst

8

nit: a silly English question. Is it ok to use *s are and an together in a sentence? I got confused several times before.

28

134–135

This was mitigated recently: https://github.com/llvm/llvm-project/blob/15a719de01b92da7de4b8381660525b622c2c292/clang/lib/Driver/ToolChains/Clang.cpp#L3688-L3697. But personally I prefer -std=c++xx instead of -std=gnu++xx.

165

This is not what we talked about implicit paths. The implicit paths is that the BMI will contain paths to their dependency implicitly. e.g,

// b.cppm
export module b;
export int b() {
    return 43;
}

// a.cppm
export module a;
import b;
export int a() {
    return b() + 43;
}

// user.cpp
import a;
int use() {
    return a();
}

Now it is ok to compiler user.cpp without specify the path to the BMI of module b. It is different from disabling -fprebuilt-module-path.

libcxx/docs/ReleaseNotes.rst

139

nit: maybe it is helpful to mention the above change. Otherwise the readers who don't read the whole document may get confused.

libcxx/modules/CMakeLists.txt

3

nit: consider to specify 3.26 clearly in the message?

libcxx/modules/CMakeLists.txt.in

2

nit: CMake3.25 only has the support MSVC and the support for clang was added in 3.26.

[Arthapz]

Hello, i'll add the support of this patch in XMake today :)

[ChuanqiXu]

(BTW, we lack a [ in the title.)

[Mordante]

In D151814#4390263, @Arthapz wrote:

Hello, i'll add the support of this patch in XMake today :)

Great, thanks :-)

In D151814#4390266, @ChuanqiXu wrote:

(BTW, we lack a [ in the title.)

Thanks, fixed.

libcxx/docs/Contributing.rst

47

This is about adding new declarations to the .cppm files. For example when somebody implements parts of mdspan these new classes need to be added to the .cppm files. If you forget to do that, the CI will fail.

libcxx/docs/Modules.rst

134–135

Thanks for the info. I too prefer to disable extensions. I'll remove these two lines.

165

Interesting. When I removed the fprebuilt-module-path I got these warnings.

[Arthapz]

do you already know where the modules will be installed (i know modules are not installed atm, it's for simulation purpose :D) ? (like /usr/modules, /usr/module, etc...)

[Mordante]

In D151814#4393479, @Arthapz wrote:

do you already know where the modules will be installed (i know modules are not installed atm, it's for simulation purpose :D) ? (like /usr/modules, /usr/module, etc...)

It has already been discussed, but there's no conclusion yet. I want to revisit that discussion soon. That's the main reason not to install modules in this patch.

libcxx/docs/Modules.rst

8

I think it's correct, but I'm not a native speaker.

28

I think the current text is correct.

66

That seems like a non-typical use case. I prefer to leave that information out.

134–135

Actually it turns our this doesn't work correctly with libc++. There is an issue with the new partition. This is named __new since new is a keyword. For now I require extensions of and blame libc++ instead of clang.

This should be fixed, but for now I keep it as is and add it to the list of known limitations.

165

I removed the comment and left the compiler flag.

libcxx/test/libcxx/module_std.sh.cpp

7 ↗

(On Diff #527066)

This file will be removed a module_std.gen.py is available. It's still here since the new file is not tested in the CI yet.

[Mordante]

Addresses review comments
Rewritten the module verification test, using the new generated lit style.

[Mordante]

CI fixes.

[ChuanqiXu]

LGTM now. Thanks!

[ldionne]

Thanks, this looks really good but I recorded the discussion we had just now in comments.

libcxx/test/libcxx/module_std.gen.py

47

I would make this a list, and then use ' '.join(SkipDeclarations[header] when you need to output it.

59–61

I really question what black is doing here with formatting. I don't think this is sensible:

SkipDeclarations[
    "filesystem"
]

If that's what the tool generates, I argue the tool's not configured properly.

[ldionne]

libcxx/docs/Modules.rst

59

74–76

95–96

110–111

libcxx/docs/ReleaseNotes.rst

114–120

I would move this to Build System Changes. Also, I think we can just change it, no need for a deprecation period here. We can consider our Lit test suite as something internal -- even though some vendors may have to make a few changes, those are easy to make and they don't affect end-users. Let's not go through more hoops than we need to.

139–141

This can go.

libcxx/test/libcxx/module_std.gen.py

67

92–94

96

129

This makes it a bit clearer what the file contains.

151

157

158

I think you can just test for if skip_declarations since an empty list/string is false-y in Python.

162

195

224–230

I don't think this is needed at all.

libcxx/test/libcxx/modules_include.sh.cpp

1 ↗

(On Diff #528202)

I think you need to rebase onto main.

libcxx/test/tools/clang_tidy_checks/header_exportable_declarations.cpp

24

61–70

We should figure out why std::views::split(*list, ' ') stopped working at some point and use that instead. You can loop in @var-const when you have a reproducer. Ditto below.

If this ends up needing a fix in <ranges>, I won't block the review on this comment of course but it would be nice to at least see if it's just a dumb mistake.

135

Per our discussion, I don't think this is an issue.

181–190

I think we can do

return name.starts_with("std::__") || (name.starts_with("std::_) && std::isupper(name[6]));

libcxx/test/tools/clang_tidy_checks/header_exportable_declarations.hpp

12

I think we should IWYU properly here.

17

IDK what's the usual convention here, but do we want this to be explicit?

libcxx/utils/ci/buildkite-pipeline.yml

149

libcxx/utils/ci/run-buildbot

418–419

Can we do this in buildkite-pipeline.yml instead? Otherwise we can't run this job locally.

libcxx/utils/generate_header_tests.py

76 ↗

(On Diff #528202)

This will go away upon rebasing.

libcxx/utils/libcxx/test/dsl.py

446

448

libcxx/utils/libcxx/test/params.py

83–87

Not necessary.

132–136

I think we could simplify the CMake/Lit integration quite a bit by instead just building the BMIs from the top-level CMake invocation instead of from within Lit itself. Then we'd only need to pass the value for -fprebuilt-module-path to Lit and we wouldn't need AddModule(), the bridge changes, and also we might not need to use absolute paths everywhere.

I think this is worth investigating since it would simplify this patch quite a bit.

[Mordante]

Thanks for the reviews!

libcxx/test/libcxx/module_std.gen.py

59–61

It's indeed black's doing. Changing this to lists improves the formatting.

92–94

I just added it directly to the list, without an append. The comment can be in the list.

157

This doesn't work, it might try to add [] to a string.
Instead I assigned the joined list to skip_declarations.

libcxx/test/libcxx/modules_include.sh.cpp

1 ↗

(On Diff #528202)

I will do that shortly before our next review, then I can move the changes to the .cppm files in their own review.

libcxx/test/tools/clang_tidy_checks/header_exportable_declarations.cpp

61–70

Odd taking the code from D144994 now works again :-/ I didn't investigate why. I much rather use that code, there is a reason why I used that code in the first place.

181–190

I tried that and it doesn't work. Three are elements in std::ranges too. I updated the comment.

libcxx/utils/ci/buildkite-pipeline.yml

149

As mention during review I kept std in the name since std.compat needs its own job.

libcxx/utils/libcxx/test/dsl.py

446–447

@aaronmondal actually I think I know what the issue is. CMake does not know CMAKE_CXX_STANDARD 26. The current development version of CMake has this support for Clang.

libcxx/utils/libcxx/test/params.py

132–136

I tried that and it doesn't work. The module needs to be build with the flags given to lit and the standard version used. Since this can change when lit is invoked we need to do that during the test.

What I did is building a module from CMake and then rebuilt it from the lit test. That way I need 2 instead of 4 new elements in the bridge. I feel the {modules} directory is not too bad to have, it matches {includes}. Only CMake is an oddity, I hope/expect that can be removed once CMake has proper module support.

[Mordante]

Addresses review comments.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

Adds some notes for reviewing.

libcxx/test/tools/clang_tidy_checks/header_exportable_declarations.cpp

61–70

I turns out that this code isn't compiled against libc++, but against the system C++ library. So that might explain the earlier failure I saw; I probably tested it on a system with an older GCC. (I noticed it when looking at the output of the most recent CI failure.)

62

The code is not used for Clang < 17 since these compilers lack module support. However there is a working implementation for these versions of Clang. The original code fails in https://buildkite.com/llvm-project/libcxx-ci/builds/25748. Since we'll drop LLVM 15 support rather soon, I prefer this work-around for the short term.

Looking at the build log, it seems to be an issue with concepts:

clang_tidy_checks/header_exportable_declarations.cpp:9:

In file included from /usr/lib/llvm-17/include/clang-tidy/ClangTidyCheck.h:12:

In file included from /usr/lib/llvm-17/include/clang-tidy/ClangTidyDiagnosticConsumer.h:12:

In file included from /usr/lib/llvm-17/include/clang-tidy/ClangTidyOptions.h:12:

In file included from /usr/lib/llvm-17/include/llvm/ADT/IntrusiveRefCntPtr.h:66:

In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/13/../../../../include/c++/13/memory:66:

In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/13/../../../../include/c++/13/bits/stl_tempbuf.h:61:

In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/13/../../../../include/c++/13/bits/stl_construct.h:61:

In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/13/../../../../include/c++/13/bits/stl_iterator_base_types.h:71:

/usr/bin/../lib/gcc/x86_64-linux-gnu/13/../../../../include/c++/13/bits/iterator_concepts.h:999:13: error: no matching function for call to '__begin'

        = decltype(ranges::__cust_access::__begin(std::declval<_Tp&>()));

                   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

/usr/bin/../lib/gcc/x86_64-linux-gnu/13/../../../../include/c++/13/bits/ranges_base.h:513:5: note: in instantiation of template type alias '__range_iter_t' requested here

    using iterator_t = std::__detail::__range_iter_t<_Tp>;

    ^

/usr/bin/../lib/gcc/x86_64-linux-gnu/13/../../../../include/c++/13/bits/ranges_util.h:131:36: note: in instantiation of template type alias 'iterator_t' requested here

      requires contiguous_iterator<iterator_t<_Derived>>

                                   ^

/usr/bin/../lib/gcc/x86_64-linux-gnu/13/../../../../include/c++/13/ranges:1134:29: note: in instantiation of template class 'std::ranges::view_interface<std::ranges::ref_view<llvm::StringRef>>' requested here

    class ref_view : public view_interface<ref_view<_Range>>

                            ^

/usr/bin/../lib/gcc/x86_64-linux-gnu/13/../../../../include/c++/13/ranges:1269:38: note: in instantiation of template class 'std::ranges::ref_view<llvm::StringRef>' requested here

        concept __can_ref_view = requires { ref_view{std::declval<_Range>()}; };

                                            ^

/usr/bin/../lib/gcc/x86_64-linux-gnu/13/../../../../include/c++/13/ranges:1269:38: note: in instantiation of requirement here

        concept __can_ref_view = requires { ref_view{std::declval<_Range>()}; };

                                            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

/usr/bin/../lib/gcc/x86_64-linux-gnu/13/../../../../include/c++/13/ranges:1269:27: note: (skipping 8 contexts in backtrace; use -ftemplate-backtrace-limit=0 to see all)

        concept __can_ref_view = requires { ref_view{std::declval<_Range>()}; };

                                 ^

/usr/bin/../lib/gcc/x86_64-linux-gnu/13/../../../../include/c++/13/ranges:3717:6: note: while substituting template arguments into constraint expression here

          = requires { split_view(std::declval<_Range>(), std::declval<_Pattern>()); };

            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

/usr/bin/../lib/gcc/x86_64-linux-gnu/13/../../../../include/c++/13/ranges:3723:11: note: while checking the satisfaction of concept '__can_split_view<llvm::StringRef &, char>' requested here

        requires __detail::__can_split_view<_Range, _Pattern>

                 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

/usr/bin/../lib/gcc/x86_64-linux-gnu/13/../../../../include/c++/13/ranges:3723:11: note: while substituting template arguments into constraint expression here

        requires __detail::__can_split_view<_Range, _Pattern>

                 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

[Mordante]

libcxx/modules/std/string.cppm

74

Except for this change all other changes in this directory should be in a separate commit. For now I keep them here. @H-G-Hristov is making great progress on P1614 (the spaceship paper). This means a lot of changes to the to the modules. After this patch is accepted I will coordinate with @H-G-Hristov regarding splitting this patch and avoid conflicts with the spaceship patches.

[Mordante]

Rebased.
Added CMake 3.27 suppprt, by adding the new experimental UUID.
Fixed the changes in the upstream headers. The ongoing spaceship patches change
a lot of modules.

[Mordante]

CI fixes

[ldionne]

This pretty much looks good to me. I'd like to see it one last time after applying the comments but I think we can ship it once those comments have been applied. Thanks for all the work you did on this!

libcxx/docs/index.rst

122–126

I think I would drop this note. Modules are very experimental at the moment, and adding a ref to that from our main documentation seems unnecessary and perhaps even undesirable.

libcxx/modules/CMakeLists.txt.in

42–44

This has been rolled up into LIBCXX_ENABLE_FILESYSTEM now, so LIBCXX_ENABLE_FSTREAM doesn't exist anymore.

libcxx/test/tools/clang_tidy_checks/header_exportable_declarations.cpp

61–70

The question at hand is really what version of standard libraries do we support in our build tools. We've never had that question because we have very little C++ in our build tools (only the clang tidy checks) -- everything else is pretty much Python. I think what we want to do here is enforce that our build tools (that means anything we use in order to build or test the library) are written using the following requirements:

1. C++17 (like the rest of non-libc++ LLVM)
2. The compilers supported by libc++ (which are stricter than those supported by LLVM)
3. The standard libraries supported by the rest of non-libc++ LLVM

Concretely, this means that we basically lower all of our restrictions to be the same as non-libc++ LLVM for our build tools. I think this makes sense and should have little impact on us.

We could document that under tools/README.md or in our other rst documentation around contributing. Let's make it clear that this is only for build tools, though. I would also do this on a best effort basis, i.e. I wouldn't go crazy and try to add a build job that checks our minimum requirement, that seems overkill (especially given the load on our CI).

libcxx/utils/libcxx/test/dsl.py

440

462–463

libcxx/utils/libcxx/test/params.py

128

I don't think this comment is relevant anymore.

141–146

I think what you meant here is AddLinkFlag(os.path.join(cfg.test_exec_root, "__config_module__/libc++std.a")).

Also, it would be interesting to understand why your tests worked without linking against the std module as-is.

[Mordante]

In D151814#4417987, @ldionne wrote:

This pretty much looks good to me. I'd like to see it one last time after applying the comments but I think we can ship it once those comments have been applied. Thanks for all the work you did on this!

Thanks a lot for your review!

libcxx/test/tools/clang_tidy_checks/header_exportable_declarations.cpp

61–70

I will do that in a followup patch.

libcxx/utils/libcxx/test/params.py

141–146

It seems to work without it. It might be something was/is needed for the std.compat module. For now I removed it.

[Mordante]

Rebased.
Removed more operator!=
Addresses review comments

[ldionne]

libcxx/test/libcxx/modules_include.gen.py

17

We should clean up the naming of these files in a separate patch to make it clear what's testing C++20 modules and what's testing Clang modules.

[Mordante]

libcxx/modules/std/string.cppm

74

I checked there are no open operator!= patches.

libcxx/test/libcxx/modules_include.gen.py

17

Good point. I'll make a followup patch for the renaming after landing this patch.

[Mordante]

libcxx/test/libcxx/modules_include.gen.py

17

I've created D153042

libcxx/test/tools/clang_tidy_checks/header_exportable_declarations.cpp

61–70

I've created D152377.

[ldionne]

libcxx/test/tools/clang_tidy_checks/header_exportable_declarations.cpp

61–70

I think that's referencing the wrong patch.

libcxx/CMakeLists.txt

 option(LIBCXX_ENABLE_VENDOR_AVAILABILITY_ANNOTATIONS
   "Whether to turn on vendor availability annotations on declarations that depend
    on definitions in a shared library. By default, we assume that we're not building
    libc++ for any specific vendor, and we disable those annotations. Vendors wishing
    to provide compile-time errors when using features unavailable on some version of
    the shared library they shipped should turn this on and see `include/__availability`
    for more details." OFF)
 option(LIBCXX_ENABLE_CLANG_TIDY "Whether to compile and run clang-tidy checks" OFF)
+# TODO MODULES Remove this option and test for the requirements (CMake/Clang) instead.
+option(LIBCXX_ENABLE_STD_MODULES
+   "Whether to enable the building the C++23 `std` module. This feature is
+    experimental and has additional dependencies. Only enable this when
+    interested in testing or developing this module. See
+    https://libcxx.llvm.org/Modules.html for more information." OFF)
 
 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
   set(LIBCXX_DEFAULT_TEST_CONFIG "llvm-libc++-shared-gcc.cfg.in")
 elseif(MINGW)
   set(LIBCXX_DEFAULT_TEST_CONFIG "llvm-libc++-mingw.cfg.in")
 elseif(WIN32) # clang-cl
   if (LIBCXX_ENABLE_SHARED)
     set(LIBCXX_DEFAULT_TEST_CONFIG "llvm-libc++-shared-clangcl.cfg.in")
set(LIBCXX_INSTALL_RUNTIME_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH
     "Path where built libc++ runtime libraries should be installed.")
 
 set(LIBCXX_SHARED_OUTPUT_NAME "c++" CACHE STRING "Output name for the shared libc++ runtime library.")
 set(LIBCXX_STATIC_OUTPUT_NAME "c++" CACHE STRING "Output name for the static libc++ runtime library.")
 
 if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)
   set(LIBCXX_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}/${LLVM_DEFAULT_TARGET_TRIPLE})
   set(LIBCXX_GENERATED_INCLUDE_DIR "${LLVM_BINARY_DIR}/include/c++/v1")
+  set(LIBCXX_GENERATED_MODULE_DIR "${LLVM_BINARY_DIR}/modules/c++/v1")
   set(LIBCXX_GENERATED_INCLUDE_TARGET_DIR "${LLVM_BINARY_DIR}/include/${LLVM_DEFAULT_TARGET_TRIPLE}/c++/v1")
   set(LIBCXX_INSTALL_LIBRARY_DIR lib${LLVM_LIBDIR_SUFFIX}/${LLVM_DEFAULT_TARGET_TRIPLE} CACHE PATH
       "Path where built libc++ libraries should be installed.")
   set(LIBCXX_INSTALL_INCLUDE_TARGET_DIR "${CMAKE_INSTALL_INCLUDEDIR}/${LLVM_DEFAULT_TARGET_TRIPLE}/c++/v1" CACHE PATH
       "Path where target-specific libc++ headers should be installed.")
   if(LIBCXX_LIBDIR_SUBDIR)
     string(APPEND LIBCXX_LIBRARY_DIR /${LIBCXX_LIBDIR_SUBDIR})
     string(APPEND LIBCXX_INSTALL_LIBRARY_DIR /${LIBCXX_LIBDIR_SUBDIR})
   endif()
 else()
   if(LLVM_LIBRARY_OUTPUT_INTDIR)
     set(LIBCXX_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR})
     set(LIBCXX_GENERATED_INCLUDE_DIR "${LLVM_BINARY_DIR}/include/c++/v1")
+    set(LIBCXX_GENERATED_MODULE_DIR "${LLVM_BINARY_DIR}/modules/c++/v1")
   else()
     set(LIBCXX_LIBRARY_DIR ${CMAKE_BINARY_DIR}/lib${LIBCXX_LIBDIR_SUFFIX})
     set(LIBCXX_GENERATED_INCLUDE_DIR "${CMAKE_BINARY_DIR}/include/c++/v1")
+    set(LIBCXX_GENERATED_MODULE_DIR "${CMAKE_BINARY_DIR}/modules/c++/v1")
   endif()
   set(LIBCXX_GENERATED_INCLUDE_TARGET_DIR "${LIBCXX_GENERATED_INCLUDE_DIR}")
   set(LIBCXX_INSTALL_LIBRARY_DIR lib${LIBCXX_LIBDIR_SUFFIX} CACHE PATH
       "Path where built libc++ libraries should be installed.")
   set(LIBCXX_INSTALL_INCLUDE_TARGET_DIR "${LIBCXX_INSTALL_INCLUDE_DIR}" CACHE PATH
       "Path where target-specific libc++ headers should be installed.")
 endif()
 

 endfunction()
 
 #===============================================================================
 # Setup Source Code And Tests
 #===============================================================================
 add_subdirectory(include)
 add_subdirectory(src)
 add_subdirectory(utils)
+if (LIBCXX_ENABLE_STD_MODULES)
+  add_subdirectory(modules)
+endif()
 
 set(LIBCXX_TEST_DEPS "cxx_experimental")
 
 if (LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY)
   list(APPEND LIBCXX_TEST_DEPS cxx_external_threads)
 endif()
 
 if (LIBCXX_ENABLE_CLANG_TIDY)
   list(APPEND LIBCXX_TEST_DEPS cxx-tidy)
 endif()
 
+if (LIBCXX_ENABLE_STD_MODULES)
+  list(APPEND LIBCXX_TEST_DEPS generate-cxx-modules generate-test-module-std)
+endif()
+
 if (LIBCXX_INCLUDE_BENCHMARKS)
   add_subdirectory(benchmarks)
 endif()
 
 if (LIBCXX_INCLUDE_TESTS)
   add_subdirectory(test)
   add_subdirectory(lib/abi)
 endif()
 
 if (LIBCXX_INCLUDE_DOCS)
   add_subdirectory(docs)
 endif()

libcxx/cmake/caches/Generic-module-std-cxx23.cmake

+set(LIBCXX_ENABLE_STD_MODULES ON CACHE BOOL "")
+set(LIBCXX_TEST_PARAMS "enable_modules=std;std=c++23" CACHE STRING "")
+set(LIBCXXABI_TEST_PARAMS "std=c++23" CACHE STRING "")
+

libcxx/cmake/caches/Generic-modules-lsv.cmake

-set(LIBCXX_TEST_PARAMS "enable_modules=True;enable_modules_lsv=True" CACHE STRING "")
+set(LIBCXX_TEST_PARAMS "enable_modules=clang;enable_modules_lsv=True" CACHE STRING "")
 set(LIBCXXABI_TEST_PARAMS "${LIBCXX_TEST_PARAMS}" CACHE STRING "")

libcxx/cmake/caches/Generic-modules.cmake

-set(LIBCXX_TEST_PARAMS "enable_modules=True" CACHE STRING "")
+set(LIBCXX_TEST_PARAMS "enable_modules=clang" CACHE STRING "")
 set(LIBCXXABI_TEST_PARAMS "${LIBCXX_TEST_PARAMS}" CACHE STRING "")

libcxx/docs/Contributing.rst

 
 Before committing or creating a review, please go through this check-list to make
 sure you don't forget anything:
 
 - Do you have :ref:`tests <testing>` for every public class and/or function you're adding or modifying?
 - Did you update the synopsis of the relevant headers?
 - Did you update the relevant files to track implementation status (in ``docs/Status/``)?
 - Did you mark all functions and type declarations with the :ref:`proper visibility macro <visibility-macros>`?
+- Did you add all new named declarations to the ``std`` module?
 - If you added a header:
 
   - Did you add it to ``include/module.modulemap.in``?
   - Did you add it to ``include/CMakeLists.txt``?
   - If it's a public header, did you update ``utils/libcxx/test/header_information.py``?
 
 - Did you add the relevant feature test macro(s) for your feature? Did you update the ``generate_feature_test_macro_components.py`` script with it?
 - Did you run the ``libcxx-generate-files`` target and verify its output?

libcxx/docs/Modules.rst

+.. _ModulesInLibcxx:
+
+=================
+Modules in libc++
+=================
+
+.. warning:: Modules are an experimental feature. It has additional build
+             requirements and not all libc++ configurations are supported yet.
+
+             The work is still in an early developement state and not
+             considered stable nor complete
+
+This page contains information regarding C++23 module support in libc++.
+There are two kinds of modules available in Clang
+
+ * `Clang specific modules <https://clang.llvm.org/docs/Modules.html>`_
+ * `C++ modules <https://clang.llvm.org/docs/StandardCPlusPlusModules.html>`_
+
+This page mainly discusses the C++ modules. In C++20 there are also header units,
+these are not part of this document.
+
+Overview
+========
+
+The module sources are stored in ``.cppm`` files. Modules need to be available
+as BMIs, which are ``.pcm`` files for Clang. BMIs are not portable, they depend
+on the compiler used and its compilation flags. Therefore there needs to be a
+way to distribute the ``.cppm`` files to the user and offer a way for them to
+build and use the ``.pcm`` files. It is expected this will be done by build
+systems in the future. To aid early adaptor and build system vendors libc++
+currently ships a CMake project to aid building modules.
+
+.. note:: This CMake file is intended to be a temporary solution and will
+          be removed in the future. The timeline for the removal depends
+          on the availability of build systems with proper module support.
+
+What works
+~~~~~~~~~~
+
+ * Building BMIs
+ * Running tests using the ``std`` module
+ * Using the ``std`` module in external projects
+ * The following "parts disabled" configuration options are supported
+
+   * ``LIBCXX_ENABLE_LOCALIZATION``
+   * ``LIBCXX_ENABLE_WIDE_CHARACTERS``
+
+Some of the current limitations
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ * There is no official build system support, libc++ has experimental CMake support
+ * Requires CMake 3.26
+ * Requires Ninja 1.11
+ * Requires a recent Clang 17
+ * The path to the compiler may not be a symlink, ``clang-scan-deps`` does
+   not handle that case properly
+ * Only C++23 is tested
+ * Libc++ is not tested with modules instead of headers
+ * The module ``.cppm`` files are not installed
+ * The experimental ``PSTL`` library is not supported
+ * Clang supports modules using GNU extensions, but libc++ does not work using
+   GNU extensions.
+ * Clang:
+    * Including headers after importing the ``std`` module may fail. This is
+      hard to solve and there is a work-around by first including all headers
+      `bug report <https://github.com/llvm/llvm-project/issues/61465>`__.
+
+Blockers
+~~~~~~~~
+
+  * libc++
+
+    * Currently the tests only test with modules enabled, but do not import
+      modules instead of headers. When converting tests to using modules there
+      are still failures. These are under investigation.
+
+    * It has not been determined how to fully test libc++ with modules instead
+      of headers.
+
+  * Clang
+
+    * Some concepts do not work properly
+      `bug report <https://github.com/llvm/llvm-project/issues/62943>`__.
+
+
+Using in external projects
+==========================
+
+Users need to be able to build their own BMI files.
+
+.. note:: The requirements for users to build their own BMI files will remain
+   true for the forseeable future. For now this needs to be done manually.
+   Once libc++'s implementation is more mature we will reach out to build
+   system vendors, with the goal that building the BMI files is done by
+   the build system.
+
+Currently this requires a local build of libc++ with modules enabled. Since
+modules are not part of the installation yet, they are used from the build
+directory. First libc++ needs to be build with module support enabled.
+
+.. code-block:: bash
+
+  $ git clone https://github.com/llvm/llvm-project.git
+  $ cd llvm-project
+  $ mkdir build
+  $ cmake -G Ninja -S runtimes -B build -DLIBCXX_ENABLE_STD_MODULES=ON -DLLVM_ENABLE_RUNTIMES="libcxx;libcxxabi;libunwind"
+  $ ninja -C build
+
+The above ``build`` directory will be referred to as ``<build>`` in the
+rest of these instructions.
+
+This is a small sample program that uses the module ``std``. It consists of a
+``CMakeLists.txt`` and a ``main.cpp`` file.
+
+.. code-block:: cpp
+
+  import std;
+
+  int main() { std::cout << "Hello modular world\n"; }
+
+.. code-block:: cmake
+
+  cmake_minimum_required(VERSION 3.26.0 FATAL_ERROR)
+  project("module"
+    LANGUAGES CXX
+  )
+
+  #
+  # Set language version used
+  #
+
+  # At the moment only C++23 is tested.
+  set(CMAKE_CXX_STANDARD 23)
+  set(CMAKE_CXX_STANDARD_REQUIRED YES)
+  # Libc++ doesn't support compiler extensions for modules.
+  set(CMAKE_CXX_EXTENSIONS OFF)
+
+  #
+  # Enable modules in CMake
+  #
+
+  # This is required to write your own modules in your project.
+  if(CMAKE_VERSION VERSION_LESS "3.27.0")
+    set(CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API "2182bf5c-ef0d-489a-91da-49dbc3090d2a")
+  else()
+    set(CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API "aa1f7df0-828a-4fcd-9afc-2dc80491aca7")
+  endif()
+  set(CMAKE_EXPERIMENTAL_CXX_MODULE_DYNDEP 1)
+
+  #
+  # Import the modules from libc++
+  #
+
+  include(FetchContent)
+  FetchContent_Declare(
+    std
+    URL "file://${LIBCXX_BUILD}/modules/c++/v1/"
+    DOWNLOAD_EXTRACT_TIMESTAMP TRUE
+  )
+  FetchContent_GetProperties(std)
+  if(NOT std_POPULATED)
+    FetchContent_Populate(std)
+    add_subdirectory(${std_SOURCE_DIR} ${std_BINARY_DIR} EXCLUDE_FROM_ALL)
+  endif()
+
+  #
+  # Adjust project compiler flags
+  #
+
+  add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-fprebuilt-module-path=${CMAKE_BINARY_DIR}/_deps/std-build/CMakeFiles/std.dir/>)
+  add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-nostdinc++>)
+  # The include path needs to be set to be able to use macros from headers.
+  # For example from, the headers <cassert> and <version>.
+  add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-isystem>)
+  add_compile_options($<$<COMPILE_LANGUAGE:CXX>:${LIBCXX_BUILD}/include/c++/v1>)
+
+  #
+  # Adjust project linker flags
+  #
+
+  add_link_options($<$<COMPILE_LANGUAGE:CXX>:-nostdlib++>)
+  add_link_options($<$<COMPILE_LANGUAGE:CXX>:-L${LIBCXX_BUILD}/lib>)
+  add_link_options($<$<COMPILE_LANGUAGE:CXX>:-Wl,-rpath,${LIBCXX_BUILD}/lib>)
+  # Linking against std is required for CMake to get the proper dependencies
+  link_libraries(std c++)
+
+  #
+  # Add the project
+  #
+
+  add_executable(main)
+  target_sources(main
+    PRIVATE
+      main.cpp
+  )
+
+Building this project is done with the following steps, assuming the files
+``main.cpp`` and ``CMakeLists.txt`` are copied in the current directory.
+
+.. code-block:: bash
+
+  $ mkdir build
+  $ cmake -G Ninja -S . -B build -DCMAKE_CXX_COMPILER=<path-to-compiler> -DLIBCXX_BUILD=<build>
+  $ ninja -C build
+  $ build/main
+
+.. warning:: ``<path-to-compiler>`` should point point to the real binary and
+             not to a symlink.
+
+.. warning:: When using these examples in your own projects make sure the
+             compilation flags are the same for the ``std`` module and your
+             project. Some flags will affect the generated code, when these
+             are different the module cannot be used. For example using
+             ``-pthread`` in your project and not in the module will give
+             errors like
+
+             ``error: POSIX thread support was disabled in PCH file but is currently enabled``
+
+             ``error: module file _deps/std-build/CMakeFiles/std.dir/std.pcm cannot be loaded due to a configuration mismatch with the current compilation [-Wmodule-file-config-mismatch]``
+
+If you have questions about modules free free to ask them in the ``#libcxx``
+channel on `LLVM's Discord server <https://discord.gg/jzUbyP26tQ>`__.
+
+If you think you've found a bug please it using the `LLVM bug tracker
+<https://github.com/llvm/llvm-project/issues>`_. Please make sure the issue
+you found is not one of the known bugs or limitations on this page.

libcxx/docs/ReleaseNotes.rst

 Note that if you are reading this file from a Git checkout or the
 main Libc++ web page, this document applies to the *next* release, not
 the current one. To see the release notes for a specific release, please
 see the `releases page <https://llvm.org/releases/>`_.
 
 What's New in Libc++ 17.0.0?
 ============================
 
+There is an experimental implementation of the C++23 ``std`` module. See
+:ref:`ModulesInLibcxx` for more information.
+
 Implemented Papers
 ------------------
 - P2520R0 - ``move_iterator<T*>`` should be a random access iterator
 - P1328R1 - ``constexpr type_info::operator==()``
 - P1413R3 - Formatting ``thread::id`` (the ``stacktrace`` is not done yet)
 - P2675R1 - ``format``'s width estimation is too approximate and not forward compatible
 - P2505R5 - Monadic operations for ``std::expected``
 - P2711R1 - Making Multi-Param Constructors Of views explicit (``join_with_view`` is not done yet)
- Libc++ used to provide some C++11 tag type global variables in C++03 as an extension, which are removed in
   which led to ODR violations when mixed with the C++03 definition. Cleaning this up is required for libc++ to
   make progress on support for C++20 modules.
 
 - The ``_LIBCPP_ABI_OLD_LOGNORMAL_DISTRIBUTION`` macro has been removed.
 
 - The classes ``strstreambuf`` , ``istrstream``, ``ostrstream``, and ``strstream`` have been deprecated.
   They have been deprecated in the Standard since C++98, but were never marked as deprecated in libc++.
 
 Upcoming Deprecations and Removals
 ----------------------------------
 
 LLVM 18
 ~~~~~~~
 
 - The base template for ``std::char_traits`` has been marked as deprecated and
   will be removed in LLVM 18. If you are using ``std::char_traits`` with types
   other than ``char``, ``wchar_t``, ``char8_t``, ``char16_t``, ``char32_t`` or
   a custom character type for which you specialized ``std::char_traits``, your code
   will stop working when we remove the base template. The Standard does not
   mandate that a base template is provided, and such a base template is bound
   to be incorrect for some types, which could currently cause unexpected
   behavior while going undetected.
 
 - The ``_LIBCPP_AVAILABILITY_CUSTOM_VERBOSE_ABORT_PROVIDED`` macro will not be honored anymore in LLVM 18.
   Please see the updated documentation about the safe libc++ mode and in particular the ``_LIBCPP_VERBOSE_ABORT``
   macro for details.
 
 - The headers ``<experimental/deque>``, ``<experimental/forward_list>``, ``<experimental/list>``,
   ``<experimental/map>``, ``<experimental/memory_resource>``, ``<experimental/regex>``, ``<experimental/set>``,
   ``<experimental/string>``, ``<experimental/unordered_map>``, ``<experimental/unordered_set>``,
   and ``<experimental/vector>`` will be removed in LLVM 18, as all their contents will have been implemented in
   namespace ``std`` for at least two releases.
 
 API Changes
 -----------
 
 ABI Affecting Changes
 ---------------------
 
 - Symbols for ``std::allocator_arg``, ``std::defer_lock``, ``std::try_to_lock``, ``std::adopt_lock``, and
   ``std::piecewise_construct`` have been removed from the built library. Under most circumstances, user code
   should not have been relying on those symbols anyway since those are empty classes and the compiler does
   not generate an undefined reference unless the address of the object is taken. However, this is an ABI break
   if the address of one of these objects has been taken in code compiled as C++03, since in those cases the

 
 - ``LIBCXX_ENABLE_FILESYSTEM`` now represents whether a filesystem is supported on the platform instead
   of representing merely whether ``<filesystem>`` should be provided. This means that vendors building
   with ``LIBCXX_ENABLE_FILESYSTEM=OFF`` will now also get ``<fstream>`` excluded from their configuration
   of the library.
 
 - ``LIBCXX_ENABLE_FSTREAM`` is not supported anymore, please use ``LIBCXX_ENABLE_FILESYSTEM=OFF`` if your
   platform does not have support for a filesystem.
+
+- The lit test parameter ``enable_modules`` changed from a Boolean to an enum. The changes are
+
+  - ``False`` became ``none``. This option does not test with modules enabled.
+  - ``True`` became ``clang``. This option tests using Clang modules.
+  - ``std`` is a new optional and tests with the experimental C++23 ``std`` module.

libcxx/docs/index.rst

 .. toctree::
    :maxdepth: 1
 
    ReleaseNotes
    UsingLibcxx
    BuildingLibcxx
    TestingLibcxx
    Contributing
+   Modules
    ReleaseProcedure
    Status/Cxx14
    Status/Cxx17
    Status/Cxx20
    Status/Cxx23
    Status/Cxx2c
    Status/Format
    Status/Parallelism

 Compiler     Versions        Restrictions               Support policy
 ============ =============== ========================== =====================
 Clang        15, 16, 17-git                             latest two stable releases per `LLVM's release page <https://releases.llvm.org>`_ and the development version
 AppleClang   14                                         latest stable release per `Xcode's release page <https://developer.apple.com/documentation/xcode-release-notes>`_
 Open XL      17.1 (AIX)                                 latest stable release per `Open XL's documentation page <https://www.ibm.com/docs/en/openxl-c-and-cpp-aix>`_
 GCC          12              In C++11 or later only     latest stable release per `GCC's release page <https://gcc.gnu.org/releases.html>`_
 ============ =============== ========================== =====================
 
 Libc++ also supports common platforms and architectures:
 
 =============== ========================= ============================
 Target platform Target architecture       Notes
 =============== ========================= ============================
 macOS 10.9+     i386, x86_64, arm64       Building the shared library itself requires targetting macOS 10.13+
 FreeBSD 12+     i386, x86_64, arm
 Linux           i386, x86_64, arm, arm64  Only glibc-2.24 and later and no other libc is officially supported
 Windows         i386, x86_64              Both MSVC and MinGW style environments, ABI in MSVC environments is :doc:`unstable <DesignDocs/ABIVersioning>`
 AIX 7.2TL5+     powerpc, powerpc64
 =============== ========================= ============================
 
 Generally speaking, libc++ should work on any platform that provides a fairly complete

libcxx/modules/.clang-format

+BasedOnStyle: InheritParentConfig
+
+NamespaceIndentation: All

libcxx/modules/CMakeLists.txt

+if (CMAKE_VERSION VERSION_LESS 3.26)
+  message(WARNING "The libc++ modules won't be available because the CMake version is too old. Update to CMake 3.26 or later.")
+  return()
+endif()
+
+# The headers of Table 24: C++ library headers [tab:headers.cpp]
+# and the headers of Table 25: C++ headers for C library facilities [tab:headers.cpp.c]
+set(LIBCXX_SOURCES_MODULE_STD
+  std.cppm
+  std/algorithm.cppm
+  std/any.cppm
+  std/array.cppm
+  std/atomic.cppm
+  std/barrier.cppm
+  std/bit.cppm
+  std/bitset.cppm
+  std/cassert.cppm
+  std/cctype.cppm
+  std/cerrno.cppm
+  std/cfenv.cppm
+  std/cfloat.cppm
+  std/charconv.cppm
+  std/chrono.cppm
+  std/cinttypes.cppm
+  std/climits.cppm
+  std/clocale.cppm
+  std/cmath.cppm
+  std/codecvt.cppm
+  std/compare.cppm
+  std/complex.cppm
+  std/concepts.cppm
+  std/condition_variable.cppm
+  std/coroutine.cppm
+  std/csetjmp.cppm
+  std/csignal.cppm
+  std/cstdarg.cppm
+  std/cstddef.cppm
+  std/cstdint.cppm
+  std/cstdio.cppm
+  std/cstdlib.cppm
+  std/cstring.cppm
+  std/ctime.cppm
+  std/cuchar.cppm
+  std/cwchar.cppm
+  std/cwctype.cppm
+  std/deque.cppm
+  std/exception.cppm
+  std/execution.cppm
+  std/expected.cppm
+  std/filesystem.cppm
+  std/flat_map.cppm
+  std/flat_set.cppm
+  std/format.cppm
+  std/forward_list.cppm
+  std/fstream.cppm
+  std/functional.cppm
+  std/future.cppm
+  std/generator.cppm
+  std/initializer_list.cppm
+  std/iomanip.cppm
+  std/ios.cppm
+  std/iosfwd.cppm
+  std/iostream.cppm
+  std/iostream.cppm
+  std/istream.cppm
+  std/iterator.cppm
+  std/latch.cppm
+  std/limits.cppm
+  std/list.cppm
+  std/locale.cppm
+  std/map.cppm
+  std/mdspan.cppm
+  std/memory.cppm
+  std/memory_resource.cppm
+  std/mutex.cppm
+  std/new.cppm
+  std/numbers.cppm
+  std/numeric.cppm
+  std/optional.cppm
+  std/ostream.cppm
+  std/print.cppm
+  std/queue.cppm
+  std/random.cppm
+  std/ranges.cppm
+  std/ratio.cppm
+  std/regex.cppm
+  std/scoped_allocator.cppm
+  std/semaphore.cppm
+  std/set.cppm
+  std/shared_mutex.cppm
+  std/source_location.cppm
+  std/span.cppm
+  std/spanstream.cppm
+  std/sstream.cppm
+  std/stack.cppm
+  std/stacktrace.cppm
+  std/stdexcept.cppm
+  std/stdexcept.cppm
+  std/stdfloat.cppm
+  std/stop_token.cppm
+  std/streambuf.cppm
+  std/string.cppm
+  std/string_view.cppm
+  std/strstream.cppm
+  std/syncstream.cppm
+  std/system_error.cppm
+  std/thread.cppm
+  std/tuple.cppm
+  std/type_traits.cppm
+  std/typeindex.cppm
+  std/typeinfo.cppm
+  std/unordered_map.cppm
+  std/unordered_set.cppm
+  std/utility.cppm
+  std/valarray.cppm
+  std/variant.cppm
+  std/vector.cppm
+  std/version.cppm
+)
+
+# TODO MODULES the CMakeLists.txt in the install directory is only temporary
+# When that is removed the configured file can use the substitution
+# LIBCXX_GENERATED_INCLUDE_TARGET_DIR avoiding this set.
+# Also clean up the parts needed to generate the install version.
+set(LIBCXX_CONFIGURED_INCLUDE_DIR ${LIBCXX_GENERATED_INCLUDE_TARGET_DIR})
+configure_file(
+  "CMakeLists.txt.in"
+  "${LIBCXX_GENERATED_MODULE_DIR}/CMakeLists.txt"
+  @ONLY
+)
+
+set(_all_modules "${LIBCXX_GENERATED_MODULE_DIR}/CMakeLists.txt")
+foreach(file ${LIBCXX_SOURCES_MODULE_STD})
+  set(src "${CMAKE_CURRENT_SOURCE_DIR}/${file}")
+  set(dst "${LIBCXX_GENERATED_MODULE_DIR}/${file}")
+  add_custom_command(OUTPUT ${dst}
+    DEPENDS ${src}
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src} ${dst}
+    COMMENT "Copying CXX module ${file}")
+  list(APPEND _all_modules "${dst}")
+endforeach()
+
+add_custom_target(generate-cxx-modules
+  ALL DEPENDS
+    ${_all_modules}
+)

libcxx/modules/CMakeLists.txt.in

+cmake_minimum_required(VERSION 3.26)
+
+project(libc++-modules LANGUAGES CXX)
+
+# Enable CMake's module support
+if(CMAKE_VERSION VERSION_LESS "3.27.0")
+  set(CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API "2182bf5c-ef0d-489a-91da-49dbc3090d2a")
+else()
+  set(CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API "aa1f7df0-828a-4fcd-9afc-2dc80491aca7")
+endif()
+set(CMAKE_EXPERIMENTAL_CXX_MODULE_DYNDEP 1)
+
+# Default to C++ extensions being off. Libc++'s modules support have trouble
+# with extensions right now.
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+# Propagates the CMake options to the modules.
+#
+# This uses the std module hard-coded since the std.compat module does not
+# depend on these flags.
+macro(compile_define_if_not condition def)
+  if (NOT ${condition})
+    target_compile_definitions(std PRIVATE ${def})
+  endif()
+endmacro()
+macro(compile_define_if condition def)
+  if (${condition})
+    target_compile_definitions(std PRIVATE ${def})
+  endif()
+endmacro()
+
+if(NOT @LIBCXX_ENABLE_THREADS@ OR NOT @LIBCXXABI_ENABLE_THREADS@ OR NOT @LIBCXX_ENABLE_MONOTONIC_CLOCK@)
+  message(FATAL_ERROR "Modules without thread support is not yet implemented.")
+endif()
+if(NOT @LIBCXX_ENABLE_FILESYSTEM@)
+  message(FATAL_ERROR "Modules without filesystem support is not yet implemented.")
+endif()
+if(NOT @LIBCXX_ENABLE_RANDOM_DEVICE@)
+  message(FATAL_ERROR "Modules without randome device support is not yet implemented.")
+endif()
+if(NOT @LIBCXX_ENABLE_UNICODE@)
+  message(FATAL_ERROR "Modules without Unicode support is not yet implemented.")
+endif()
+if(NOT @LIBCXX_ENABLE_EXCEPTIONS@ OR NOT @LIBCXXABI_ENABLE_EXCEPTIONS@)
+  message(FATAL_ERROR "Modules without exception support is not yet implemented.")
+endif()
+
+add_library(std)
+target_sources(std
+  PUBLIC FILE_SET cxx_modules TYPE CXX_MODULES FILES
+    @LIBCXX_SOURCES_MODULE_STD@
+)
+
+target_compile_definitions(std PRIVATE _LIBCPP_ENABLE_EXPERIMENTAL)
+target_include_directories(std SYSTEM PRIVATE @LIBCXX_CONFIGURED_INCLUDE_DIR@)
+
+target_compile_options(std
+  PUBLIC
+    -nostdinc++
+    -Wno-reserved-module-identifier
+    -Wno-reserved-user-defined-literal
+    @LIBCXX_COMPILE_FLAGS@
+)
+set_target_properties(std
+  PROPERTIES
+    OUTPUT_NAME   "c++std"
+)

libcxx/modules/std/string.cppm

 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
     using std::pmr::wstring;
 #endif
   } // namespace pmr
 
   // [basic.string.hash], hash support
   using std::hash;
 
+  // TODO MODULES is this a bug?
+#if 1
+  using std::operator""s;
+#else
   inline namespace literals {
     inline namespace string_literals {
       // [basic.string.literals], suffix for basic_string literals
       using std::literals::string_literals::operator""s;
     } // namespace string_literals
   }   // namespace literals
+#endif
 } // namespace std

libcxx/test/CMakeLists.txt

if (LIBCXX_INCLUDE_TESTS)
   add_custom_target(cxx-test-depends
     DEPENDS cxx ${LIBCXX_TEST_DEPS}
     COMMENT "Builds dependencies required to run the test suite.")
 
   add_lit_testsuite(check-cxx
     "Running libcxx tests"
     ${CMAKE_CURRENT_BINARY_DIR}
     DEPENDS cxx-test-depends)
+
+  if(LIBCXX_ENABLE_STD_MODULES)
+    # Generates the modules used in the test.
+    # Note the test will regenerate this with the proper setting
+    # - the right DCMAKE_CXX_STANDARD
+    # - the right test compilation flags
+    # Since modules depend on these flags there currently is no way to
+    # avoid generating these for the tests. The advantage of the
+    # pre generation is that less build information needs to be shared
+    # in the bridge.
+    add_custom_command(
+        OUTPUT "${CMAKE_BINARY_DIR}/test/__config_module__/CMakeCache.txt"
+        COMMAND
+        ${CMAKE_COMMAND}
+            "-G${CMAKE_GENERATOR}"
+            "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
+            "-B${CMAKE_BINARY_DIR}/test/__config_module__"
+            "-H${LIBCXX_GENERATED_MODULE_DIR}"
+            "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
+            "-DCMAKE_CXX_STANDARD=23"
+            "-DCMAKE_EXPORT_COMPILE_COMMANDS=ON"
+            )
+  add_custom_target(generate-test-module-std
+      DEPENDS "${CMAKE_BINARY_DIR}/test/__config_module__/CMakeCache.txt"
+      COMMENT "Builds generic module std.")
+  endif()
 endif()
 
 if (LIBCXX_GENERATE_COVERAGE)
   include(CodeCoverage)
   set(output_dir "${CMAKE_CURRENT_BINARY_DIR}/coverage")
   set(capture_dirs
       "${LIBCXX_LIB_CMAKEFILES_DIR}/cxx_objects.dir/"
       "${LIBCXX_LIB_CMAKEFILES_DIR}/cxx.dir/"

libcxx/test/configs/cmake-bridge.cfg.in

 
 # Add substitutions for bootstrapping the test suite configuration
 import shlex
 config.substitutions.append(('%{cxx}', shlex.quote('@CMAKE_CXX_COMPILER@')))
 config.substitutions.append(('%{libcxx}', '@LIBCXX_SOURCE_DIR@'))
 config.substitutions.append(('%{include}', '@LIBCXX_GENERATED_INCLUDE_DIR@'))
 config.substitutions.append(('%{target-include}', '@LIBCXX_GENERATED_INCLUDE_TARGET_DIR@'))
 config.substitutions.append(('%{lib}', '@LIBCXX_LIBRARY_DIR@'))
+config.substitutions.append(('%{module}', '@LIBCXX_GENERATED_MODULE_DIR@'))
 config.substitutions.append(('%{executor}', '@LIBCXX_EXECUTOR@'))
 config.substitutions.append(('%{test-tools}', '@LIBCXX_TEST_TOOLS_PATH@'))
+
+# The test needs to manually rebuild the module. The compiler flags used in the
+# test need to be the same as the compiler flags used to generate the module.
+# In the future, when CMake can generated modules this may no longer be
+# necessary.
+# TODO MODULES whether it's possible to remove this substitution.
+config.substitutions.append(('%{cmake}', '@CMAKE_COMMAND@'))

libcxx/test/libcxx/module_std.gen.py

+# ===----------------------------------------------------------------------===##
+#
+# 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
+#
+# ===----------------------------------------------------------------------===##
+
+# Test that all named declarations with external linkage match the
+# exported declarations in their associated module partition.
+# Then it tests the sum of the exported declarations in the module
+# partitions matches the export of the std module.
+
+# Note the test of the std module requires all partitions to be tested
+# first. Since lit tests have no dependencies, this means the test needs
+# to be one monolitic test. Since the test doesn't take very long it's
+# not a huge issue.
+
+# RUN: %{python} %s %{libcxx}/utils
+
+import sys
+
+sys.path.append(sys.argv[1])
+from libcxx.test.header_information import toplevel_headers
+
+BLOCKLIT = (
+    ""  # block Lit from interpreting a RUN/XFAIL/etc inside the generation script
+)
+
+### Remove the headers that have no module associated with them
+
+# Note all C-headers using .h are filtered in the loop.
+
+# These headers are not available in C++23, but in older language Standards.
+toplevel_headers.remove("ccomplex")
+toplevel_headers.remove("ciso646")
+toplevel_headers.remove("cstdbool")
+toplevel_headers.remove("ctgmath")
+
+# Ignore several declarations found in the includes.
+#
+# Part of these items are bugs other are not yet implemented features.
+SkipDeclarations = dict()
+
+# See comment in the header.
+SkipDeclarations["cuchar"] = ["std::mbstate_t", "std::size_t"]
+
+# Not in the synopsis.
+SkipDeclarations["cwchar"] = ["std::FILE"]
+
+# The operators are added for private types like __iom_t10.
+SkipDeclarations["iomanip"] = ["std::operator<<", "std::operator>>"]
+
+SkipDeclarations["iosfwd"] = ["std::ios_base", "std::vector"]
+
+# This header also provides declarations in the namespace that might be
+# an error.
+SkipDeclarations["filesystem"] = [
+    "std::filesystem::operator==",
+    "std::filesystem::operator!=",
+]
+
+# This is a specialization for a private type
+SkipDeclarations["iterator"] = ["std::pointer_traits"]
+
+# TODO MODULES
+# This definition is declared in string and defined in istream
+# This declaration should be part of string
+SkipDeclarations["istream"] = ["std::getline"]
+
+# P1614 (at many places) and LWG3519 too.
+SkipDeclarations["random"] = [
+    "std::operator!=",
+    # LWG3519 makes these hidden friends.
+    # Note the older versions had the requirement of these operations but not in
+    # the synopsis.
+    "std::operator<<",
+    "std::operator>>",
+    "std::operator==",
+]
+
+# Declared in the forward header since std::string uses std::allocator
+SkipDeclarations["string"] = ["std::allocator"]
+# TODO MODULES remove zombie names
+# https://libcxx.llvm.org/Status/Cxx20.html#note-p0619
+SkipDeclarations["memory"] = [
+    "std::return_temporary_buffer",
+    "std::get_temporary_buffer",
+]
+
+# TODO MODULES this should be part of ios instead
+SkipDeclarations["streambuf"] = ["std::basic_ios"]
+
+# include/__type_traits/is_swappable.h
+SkipDeclarations["type_traits"] = [
+    "std::swap",
+    # TODO MODULES gotten through __functional/unwrap_ref.h
+    "std::reference_wrapper",
+]
+
+# Add declarations in headers.
+#
+# Some headers have their defines in a different header, which may have
+# additional declarations.
+ExtraDeclarations = dict()
+# This declaration is in the ostream header.
+ExtraDeclarations["system_error"] = ["std::operator<<"]
+
+# Adds an extra header file to scan
+#
+#
+ExtraHeader = dict()
+# locale has a file and not a subdirectory
+ExtraHeader["locale"] = "v1/__locale$"
+ExtraHeader["thread"] = "v1/__threading_support$"
+ExtraHeader["ranges"] = "v1/__fwd/subrange.h$"
+
+# The extra header is needed since two headers are required to provide the
+# same definition.
+ExtraHeader["functional"] = "v1/__compare/compare_three_way.h$"
+
+# Create empty file with all parts.
+print(
+    f"""\
+//--- module_std.sh.cpp
+// UNSUPPORTED{BLOCKLIT}: c++03, c++11, c++14, c++17, c++20
+
+// REQUIRES{BLOCKLIT}: has-clang-tidy
+// REQUIRES{BLOCKLIT}: use_module_std
+
+// The GCC compiler flags are not always compatible with clang-tidy.
+// UNSUPPORTED{BLOCKLIT}: gcc
+
+// RUN{BLOCKLIT}: echo -n > %t.all_partitions
+"""
+)
+
+# Validate all module parts.
+for header in toplevel_headers:
+    if header.endswith(".h"):  # Skip C compatibility headers
+        continue
+
+    # Dump the information as found in the module's cppm file.
+    print(
+        f"// RUN{BLOCKLIT}: %{{clang-tidy}} %{{module}}/std/{header}.cppm "
+        "  --checks='-*,libcpp-header-exportable-declarations' "
+        "  -config='{CheckOptions: [ "
+        "    {"
+        "      key: libcpp-header-exportable-declarations.Filename, "
+        f"     value: {header}.cppm"
+        "    }, {"
+        "      key: libcpp-header-exportable-declarations.FileType, "
+        "      value: ModulePartition"
+        "    }, "
+        "  ]}' "
+        "  --load=%{test-tools}/clang_tidy_checks/libcxx-tidy.plugin "
+        "  -- %{flags} %{compile_flags} "
+        f"| sort > %t.{header}.module"
+    )
+    print(f"// RUN{BLOCKLIT}: cat  %t.{header}.module >> %t.all_partitions")
+
+    # Dump the information as found in the module by using the header file(s).
+    skip_declarations = " ".join(SkipDeclarations.get(header, []))
+    if skip_declarations:
+        skip_declarations = (
+            "{"
+            "  key: libcpp-header-exportable-declarations.SkipDeclarations, "
+            f' value: "{skip_declarations}" '
+            "}, "
+        )
+
+    extra_declarations = " ".join(ExtraDeclarations.get(header, []))
+    if extra_declarations:
+        extra_declarations = (
+            " {"
+            "  key: libcpp-header-exportable-declarations.ExtraDeclarations, "
+            f' value: "{extra_declarations}" '
+            "}, "
+        )
+
+    extra_header = ExtraHeader.get(header, "")
+    if extra_header:
+        extra_header = (
+            "{"
+            "  key: libcpp-header-exportable-declarations.ExtraHeader, "
+            f' value: "{extra_header}" '
+            "}, "
+        )
+
+    # Clang-tidy needs a file input
+    print(f'// RUN{BLOCKLIT}: echo "#include <{header}>" > %t.{header}.cpp')
+    print(
+        f"// RUN{BLOCKLIT}: %{{clang-tidy}} %t.{header}.cpp "
+        "  --checks='-*,libcpp-header-exportable-declarations' "
+        "  -config='{CheckOptions: [ "
+        f"   {{key: libcpp-header-exportable-declarations.Filename, value: {header}}}, "
+        "    {key: libcpp-header-exportable-declarations.FileType, value: Header}, "
+        f"   {skip_declarations} {extra_declarations} {extra_header}, "
+        "  ]}' "
+        "  --load=%{test-tools}/clang_tidy_checks/libcxx-tidy.plugin "
+        "  -- %{flags} %{compile_flags} "
+        f" | sort > %t.{header}.include"
+    )
+
+    # Compare the cppm and header file(s) return the same results.
+    print(f"// RUN{BLOCKLIT}: diff -u %t.{header}.module %t.{header}.include")
+
+
+# Merge the data of the parts
+print(f"// RUN{BLOCKLIT}: sort -u -o %t.all_partitions %t.all_partitions")
+
+# Dump the information as found in std.cppm.
+print(
+    f"// RUN{BLOCKLIT}: %{{clang-tidy}} %{{module}}/std.cppm "
+    "  --checks='-*,libcpp-header-exportable-declarations' "
+    "  -config='{CheckOptions: [ "
+    "    {key: libcpp-header-exportable-declarations.Header, value: std.cppm}, "
+    "    {key: libcpp-header-exportable-declarations.FileType, value: Module}, "
+    "  ]}' "
+    f" --load=%{{test-tools}}/clang_tidy_checks/libcxx-tidy.plugin "
+    "  -- %{flags} %{compile_flags} "
+    "  | sort > %t.module"
+)
+
+
+# Compare the sum of the parts with the main module.
+print(f"// RUN{BLOCKLIT}: diff -u %t.all_partitions %t.module")

libcxx/test/libcxx/modules_include.gen.py

 #===----------------------------------------------------------------------===##
 #
 # 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
 #
 #===----------------------------------------------------------------------===##
 
 # Test that we can include each header in a TU while using modules.
 # This is important notably because the LLDB data formatters use
 # libc++ headers with modules enabled.
 
 # RUN: %{python} %s %{libcxx}/utils
 
 import sys
 sys.path.append(sys.argv[1])
 from libcxx.test.header_information import lit_header_restrictions, public_headers
 
 for header in public_headers:
   BLOCKLIT = '' # block Lit from interpreting a RUN/XFAIL/etc inside the generation script
   print(f"""\
 //--- {header}.compile.pass.cpp
 // RUN{BLOCKLIT}: %{{cxx}} %s %{{flags}} %{{compile_flags}} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only
 
+// UNSUPPORTED{BLOCKLIT}: use_module_std
+
 // GCC doesn't support -fcxx-modules
 // UNSUPPORTED{BLOCKLIT}: gcc
 
 // The Windows headers don't appear to be compatible with modules
 // UNSUPPORTED{BLOCKLIT}: windows
 // UNSUPPORTED{BLOCKLIT}: buildhost=windows
 
 // The Android headers don't appear to be compatible with modules yet

libcxx/test/tools/clang_tidy_checks/CMakeLists.txt

 # temporary the ToT version is preferred.
 find_package(Clang 17)
 if (NOT Clang_FOUND)
   find_package(Clang 16)
 endif()
 
 set(SOURCES
     abi_tag_on_virtual.cpp
+    header_exportable_declarations.cpp
     hide_from_abi.cpp
     proper_version_checks.cpp
     qualify_declval.cpp
     robust_against_adl.cpp
     uglify_attributes.cpp
 
     libcpp_module.cpp
    )

libcxx/test/tools/clang_tidy_checks/header_exportable_declarations.hpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang-tidy/ClangTidyCheck.h"
+
+#include "llvm/ADT/StringRef.h"
+
+#include <fstream>
+#include <set>
+#include <string>
+
+namespace libcpp {
+class header_exportable_declarations : public clang::tidy::ClangTidyCheck {
+public:
+  explicit header_exportable_declarations(llvm::StringRef, clang::tidy::ClangTidyContext*);
+  void registerMatchers(clang::ast_matchers::MatchFinder*) override;
+  void check(const clang::ast_matchers::MatchFinder::MatchResult&) override;
+
+  enum class FileType { Header, ModulePartition, Module, Unknown };
+
+private:
+  llvm::StringRef filename_;
+  FileType file_type_;
+  llvm::StringRef extra_header_;
+  std::set<std::string> decls_;
+};
+} // namespace libcpp

libcxx/test/tools/clang_tidy_checks/header_exportable_declarations.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
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang-tidy/ClangTidyCheck.h"
+#include "clang-tidy/ClangTidyModuleRegistry.h"
+
+#include "clang/Basic/Module.h"
+
+#include "llvm/ADT/ArrayRef.h"
+
+#include "header_exportable_declarations.hpp"
+
+#include <iostream>
+#include <iterator>
+#include <ranges>
+#include <algorithm>
+
+template <>
+struct clang::tidy::OptionEnumMapping<libcpp::header_exportable_declarations::FileType> {
+  static llvm::ArrayRef<std::pair<libcpp::header_exportable_declarations::FileType, llvm::StringRef>> getEnumMapping() {
+    static constexpr std::pair<libcpp::header_exportable_declarations::FileType, llvm::StringRef> Mapping[] = {
+        {libcpp::header_exportable_declarations::FileType::Header, "Header"},
+        {libcpp::header_exportable_declarations::FileType::ModulePartition, "ModulePartition"},
+        {libcpp::header_exportable_declarations::FileType::Module, "Module"}};
+    return ArrayRef(Mapping);
+  }
+};
+
+namespace libcpp {
+header_exportable_declarations::header_exportable_declarations(
+    llvm::StringRef name, clang::tidy::ClangTidyContext* context)
+    : clang::tidy::ClangTidyCheck(name, context),
+      filename_(Options.get("Filename", "")),
+      file_type_(Options.get("FileType", header_exportable_declarations::FileType::Unknown)),
+      extra_header_(Options.get("ExtraHeader", "")) {
+  if (filename_.empty())
+    llvm::errs() << "No filename is provided.\n";
+
+  switch (file_type_) {
+  case header_exportable_declarations::FileType::Header:
+    /* DO NOTHING */
+    break;
+  case header_exportable_declarations::FileType::Module:
+  case header_exportable_declarations::FileType::ModulePartition:
+    if (!extra_header_.empty())
+      llvm::errs() << "Extra headers are not allowed for modules.\n";
+    if (Options.get("SkipDeclarations"))
+      llvm::errs() << "Modules may not skip declarations.\n";
+    if (Options.get("ExtraDeclarations"))
+      llvm::errs() << "Modules may not have extra declarations.\n";
+    break;
+  case header_exportable_declarations::FileType::Unknown:
+    llvm::errs() << "No file type is provided.\n";
+    break;
+  }
+
+  std::optional<llvm::StringRef> list = Options.get("SkipDeclarations");
+  // TODO(LLVM-17) Remove clang 15 work-around.
+#if defined(__clang_major__) && __clang_major__ < 16
+  if (list) {
+    std::string_view s = *list;
+    auto b             = s.begin();
+    auto e             = std::find(b, s.end(), ' ');
+    while (b != e) {
+      decls_.emplace(b, e);
+      if (e == s.end())
+        break;
+      b = e + 1;
+      e = std::find(b, s.end(), ' ');
+    }
+  }
+#else  // defined(__clang_major__) && __clang_major__ < 16
+  if (list)
+    for (auto decl : std::views::split(*list, ' ')) {
+      std::string s;
+      std::ranges::copy(decl, std::back_inserter(s)); // use range based constructor
+      decls_.emplace(std::move(s));
+    }
+#endif // defined(__clang_major__) && __clang_major__ < 16
+
+  list = Options.get("ExtraDeclarations");
+  // TODO(LLVM-17) Remove clang 15 work-around.
+#if defined(__clang_major__) && __clang_major__ < 16
+  if (list) {
+    std::string_view s = *list;
+    auto b             = s.begin();
+    auto e             = std::find(b, s.end(), ' ');
+    while (b != e) {
+      std::cout << "using " << std::string_view{b, e} << ";\n";
+      if (e == s.end())
+        break;
+      b = e + 1;
+      e = std::find(b, s.end(), ' ');
+    }
+  }
+#else  // defined(__clang_major__) && __clang_major__ < 16
+  if (list)
+    for (auto decl : std::views::split(*list, ' '))
+      std::cout << "using " << std::string_view{decl.data(), decl.size()} << ";\n";
+#endif // defined(__clang_major__) && __clang_major__ < 16
+}
+
+void header_exportable_declarations::registerMatchers(clang::ast_matchers::MatchFinder* finder) {
+  // there are no public names in the Standard starting with an underscore, so
+  // no need to check the strict rules.
+  using namespace clang::ast_matchers;
+
+  switch (file_type_) {
+  case FileType::Header:
+
+    finder->addMatcher(
+        namedDecl(
+            // Looks at the common locations where headers store their data
+            // * header
+            // * __header/*.h
+            // * __fwd/header.h
+            anyOf(isExpansionInFileMatching(("v1/__" + filename_ + "/").str()),
+                  isExpansionInFileMatching(extra_header_),
+                  isExpansionInFileMatching(("v1/__fwd/" + filename_ + "\\.h$").str()),
+                  isExpansionInFileMatching(("v1/" + filename_ + "$").str())),
+            unless(hasAncestor(friendDecl())))
+            .bind("header_exportable_declarations"),
+        this);
+    break;
+  case FileType::ModulePartition:
+    finder->addMatcher(namedDecl(isExpansionInFileMatching(filename_)).bind("header_exportable_declarations"), this);
+    break;
+  case FileType::Module:
+    finder->addMatcher(namedDecl().bind("header_exportable_declarations"), this);
+    break;
+  case header_exportable_declarations::FileType::Unknown:
+    llvm::errs() << "This should be unreachable.\n";
+    break;
+  }
+}
+
+/// Returns the qualified name of a declaration.
+///
+/// There is a small issue with qualified names. Typically the name returned is
+/// in the namespace \c std instead of the namespace \c std::__1. Except when a
+/// name is declared both in the namespace \c std and in the namespace
+/// \c std::__1. In that case the returned value will adjust the name to use
+/// the namespace \c std.
+///
+/// The reason this happens is due to some parts of libc++ using
+/// \code namespace std \endcode instead of
+/// \code _LIBCPP_BEGIN_NAMESPACE_STD \endcode
+/// Some examples
+/// * cstddef has bitwise operators for the type \c byte
+/// * exception has equality operators for the type \c exception_ptr
+/// * initializer_list has the functions \c begin and \c end
+static std::string get_qualified_name(const clang::NamedDecl& decl) {
+  std::string result = decl.getQualifiedNameAsString();
+
+  if (result.starts_with("std::__1::"))
+    result.erase(5, 5);
+
+  return result;
+}
+
+static bool is_viable_declaration(const clang::NamedDecl* decl) {
+  // Declarations nested in records are automatically exported with the record itself.
+  if (!decl->getDeclContext()->isNamespace())
+    return false;
+
+  // Declarations that are a subobject of a friend Declaration are automatically exported with the record itself.
+  if (decl->getFriendObjectKind() != clang::Decl::FOK_None)
+    return false;
+
+  // *** Function declarations ***
+
+  if (clang::CXXMethodDecl::classof(decl))
+    return false;
+
+  if (clang::CXXDeductionGuideDecl::classof(decl))
+    return false;
+
+  if (clang::FunctionDecl::classof(decl))
+    return true;
+
+  if (clang::CXXConstructorDecl::classof(decl))
+    return false;
+
+  // implicit constructors disallowed
+  if (const auto* r = llvm::dyn_cast_or_null<clang::RecordDecl>(decl))
+    return !r->isLambda() && !r->isImplicit();
+
+  // *** Unconditionally accepted declarations ***
+  return llvm::isa<clang::EnumDecl, clang::VarDecl, clang::ConceptDecl, clang::TypedefNameDecl, clang::UsingDecl>(decl);
+}
+
+/// Returns the name is a reserved name.
+///
+/// Detected reserved names are names starting with __ or _[A-Z].
+/// These names can be in the namespace std or any namespace inside std. For
+/// example std::ranges contains reserved names to implement the Niebloids.
+///
+/// This test misses 2 candidates which are not used in libc++
+/// * any identifier with two underscores not at the start
+/// * a name with a leading underscore in the global namespace
+bool is_reserved_name(const std::string& name) {
+  std::size_t pos = name.find("::_");
+  if (pos == std::string::npos)
+    return false;
+
+  if (pos + 3 > name.size())
+    return false;
+
+  return name[pos + 3] == '_' || std::isupper(name[pos + 3]);
+}
+
+void header_exportable_declarations::check(const clang::ast_matchers::MatchFinder::MatchResult& result) {
+  if (const auto* decl = result.Nodes.getNodeAs<clang::NamedDecl>("header_exportable_declarations"); decl != nullptr) {
+    if (!is_viable_declaration(decl))
+      return;
+
+    std::string name = get_qualified_name(*decl);
+    if (is_reserved_name(name))
+      return;
+
+    // For modules (std, std.compat) only take the declarations exported from the partitions.
+    // Making sure no declatations of headers are compared.
+    if (file_type_ == FileType::Module)
+      if (clang::Module* M = decl->getOwningModule(); M && M->Kind != clang::Module::ModulePartitionInterface)
+        return;
+
+    if (decls_.contains(name))
+      return;
+
+    std::cout << "using " << std::string{name} << ";\n";
+    decls_.insert(name);
+  }
+}
+
+} // namespace libcpp

libcxx/test/tools/clang_tidy_checks/libcpp_module.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
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang-tidy/ClangTidyModule.h"
 #include "clang-tidy/ClangTidyModuleRegistry.h"
 
 #include "abi_tag_on_virtual.hpp"
+#include "header_exportable_declarations.hpp"
 #include "hide_from_abi.hpp"
 #include "proper_version_checks.hpp"
 #include "qualify_declval.hpp"
 #include "robust_against_adl.hpp"
 #include "uglify_attributes.hpp"
 
 namespace {
 class LibcxxTestModule : public clang::tidy::ClangTidyModule {
 public:
   void addCheckFactories(clang::tidy::ClangTidyCheckFactories& check_factories) override {
     check_factories.registerCheck<libcpp::abi_tag_on_virtual>("libcpp-avoid-abi-tag-on-virtual");
+    check_factories.registerCheck<libcpp::header_exportable_declarations>("libcpp-header-exportable-declarations");
     check_factories.registerCheck<libcpp::hide_from_abi>("libcpp-hide-from-abi");
     check_factories.registerCheck<libcpp::proper_version_checks>("libcpp-cpp-version-check");
     check_factories.registerCheck<libcpp::robust_against_adl_check>("libcpp-robust-against-adl");
     check_factories.registerCheck<libcpp::uglify_attributes>("libcpp-uglify-attributes");
     check_factories.registerCheck<libcpp::qualify_declval>("libcpp-qualify-declval");
   }
 };
 } // namespace
 
 clang::tidy::ClangTidyModuleRegistry::Add<LibcxxTestModule> libcpp_module{
     "libcpp-module", "Adds libc++-specific checks."};

libcxx/utils/ci/buildkite-pipeline.yml

agents:
       queue: "libcxx-builders"
       os: "linux"
     retry:
       automatic:
         - exit_status: -1  # Agent was lost
           limit: 2
     timeout_in_minutes: 120
 
+  - label: "C++23 Module std"
+    command: "libcxx/utils/ci/run-buildbot generic-module-std-cxx23"
+    artifact_paths:
+      - "**/test-results.xml"
+      - "**/*.abilist"
+    env:
+        # Note modules require and absolute path for clang-scan-deps
+        # https://github.com/llvm/llvm-project/issues/61006
+        CC: "/usr/lib/llvm-${LLVM_HEAD_VERSION}/bin/clang"
+        CXX: "/usr/lib/llvm-${LLVM_HEAD_VERSION}/bin/clang++"
+        CMAKE: "/opt/bin/cmake"
+        ENABLE_CLANG_TIDY: "On"
+    agents:
+      queue: "libcxx-builders"
+      os: "linux"
+    retry:
+      automatic:
+        - exit_status: -1  # Agent was lost
+          limit: 2
+    timeout_in_minutes: 120
+
   - label: "C++11"
     command: "libcxx/utils/ci/run-buildbot generic-cxx11"
     artifact_paths:
       - "**/test-results.xml"
       - "**/*.abilist"
     env:
         CC: "clang-${LLVM_HEAD_VERSION}"
         CXX: "clang++-${LLVM_HEAD_VERSION}"

libcxx/utils/ci/run-buildbot

 
 --osx-roots <DIR>   Path to pre-downloaded macOS dylibs. By default, we download
                     them from Green Dragon. This is only relevant at all when
                     running back-deployment testing if one wants to override
                     the old dylibs we use to run the tests with different ones.
 Environment variables
 CC                  The C compiler to use, this value is used by CMake. This
                     variable is optional.
+
 CXX                 The C++ compiler to use, this value is used by CMake. This
                     variable is optional.
 
+CMAKE               The CMake binary to use. This variable is optional.
+
 CLANG_FORMAT        The clang-format binary to use when generating the format
                     ignore list.
 
 GIT_CLANG_FORMAT    The git-clang-format binary to use in the 'format' builder.
                     When the value is omitted, it defaults to
                     'git-clang-format'. This variable or its fallback must work
                     when running the 'format' builder.
 

 MONOREPO_ROOT="${MONOREPO_ROOT:="$(git rev-parse --show-toplevel)"}"
 BUILD_DIR="${BUILD_DIR:=${MONOREPO_ROOT}/build/${BUILDER}}"
 INSTALL_DIR="${BUILD_DIR}/install"
 
 # If we can find Ninja/CMake provided by Xcode, use those since we know their
 # version will generally work with the Clang shipped in Xcode (e.g. if Clang
 # knows about -std=c++20, the CMake bundled in Xcode will probably know about
 # that flag too).
-if xcrun --find ninja &>/dev/null; then NINJA="$(xcrun --find ninja)"; else NINJA="ninja"; fi
-if xcrun --find cmake &>/dev/null; then CMAKE="$(xcrun --find cmake)"; else CMAKE="cmake"; fi
+if xcrun --find ninja &>/dev/null; then
+    NINJA="$(xcrun --find ninja)"
+elif which ninja &>/dev/null; then
+    # The current implementation of modules needs the absolute path to the ninja
+    # binary.
+    # TODO MODULES Is this still needed when CMake has libc++ module support?
+    NINJA="$(which ninja)"
+else
+    NINJA="ninja"
+fi
+
+if [ -z "${CMAKE}" ]; then
+    if xcrun --find cmake &>/dev/null; then
+        CMAKE="$(xcrun --find cmake)"
+    else
+        CMAKE="cmake"
+    fi
+fi
 
 function clean() {
     rm -rf "${BUILD_DIR}"
 }
 
 if [ -z "${ENABLE_CLANG_TIDY}" ]; then
     ENABLE_CLANG_TIDY=Off
 fi
check-format)
     echo "+++ Checking formatting"
     # We need to set --extensions so that clang-format checks extensionless files.
     mkdir -p ${BUILD_DIR}
     if [ -z "${GIT_CLANG_FORMAT}" ]; then
        GIT_CLANG_FORMAT=git-clang-format
     fi
     ${GIT_CLANG_FORMAT} \
         --diff \
-        --extensions ',h,hpp,c,cpp,inc,ipp' HEAD~1 \
-        -- $(find libcxx/{benchmarks,include,src}/ -type f | grep -vf libcxx/utils/data/ignore_format.txt) \
+        --extensions ',h,hpp,c,cpp,cppm,inc,ipp' HEAD~1 \
+        -- $(find libcxx/{benchmarks,include,modules,src}/ -type f | grep -vf libcxx/utils/data/ignore_format.txt) \
         | tee ${BUILD_DIR}/clang-format.patch
     # Check if the diff is empty, fail otherwise.
     ! grep -q '^--- a' ${BUILD_DIR}/clang-format.patch
 ;;
 check-generated-output)
     # `! foo` doesn't work properly with `set -e`, use `! foo || false` instead.
     # https://stackoverflow.com/questions/57681955/set-e-does-not-respect-logical-not
     clean
generic-debug-mode)
     check-runtimes
     # We don't check the ABI lists because the debug mode ABI is not stable
 ;;
 generic-with_llvm_unwinder)
     clean
     generate-cmake -DLIBCXXABI_USE_LLVM_UNWINDER=ON
     check-runtimes
 ;;
+#
+# Module builds
+#
 generic-modules)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-modules.cmake"
     check-runtimes
     check-abi-list
 ;;
 generic-modules-lsv)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-modules-lsv.cmake"
     check-runtimes
     check-abi-list
 ;;
+generic-module-std-cxx23)
+    clean
+    generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-module-std-cxx23.cmake"
+    check-runtimes
+    check-abi-list
+;;
 #
 # Parts removed
 #
 generic-no-threads)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-threads.cmake"
     check-runtimes
 ;;

libcxx/utils/libcxx/test/dsl.py

 # ===----------------------------------------------------------------------===##
 #
 # 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
 #
 # ===----------------------------------------------------------------------===##
 
 import os
 import pickle
 import pipes
 import platform
 import re
 import shutil
+import subprocess
 import tempfile
 
 import libcxx.test.format
 import lit
 import lit.LitConfig
 import lit.Test
 import lit.TestRunner
 import lit.util
def featureTestMacros(config, flags=""):
     allMacros = compilerMacros(config, flags)
     return {
         m: int(v.rstrip("LlUu"))
         for (m, v) in allMacros.items()
         if m.startswith("__cpp_")
     }
 
 
+def _getSubstitution(substitution, config):
+  for (orig, replacement) in config.substitutions:
+    if orig == substitution:
+      return replacement
+  raise ValueError('Substitution {} is not in the config.'.format(substitution))
+
 def _appendToSubstitution(substitutions, key, value):
     return [(k, v + " " + value) if k == key else (k, v) for (k, v) in substitutions]
 
 
 def _prependToSubstitution(substitutions, key, value):
     return [(k, value + " " + v) if k == key else (k, v) for (k, v) in substitutions]
 
 
def applyTo(self, config):
         ), "Trying to enable flag {}, which is not supported".format(flag)
         config.substitutions = _appendToSubstitution(
             config.substitutions, "%{flags}", flag
         )
 
     def pretty(self, config, litParams):
         return "add {} to %{{flags}}".format(self._getFlag(config))
 
+class BuildStdModule(ConfigAction):
+  def applyTo(self, config):
+    build = os.path.join(config.test_exec_root, '__config_module__')
+
+    std = _getSubstitution('%{cxx_std}', config)
+    if std == 'cxx26':
+        # This fails to work properly. It might be due to
+        #   CMAKE_CXX_STANDARD 26
+        # does not work in CMake 3.26, it requires the upcomming CMake 3.27.
+        # TODO MODULES test whether this is fixed with CMake 3.27.
+        std = '17'
+    elif std == 'cxx23':
+        std = '23'
+    else:
+        std = '17' # Not allowed for modules
+
+    flags = _getSubstitution('%{flags}', config)
+    cmake = _getSubstitution('%{cmake}', config)
+
+    subprocess.check_call([cmake, "-DCMAKE_CXX_STANDARD=" + std, f"-DCMAKE_CXX_FLAGS={flags}", build], env={})
+    subprocess.check_call([cmake, "--build", build], env={})
+
+  def pretty(self, config, litParams):
+    return "building std module with flags {}".format(_getSubstitution('%{flags}', config))
 
 class AddFlagIfSupported(ConfigAction):
     """
     This action adds the given flag to the %{flags} substitution, only if
     the compiler supports the flag.
 
     The flag can be a string or a callable, in which case it is called with the
     configuration to produce the actual flag (as a string).

libcxx/utils/libcxx/test/params.py

_warningFlags = [
     "-Wundef",
     "-Wunused-template",
     "-Wno-unused-command-line-argument",
     "-Wno-attributes",
     "-Wno-pessimizing-move",
     "-Wno-noexcept-type",
     "-Wno-aligned-allocation-unavailable",
     "-Wno-atomic-alignment",
+    "-Wno-reserved-module-identifier",
     # GCC warns about places where we might want to add sized allocation/deallocation
     # functions, but we know better what we're doing/testing in the test suite.
     "-Wno-sized-deallocation",
     # Turn off warnings about user-defined literals with reserved suffixes. Those are
     # just noise since we are testing the Standard Library itself.
     "-Wno-literal-suffix",  # GCC
     "-Wno-user-defined-literals",  # Clang
     # GCC warns about this when TEST_IS_CONSTANT_EVALUATED is used on a non-constexpr
if std == "c++23":
         std = "c++2b"
     if hasCompileFlag(cfg, "-std=" + std):
         return "-std=" + std
     if std in fallbacks and hasCompileFlag(cfg, "-std=" + fallbacks[std]):
         return "-std=" + fallbacks[std]
     return None
 
 
+_allModules = ["none", "clang", "std"]
+
+
+def getModuleFlag(cfg, enable_modules):
+    if enable_modules in _allModules:
+        return enable_modules
+    return None
+
+
 DEFAULT_PARAMETERS = [
     Parameter(
         name="target_triple",
         type=str,
         help="The target triple to compile the test suite for. This must be "
         "compatible with the target that the tests will be run on.",
         actions=lambda triple: filter(
             None,
             [
                 AddFeature("target={}".format(triple)),
Parameter(
         actions=lambda std: [
             AddFeature(std),
             AddSubstitution("%{cxx_std}", re.sub("\+", "x", std)),
             AddCompileFlag(lambda cfg: getStdFlag(cfg, std)),
         ],
     ),
     Parameter(
         name="enable_modules",
-        choices=[True, False],
-        type=bool,
-        default=False,
-        help="Whether to build the test suite with Clang modules enabled.",
-        actions=lambda modules: [
+        choices=_allModules,
+        type=str,
+        help="Whether to build the test suite with modules enabled. Select "
+        "`clang` for Clang modules and `std` for C++23 std module",
+        default=lambda cfg: next(s for s in _allModules if getModuleFlag(cfg, s)),
+        actions=lambda enable_modules: [
             AddFeature("modules-build"),
             AddCompileFlag("-fmodules"),
             AddCompileFlag(
                 "-fcxx-modules"
             ),  # AppleClang disregards -fmodules entirely when compiling C++. This enables modules for C++.
         ]
-        if modules
+        if enable_modules == "clang"
+        else [
+            AddFeature("use_module_std"),
+            AddCompileFlag("-DTEST_USE_MODULE"),
+            AddCompileFlag("-DTEST_USE_MODULE_STD"),
+            AddCompileFlag(
+                lambda cfg: "-fprebuilt-module-path="
+                + os.path.join(
+                    cfg.test_exec_root, "__config_module__/CMakeFiles/std.dir"
+                )
+            ),
+            BuildStdModule(),
+        ]
+        if enable_modules == "std"
         else [],
     ),
     Parameter(
         name="enable_modules_lsv",
         choices=[True, False],
         type=bool,
         default=False,
         help="Whether to enable Local Submodule Visibility in the Modules build.",
         actions=lambda lsv: [
             AddCompileFlag("-Xclang -fmodules-local-submodule-visibility"),
         ]
         if lsv