[libcxx][modules] protects users from relying on libc++ detail headers (1/n)

[cjdb]

Summary

libc++ has started splicing standard library headers into much more
fine-grained content for maintainability. It's very likely that outdated
and naive tooling (some of which is outside of LLVM's scope) will
suggest users include things such as <__algorithm/find.h> instead of
<algorithm>, and Hyrum's law suggests that users will eventually begin
to rely on this without the help of tooling. As such, this commit
intends to protect users from themselves, by making it a hard error for
anyone outside of the standard library to include libc++ detail headers.

This is the first of four patches. Patch #2 will solve the problem for
pre-processor #includes; patches #3 and #4 will solve the problem for
<__tree> and <__hash_table> (since I've never touched the test cases
that are failing for these two, I want to split them out into their own
commits to be extra careful). Patch #5 will concern itself with
<__threading_support>, which intersects with libcxxabi (which I know
even less about).

[cjdb]

This was originally the Clang patch D105439. Some context from over there is relevant to the discussion here.

[ldionne]

This seems like an elegant and straightforward approach to me. LGTM if CI passes.

[• Quuxplusone]

I predict controversy with patch #2. ;) But this certainly looks correct for the Modules part (and #3 and #4 should be equally straightforward).

[Mordante]

In D105932#2875275, @ldionne wrote:

This seems like an elegant and straightforward approach to me. LGTM if CI passes.

+1

[cjdb]

rolls back __mutex_base to see if CI will now pass

[cjdb]

• re-adds the stuff I removed
• adds <span> and <shared_mutex> to the module map
  • fixes tests to account for this

[cjdb]

• corrects <span>
• fixes libcxxabi breaks

Reviwers will probably want to take a look, but I'm going to ask that you hold off till CI is 100% green (or we just have that pesky Apple flake). libcxxabi might result in some churn since I'm unable to test it locally right now, so there could be two or three more commits before I get it completely right.

[ldionne]

I'm going to request changes on the patch so I remember to look at it again before it ships. Please ping me when you want this reviewed.

[cjdb]

• completely rolls back libcxxabi changes
• makes <__threading_support> a "public" header again
• expands number of commits this will take from 4 to 5 to account for <__threading_support>.

I don't see why libcxxabi couldn't instead include <thread> to get what's needed out of <__threading_support>, but I'm not convinced that's the right path forward without giving it some thought. Probably best to defer that to another patch where it owns the spotlight.

[cjdb]

@ldionne the modules build is green, so I'm going to pretend the rest passes for the purposes of asking you to re-review (I will of course wait for CI to actually be (green % Apple thread) flake before merging).

[ldionne]

The Apple failure is caused by your patch not being quite rebased onto main. Feel free to ship as-is.

[ldionne]

The Apple failure is caused by your patch not being quite rebased onto main. Feel free to ship as-is.

Phabricator glitch.

[cjdb]

Sorry @ldionne, but I decided to add tests for this, and I'm gonna need you to give this one last cursory review.
You can get away with reading the Python script that generated all the test cases, so it's not like there's a lot of extra work: it just looks that way :)

I promise that I'll merge after this.

[miscco]

libcxx/utils/generate_private_header_tests.py

19 ↗

(On Diff #358849)

Just to be sure, can we disable this for MSVC STL? There are no such headers there and this is rather specific to libc++

[cjdb]

libcxx/utils/generate_private_header_tests.py

19 ↗

(On Diff #358849)

These test are generated in libcxx/test/libcxx, which tests libc++ internals, so I don't think it's necessary to guard on that. Having said that, shouldn't REQUIRES: modules-build disable for Microsoft/STL anyway?

[STL_MSFT]

libcxx/utils/generate_private_header_tests.py

19 ↗

(On Diff #358849)

microsoft/STL runs only libcxx/test/std, not libcxx/test/libcxx, so this sounds perfectly fine to me.

[• Quuxplusone]

libcxx/utils/generate_private_header_tests.py

40–50 ↗

(On Diff #358849)

FWIW, I'd find this easier to read as

def is_still_public(p):
    return p.startswith('__support/') or p in [
        ...
    ]

paths = [p[10:] for p in Path('include').rglob('*') if p.as_posix().startswith('include/__') and not p.is_dir()]
private_paths = [p for p in paths if not is_still_public(p)]

[cjdb]

libcxx/utils/generate_private_header_tests.py

40–50 ↗

(On Diff #358849)

Yes, very much so. I was extremely disappointed when I found out I couldn't do this

Path("include").rglob('*')
               .filter(...)
               .map(...)
               .filter(...)

I guess list comprehensions are the Pythonic way of achieving this.

[ldionne]

Good idea about adding tests, thanks for doing that.

It does raise a couple issues that I don't think we've had before:

1. We'll now have to re-generate the auto-gen tests very often, since we add detail headers a lot more often than we add public headers. I don't think that's an actual issue, especially since we now have the libcxx-generate-files target to do it, but it's worth keeping in mind. If it becomes a pain, we could potentially go for a different approach where the tests are generated automatically on the fly when we run the test suite. Unless that becomes a real issue, I do have a preference for something simple where we can see the generated sources directly, like today.

2. Today, we never have to delete auto-gen tests, because we basically never remove/rename public headers. This commit changes that. Since there is some churn in our private headers (which is okay), we might start accumulating older headers that have since then been removed/renamed. I think a simple way to solve that would be to remove the whole libcxx/test/libcxx/diagnostics/detail.headers directory in your generation script. Also, if someone manually modifies one of the header tests (or tries adding their own), CI would fail in the check-generated-output CI job (since whatever they added would be removed).

libcxx/test/libcxx/diagnostics/detail.headers/algorithm/adjacent_find.module.verify.cpp

1 ↗

(On Diff #358849)

All your generated headers have this newline at the beginning -- they shouldn't.

I also think they should have a newline at the end (might not be required technically but we always do that).

13 ↗

(On Diff #358849)

This could look more like:

// WARNING: This test was generated by {script_name}
// and should not be edited manually.

That's what we do in other generated tests.

libcxx/utils/generate_private_header_tests.py

54 ↗

(On Diff #358849)

Awkward line break.

[• Quuxplusone]

libcxx/utils/generate_private_header_tests.py

29–32 ↗

(On Diff #358849)

Please follow the magic incantation at the top of all the other test-generating scripts, so that this script can be run from anywhere.

56 ↗

(On Diff #358849)

@ldionne wrote:

Today, we never have to delete auto-gen tests, because we basically never remove/rename public headers. This commit changes that. Since there is some churn in our private headers (which is okay), we might start accumulating older headers that have since then been removed/renamed. I think a simple way to solve that would be to remove the whole libcxx/test/libcxx/diagnostics/detail.headers directory in your generation script.

Another idea (and maybe a better one for the maintainers' sanity) would be to generate just one test file per public header. Instead of generating detail.headers/utility/{__decay_copy,as_const,cmp,declval,...}.module.verify.cpp, simply generate one test file, detail.headers/utility.verify.cpp, containing the code

// expected-error@*:* {{use of private header from outside its module: '__utility/__decay_copy.h'}}
#include <__utility/__decay_copy.h>

// expected-error@*:* {{use of private header from outside its module: '__utility/as_const.h'}}
#include <__utility/as_const.h>

// expected-error@*:* {{use of private header from outside its module: '__utility/cmp.h'}}
#include <__utility/cmp.h>

and so on and so on. Then these files would change often, but be added/deleted rarely, just like all the other generated test files.

Finally: Is the .module. in foo.module.verify.cpp significant to llvm-lit? Or could we go with just foo.verify.cpp, for clarity? find ../libcxx/test/ -name \*.module.\* doesn't show any results in trunk at the moment, so I suspect it's not significant and can be removed.

[cjdb]

libcxx/test/libcxx/diagnostics/detail.headers/algorithm/adjacent_find.module.verify.cpp

1 ↗

(On Diff #358849)

All your generated headers have this newline at the beginning -- they shouldn't.

Is that really a concern? (I'm going to fix it, but I wanna understand why.)

I also think they should have a newline at the end (might not be required technically but we always do that).

They already do. Evidence: Phab will tell you "no newline before EOF".

libcxx/utils/generate_private_header_tests.py

56 ↗

(On Diff #358849)

@ldionne wrote:

Today, we never have to delete auto-gen tests, because we basically never remove/rename public headers. This commit changes that. Since there is some churn in our private headers (which is okay), we might start accumulating older headers that have since then been removed/renamed. I think a simple way to solve that would be to remove the whole libcxx/test/libcxx/diagnostics/detail.headers directory in your generation script.

Another idea (and maybe a better one for the maintainers' sanity) would be to generate just one test file per public header. Instead of generating detail.headers/utility/{__decay_copy,as_const,cmp,declval,...}.module.verify.cpp, simply generate one test file, detail.headers/utility.verify.cpp, containing the code

// expected-error@*:* {{use of private header from outside its module: '__utility/__decay_copy.h'}}
#include <__utility/__decay_copy.h>

// expected-error@*:* {{use of private header from outside its module: '__utility/as_const.h'}}
#include <__utility/as_const.h>

// expected-error@*:* {{use of private header from outside its module: '__utility/cmp.h'}}
#include <__utility/cmp.h>

and so on and so on. Then these files would change often, but be added/deleted rarely, just like all the other generated test files.

I initially did this (it was waaaay cleaner and could be done by hand too), but modules mode only reports one header error at a time, so we end up with two expected-but-not-seen errors :(

Finally: Is the .module. in foo.module.verify.cpp significant to llvm-lit? Or could we go with just foo.verify.cpp, for clarity? find ../libcxx/test/ -name \*.module.\* doesn't show any results in trunk at the moment, so I suspect it's not significant and can be removed.

It's significant for a future patch that I expect to throw up in a day or so.

[cjdb]

applies suggested feedback

[cjdb]

adds the CMakeLists.txt bit

[ldionne]

LGTM but it would be great to see CI passing before committing this!

libcxx/test/libcxx/diagnostics/detail.headers/algorithm/adjacent_find.module.verify.cpp

1 ↗

(On Diff #358849)

It's not a concern per-se, but we might as well generate files the way we'd do it by hand.

I guess a minor concern is that you want the modline at the top to be the very first line (but I would have little love for an editor that can't figure out syntax highlighting from the .cpp extension).

libcxx/utils/CMakeLists.txt

16 ↗

(On Diff #359218)

When you commit, please change this COMMENT to the imperative, like the others above.

[cjdb]

rebases to activate CI

[cjdb]

fixes minor regex mishap

[ldionne]

libcxx/utils/CMakeLists.txt

16 ↗

(On Diff #359218)

This was never done. Please make sure you read the comments when you get a LGTM, often I request changes but still give the green check mark to avoid stalling the patch on something trivial.

In this case it's really not a big deal, but ideally this wouldn't happen with more important comments. I'll make this change as a NFC.

[cjdb]

libcxx/utils/CMakeLists.txt

16 ↗

(On Diff #359218)

Sorry, I clearly missed this comment.

libcxx/include/module.modulemap

module std [system] {
   }
 
   module algorithm {
     header "algorithm"
     export initializer_list
     export *
 
     module __algorithm {
-      module adjacent_find            { header "__algorithm/adjacent_find.h" }
-      module all_of                   { header "__algorithm/all_of.h" }
-      module any_of                   { header "__algorithm/any_of.h" }
-      module binary_search            { header "__algorithm/binary_search.h" }
-      module clamp                    { header "__algorithm/clamp.h" }
-      module comp                     { header "__algorithm/comp.h" }
-      module comp_ref_type            { header "__algorithm/comp_ref_type.h" }
-      module copy                     { header "__algorithm/copy.h" }
-      module copy_backward            { header "__algorithm/copy_backward.h" }
-      module copy_if                  { header "__algorithm/copy_if.h" }
-      module copy_n                   { header "__algorithm/copy_n.h" }
-      module count                    { header "__algorithm/count.h" }
-      module count_if                 { header "__algorithm/count_if.h" }
-      module equal                    { header "__algorithm/equal.h" }
-      module equal_range              { header "__algorithm/equal_range.h" }
-      module fill                     { header "__algorithm/fill.h" }
-      module fill_n                   { header "__algorithm/fill_n.h" }
-      module find                     { header "__algorithm/find.h" }
-      module find_end                 { header "__algorithm/find_end.h" }
-      module find_first_of            { header "__algorithm/find_first_of.h" }
-      module find_if                  { header "__algorithm/find_if.h" }
-      module find_if_not              { header "__algorithm/find_if_not.h" }
-      module for_each                 { header "__algorithm/for_each.h" }
-      module for_each_n               { header "__algorithm/for_each_n.h" }
-      module generate                 { header "__algorithm/generate.h" }
-      module generate_n               { header "__algorithm/generate_n.h" }
-      module half_positive            { header "__algorithm/half_positive.h" }
-      module includes                 { header "__algorithm/includes.h" }
-      module inplace_merge            { header "__algorithm/inplace_merge.h" }
-      module is_heap                  { header "__algorithm/is_heap.h" }
-      module is_heap_until            { header "__algorithm/is_heap_until.h" }
-      module is_partitioned           { header "__algorithm/is_partitioned.h" }
-      module is_permutation           { header "__algorithm/is_permutation.h" }
-      module is_sorted                { header "__algorithm/is_sorted.h" }
-      module is_sorted_until          { header "__algorithm/is_sorted_until.h" }
-      module lexicographical_compare  { header "__algorithm/lexicographical_compare.h" }
-      module lower_bound              { header "__algorithm/lower_bound.h" }
-      module make_heap                { header "__algorithm/make_heap.h" }
-      module max                      { header "__algorithm/max.h" }
-      module max_element              { header "__algorithm/max_element.h" }
-      module merge                    { header "__algorithm/merge.h" }
-      module min                      { header "__algorithm/min.h" }
-      module min_element              { header "__algorithm/min_element.h" }
-      module minmax                   { header "__algorithm/minmax.h" }
-      module minmax_element           { header "__algorithm/minmax_element.h" }
-      module mismatch                 { header "__algorithm/mismatch.h" }
-      module move                     { header "__algorithm/move.h" }
-      module move_backward            { header "__algorithm/move_backward.h" }
-      module next_permutation         { header "__algorithm/next_permutation.h" }
-      module none_of                  { header "__algorithm/none_of.h" }
-      module nth_element              { header "__algorithm/nth_element.h" }
-      module partial_sort             { header "__algorithm/partial_sort.h" }
-      module partial_sort_copy        { header "__algorithm/partial_sort_copy.h" }
-      module partition                { header "__algorithm/partition.h" }
-      module partition_copy           { header "__algorithm/partition_copy.h" }
-      module partition_point          { header "__algorithm/partition_point.h" }
-      module pop_heap                 { header "__algorithm/pop_heap.h" }
-      module prev_permutation         { header "__algorithm/prev_permutation.h" }
-      module push_heap                { header "__algorithm/push_heap.h" }
-      module remove                   { header "__algorithm/remove.h" }
-      module remove_copy              { header "__algorithm/remove_copy.h" }
-      module remove_copy_if           { header "__algorithm/remove_copy_if.h" }
-      module remove_if                { header "__algorithm/remove_if.h" }
-      module replace                  { header "__algorithm/replace.h" }
-      module replace_copy             { header "__algorithm/replace_copy.h" }
-      module replace_copy_if          { header "__algorithm/replace_copy_if.h" }
-      module replace_if               { header "__algorithm/replace_if.h" }
-      module reverse                  { header "__algorithm/reverse.h" }
-      module reverse_copy             { header "__algorithm/reverse_copy.h" }
-      module rotate                   { header "__algorithm/rotate.h" }
-      module rotate_copy              { header "__algorithm/rotate_copy.h" }
-      module sample                   { header "__algorithm/sample.h" }
-      module search                   { header "__algorithm/search.h" }
-      module search_n                 { header "__algorithm/search_n.h" }
-      module set_difference           { header "__algorithm/set_difference.h" }
-      module set_intersection         { header "__algorithm/set_intersection.h" }
-      module set_symmetric_difference { header "__algorithm/set_symmetric_difference.h" }
-      module set_union                { header "__algorithm/set_union.h" }
-      module shift_left               { header "__algorithm/shift_left.h" }
-      module shift_right              { header "__algorithm/shift_right.h" }
-      module shuffle                  { header "__algorithm/shuffle.h" }
-      module sift_down                { header "__algorithm/sift_down.h" }
-      module sort                     { header "__algorithm/sort.h" }
-      module sort_heap                { header "__algorithm/sort_heap.h" }
-      module stable_partition         { header "__algorithm/stable_partition.h" }
-      module stable_sort              { header "__algorithm/stable_sort.h" }
-      module transform                { header "__algorithm/transform.h" }
-      module unique                   { header "__algorithm/unique.h" }
-      module unique_copy              { header "__algorithm/unique_copy.h" }
-      module unwrap_iter              { header "__algorithm/unwrap_iter.h" }
-      module upper_bound              { header "__algorithm/upper_bound.h" }
+      module adjacent_find            { private header "__algorithm/adjacent_find.h" }
+      module all_of                   { private header "__algorithm/all_of.h" }
+      module any_of                   { private header "__algorithm/any_of.h" }
+      module binary_search            { private header "__algorithm/binary_search.h" }
+      module clamp                    { private header "__algorithm/clamp.h" }
+      module comp                     { private header "__algorithm/comp.h" }
+      module comp_ref_type            { private header "__algorithm/comp_ref_type.h" }
+      module copy                     { private header "__algorithm/copy.h" }
+      module copy_backward            { private header "__algorithm/copy_backward.h" }
+      module copy_if                  { private header "__algorithm/copy_if.h" }
+      module copy_n                   { private header "__algorithm/copy_n.h" }
+      module count                    { private header "__algorithm/count.h" }
+      module count_if                 { private header "__algorithm/count_if.h" }
+      module equal                    { private header "__algorithm/equal.h" }
+      module equal_range              { private header "__algorithm/equal_range.h" }
+      module fill                     { private header "__algorithm/fill.h" }
+      module fill_n                   { private header "__algorithm/fill_n.h" }
+      module find                     { private header "__algorithm/find.h" }
+      module find_end                 { private header "__algorithm/find_end.h" }
+      module find_first_of            { private header "__algorithm/find_first_of.h" }
+      module find_if                  { private header "__algorithm/find_if.h" }
+      module find_if_not              { private header "__algorithm/find_if_not.h" }
+      module for_each                 { private header "__algorithm/for_each.h" }
+      module for_each_n               { private header "__algorithm/for_each_n.h" }
+      module generate                 { private header "__algorithm/generate.h" }
+      module generate_n               { private header "__algorithm/generate_n.h" }
+      module half_positive            { private header "__algorithm/half_positive.h" }
+      module includes                 { private header "__algorithm/includes.h" }
+      module inplace_merge            { private header "__algorithm/inplace_merge.h" }
+      module is_heap                  { private header "__algorithm/is_heap.h" }
+      module is_heap_until            { private header "__algorithm/is_heap_until.h" }
+      module is_partitioned           { private header "__algorithm/is_partitioned.h" }
+      module is_permutation           { private header "__algorithm/is_permutation.h" }
+      module is_sorted                { private header "__algorithm/is_sorted.h" }
+      module is_sorted_until          { private header "__algorithm/is_sorted_until.h" }
+      module lexicographical_compare  { private header "__algorithm/lexicographical_compare.h" }
+      module lower_bound              { private header "__algorithm/lower_bound.h" }
+      module make_heap                { private header "__algorithm/make_heap.h" }
+      module max                      { private header "__algorithm/max.h" }
+      module max_element              { private header "__algorithm/max_element.h" }
+      module merge                    { private header "__algorithm/merge.h" }
+      module min                      { private header "__algorithm/min.h" }
+      module min_element              { private header "__algorithm/min_element.h" }
+      module minmax                   { private header "__algorithm/minmax.h" }
+      module minmax_element           { private header "__algorithm/minmax_element.h" }
+      module mismatch                 { private header "__algorithm/mismatch.h" }
+      module move                     { private header "__algorithm/move.h" }
+      module move_backward            { private header "__algorithm/move_backward.h" }
+      module next_permutation         { private header "__algorithm/next_permutation.h" }
+      module none_of                  { private header "__algorithm/none_of.h" }
+      module nth_element              { private header "__algorithm/nth_element.h" }
+      module partial_sort             { private header "__algorithm/partial_sort.h" }
+      module partial_sort_copy        { private header "__algorithm/partial_sort_copy.h" }
+      module partition                { private header "__algorithm/partition.h" }
+      module partition_copy           { private header "__algorithm/partition_copy.h" }
+      module partition_point          { private header "__algorithm/partition_point.h" }
+      module pop_heap                 { private header "__algorithm/pop_heap.h" }
+      module prev_permutation         { private header "__algorithm/prev_permutation.h" }
+      module push_heap                { private header "__algorithm/push_heap.h" }
+      module remove                   { private header "__algorithm/remove.h" }
+      module remove_copy              { private header "__algorithm/remove_copy.h" }
+      module remove_copy_if           { private header "__algorithm/remove_copy_if.h" }
+      module remove_if                { private header "__algorithm/remove_if.h" }
+      module replace                  { private header "__algorithm/replace.h" }
+      module replace_copy             { private header "__algorithm/replace_copy.h" }
+      module replace_copy_if          { private header "__algorithm/replace_copy_if.h" }
+      module replace_if               { private header "__algorithm/replace_if.h" }
+      module reverse                  { private header "__algorithm/reverse.h" }
+      module reverse_copy             { private header "__algorithm/reverse_copy.h" }
+      module rotate                   { private header "__algorithm/rotate.h" }
+      module rotate_copy              { private header "__algorithm/rotate_copy.h" }
+      module sample                   { private header "__algorithm/sample.h" }
+      module search                   { private header "__algorithm/search.h" }
+      module search_n                 { private header "__algorithm/search_n.h" }
+      module set_difference           { private header "__algorithm/set_difference.h" }
+      module set_intersection         { private header "__algorithm/set_intersection.h" }
+      module set_symmetric_difference { private header "__algorithm/set_symmetric_difference.h" }
+      module set_union                { private header "__algorithm/set_union.h" }
+      module shift_left               { private header "__algorithm/shift_left.h" }
+      module shift_right              { private header "__algorithm/shift_right.h" }
+      module shuffle                  { private header "__algorithm/shuffle.h" }
+      module sift_down                { private header "__algorithm/sift_down.h" }
+      module sort                     { private header "__algorithm/sort.h" }
+      module sort_heap                { private header "__algorithm/sort_heap.h" }
+      module stable_partition         { private header "__algorithm/stable_partition.h" }
+      module stable_sort              { private header "__algorithm/stable_sort.h" }
+      module transform                { private header "__algorithm/transform.h" }
+      module unique                   { private header "__algorithm/unique.h" }
+      module unique_copy              { private header "__algorithm/unique_copy.h" }
+      module unwrap_iter              { private header "__algorithm/unwrap_iter.h" }
+      module upper_bound              { private header "__algorithm/upper_bound.h" }
     }
   }
   module any {
     header "any"
     export *
   }
   module array {
     header "array"
module filesystem {
     header "filesystem"
     export *
   }
   module format {
     header "format"
     export *
 
     module __format {
-      module format_error         { header "__format/format_error.h"         }
-      module format_parse_context { header "__format/format_parse_context.h" }
+      module format_error         { private header "__format/format_error.h"         }
+      module format_parse_context { private header "__format/format_parse_context.h" }
     }
   }
   module forward_list {
     header "forward_list"
     export initializer_list
     export *
   }
   module fstream {
     header "fstream"
     export *
   }
   module functional {
     header "functional"
     export *
 
     module __functional {
-      module binary_function            { header "__functional/binary_function.h" }
-      module binary_negate              { header "__functional/binary_negate.h" }
-      module bind                       { header "__functional/bind.h" }
-      module bind_front                 { header "__functional/bind_front.h" }
-      module binder1st                  { header "__functional/binder1st.h" }
-      module binder2nd                  { header "__functional/binder2nd.h" }
-      module default_searcher           { header "__functional/default_searcher.h" }
-      module function                   { header "__functional/function.h" }
-      module hash                       { header "__functional/hash.h" }
-      module identity                   { header "__functional/identity.h" }
-      module invoke                     { header "__functional/invoke.h" }
-      module mem_fn                     { header "__functional/mem_fn.h"  }
-      module mem_fun_ref                { header "__functional/mem_fun_ref.h"  }
-      module not_fn                     { header "__functional/not_fn.h" }
-      module operations                 { header "__functional/operations.h" }
-      module perfect_forward            { header "__functional/perfect_forward.h" }
-      module pointer_to_binary_function { header "__functional/pointer_to_binary_function.h" }
-      module pointer_to_unary_function  { header "__functional/pointer_to_unary_function.h" }
-      module ranges_operations          { header "__functional/ranges_operations.h" }
-      module reference_wrapper          { header "__functional/reference_wrapper.h" }
-      module unary_function             { header "__functional/unary_function.h" }
-      module unary_negate               { header "__functional/unary_negate.h" }
-      module unwrap_ref                 { header "__functional/unwrap_ref.h" }
-      module weak_result_type           { header "__functional/weak_result_type.h" }
+      module binary_function            { private header "__functional/binary_function.h" }
+      module binary_negate              { private header "__functional/binary_negate.h" }
+      module bind                       { private header "__functional/bind.h" }
+      module bind_front                 { private header "__functional/bind_front.h" }
+      module binder1st                  { private header "__functional/binder1st.h" }
+      module binder2nd                  { private header "__functional/binder2nd.h" }
+      module default_searcher           { private header "__functional/default_searcher.h" }
+      module function                   { private header "__functional/function.h" }
+      module hash                       { private header "__functional/hash.h" }
+      module identity                   { private header "__functional/identity.h" }
+      module invoke                     { private header "__functional/invoke.h" }
+      module mem_fn                     { private header "__functional/mem_fn.h"  }
+      module mem_fun_ref                { private header "__functional/mem_fun_ref.h"  }
+      module not_fn                     { private header "__functional/not_fn.h" }
+      module operations                 { private header "__functional/operations.h" }
+      module perfect_forward            { private header "__functional/perfect_forward.h" }
+      module pointer_to_binary_function { private header "__functional/pointer_to_binary_function.h" }
+      module pointer_to_unary_function  { private header "__functional/pointer_to_unary_function.h" }
+      module ranges_operations          { private header "__functional/ranges_operations.h" }
+      module reference_wrapper          { private header "__functional/reference_wrapper.h" }
+      module unary_function             { private header "__functional/unary_function.h" }
+      module unary_negate               { private header "__functional/unary_negate.h" }
+      module unwrap_ref                 { private header "__functional/unwrap_ref.h" }
+      module weak_result_type           { private header "__functional/weak_result_type.h" }
     }
   }
   module future {
     header "future"
     export *
   }
   module initializer_list {
     header "initializer_list"
module istream {
     // FIXME: should re-export ios, streambuf?
     export *
   }
   module iterator {
     header "iterator"
     export *
 
     module __iterator {
-      module access                { header "__iterator/access.h" }
-      module advance               { header "__iterator/advance.h" }
-      module back_insert_iterator  { header "__iterator/back_insert_iterator.h" }
-      module concepts              { header "__iterator/concepts.h" }
-      module data                  { header "__iterator/data.h" }
-      module default_sentinel      { header "__iterator/default_sentinel.h" }
-      module distance              { header "__iterator/distance.h" }
-      module empty                 { header "__iterator/empty.h" }
-      module erase_if_container    { header "__iterator/erase_if_container.h" }
-      module front_insert_iterator { header "__iterator/front_insert_iterator.h" }
-      module incrementable_traits  { header "__iterator/incrementable_traits.h" }
-      module insert_iterator       { header "__iterator/insert_iterator.h" }
-      module istream_iterator      { header "__iterator/istream_iterator.h" }
-      module istreambuf_iterator   { header "__iterator/istreambuf_iterator.h" }
-      module iter_move             { header "__iterator/iter_move.h" }
-      module iter_swap             { header "__iterator/iter_swap.h" }
-      module iterator              { header "__iterator/iterator.h" }
-      module iterator_traits       { header "__iterator/iterator_traits.h" }
-      module move_iterator         { header "__iterator/move_iterator.h" }
-      module next                  { header "__iterator/next.h" }
-      module ostream_iterator      { header "__iterator/ostream_iterator.h" }
-      module ostreambuf_iterator   { header "__iterator/ostreambuf_iterator.h" }
-      module prev                  { header "__iterator/prev.h" }
-      module projected             { header "__iterator/projected.h" }
-      module readable_traits       { header "__iterator/readable_traits.h" }
-      module reverse_access        { header "__iterator/reverse_access.h" }
-      module reverse_iterator      { header "__iterator/reverse_iterator.h" }
-      module size                  { header "__iterator/size.h" }
-      module wrap_iter             { header "__iterator/wrap_iter.h" }
+      module access                { private header "__iterator/access.h" }
+      module advance               { private header "__iterator/advance.h" }
+      module back_insert_iterator  { private header "__iterator/back_insert_iterator.h" }
+      module concepts              { private header "__iterator/concepts.h" }
+      module data                  { private header "__iterator/data.h" }
+      module default_sentinel      { private header "__iterator/default_sentinel.h" }
+      module distance              { private header "__iterator/distance.h" }
+      module empty                 { private header "__iterator/empty.h" }
+      module erase_if_container    { private header "__iterator/erase_if_container.h" }
+      module front_insert_iterator { private header "__iterator/front_insert_iterator.h" }
+      module incrementable_traits  { private header "__iterator/incrementable_traits.h" }
+      module insert_iterator       { private header "__iterator/insert_iterator.h" }
+      module istream_iterator      { private header "__iterator/istream_iterator.h" }
+      module istreambuf_iterator   { private header "__iterator/istreambuf_iterator.h" }
+      module iter_move             { private header "__iterator/iter_move.h" }
+      module iter_swap             { private header "__iterator/iter_swap.h" }
+      module iterator              { private header "__iterator/iterator.h" }
+      module iterator_traits       { private header "__iterator/iterator_traits.h" }
+      module move_iterator         { private header "__iterator/move_iterator.h" }
+      module next                  { private header "__iterator/next.h" }
+      module ostream_iterator      { private header "__iterator/ostream_iterator.h" }
+      module ostreambuf_iterator   { private header "__iterator/ostreambuf_iterator.h" }
+      module prev                  { private header "__iterator/prev.h" }
+      module projected             { private header "__iterator/projected.h" }
+      module readable_traits       { private header "__iterator/readable_traits.h" }
+      module reverse_access        { private header "__iterator/reverse_access.h" }
+      module reverse_iterator      { private header "__iterator/reverse_iterator.h" }
+      module size                  { private header "__iterator/size.h" }
+      module wrap_iter             { private header "__iterator/wrap_iter.h" }
     }
   }
   module latch {
     requires cplusplus14
     header "latch"
     export *
   }
   module limits {
module map {
     export initializer_list
     export *
   }
   module memory {
     header "memory"
     export *
 
     module __memory {
-      module addressof                { header "__memory/addressof.h"                }
-      module allocation_guard         { header "__memory/allocation_guard.h"         }
-      module allocator                { header "__memory/allocator.h"                }
-      module allocator_arg_t          { header "__memory/allocator_arg_t.h"          }
-      module allocator_traits         { header "__memory/allocator_traits.h"         }
-      module auto_ptr                 { header "__memory/auto_ptr.h"                 }
-      module compressed_pair          { header "__memory/compressed_pair.h"          }
-      module construct_at             { header "__memory/construct_at.h"             }
-      module pointer_safety           { header "__memory/pointer_safety.h"           }
-      module pointer_traits           { header "__memory/pointer_traits.h"           }
-      module raw_storage_iterator     { header "__memory/raw_storage_iterator.h"     }
-      module shared_ptr               { header "__memory/shared_ptr.h"               }
-      module temporary_buffer         { header "__memory/temporary_buffer.h"         }
-      module uninitialized_algorithms { header "__memory/uninitialized_algorithms.h" }
-      module unique_ptr               { header "__memory/unique_ptr.h"               }
+      module addressof                { private header "__memory/addressof.h"                }
+      module allocation_guard         { private header "__memory/allocation_guard.h"         }
+      module allocator                { private header "__memory/allocator.h"                }
+      module allocator_arg_t          { private header "__memory/allocator_arg_t.h"          }
+      module allocator_traits         { private header "__memory/allocator_traits.h"         }
+      module auto_ptr                 { private header "__memory/auto_ptr.h"                 }
+      module compressed_pair          { private header "__memory/compressed_pair.h"          }
+      module construct_at             { private header "__memory/construct_at.h"             }
+      module pointer_safety           { private header "__memory/pointer_safety.h"           }
+      module pointer_traits           { private header "__memory/pointer_traits.h"           }
+      module raw_storage_iterator     { private header "__memory/raw_storage_iterator.h"     }
+      module shared_ptr               { private header "__memory/shared_ptr.h"               }
+      module temporary_buffer         { private header "__memory/temporary_buffer.h"         }
+      module uninitialized_algorithms { private header "__memory/uninitialized_algorithms.h" }
+      module unique_ptr               { private header "__memory/unique_ptr.h"               }
     }
   }
   module mutex {
     header "mutex"
     export *
   }
   module new {
     header "new"
module queue {
     export *
   }
   module random {
     header "random"
     export initializer_list
     export *
 
     module __random {
-      module uniform_int_distribution { header "__random/uniform_int_distribution.h" }
+      module uniform_int_distribution { private header "__random/uniform_int_distribution.h" }
     }
   }
   module ranges {
     header "ranges"
     export compare
     export initializer_list
     export iterator
     export *
 
     module __ranges {
-      module access                 { header "__ranges/access.h"                }
-      module all                    { header "__ranges/all.h"                   }
-      module concepts               { header "__ranges/concepts.h"              }
-      module copyable_box           { header "__ranges/copyable_box.h"          }
-      module data                   { header "__ranges/data.h"                  }
-      module empty                  { header "__ranges/empty.h"                 }
-      module empty_view             { header "__ranges/empty_view.h"            }
-      module enable_borrowed_range  { header "__ranges/enable_borrowed_range.h" }
-      module enable_view            { header "__ranges/enable_view.h"           }
-      module ref_view               { header "__ranges/ref_view.h"              }
-      module size                   { header "__ranges/size.h"                  }
-      module subrange               { header "__ranges/subrange.h"              }
-      module view_interface         { header "__ranges/view_interface.h"        }
+      module access                 { private header "__ranges/access.h"                }
+      module all                    { private header "__ranges/all.h"                   }
+      module concepts               { private header "__ranges/concepts.h"              }
+      module copyable_box           { private header "__ranges/copyable_box.h"          }
+      module data                   { private header "__ranges/data.h"                  }
+      module empty                  { private header "__ranges/empty.h"                 }
+      module empty_view             { private header "__ranges/empty_view.h"            }
+      module enable_borrowed_range  { private header "__ranges/enable_borrowed_range.h" }
+      module enable_view            { private header "__ranges/enable_view.h"           }
+      module ref_view               { private header "__ranges/ref_view.h"              }
+      module size                   { private header "__ranges/size.h"                  }
+      module subrange               { private header "__ranges/subrange.h"              }
+      module view_interface         { private header "__ranges/view_interface.h"        }
     }
   }
   module ratio {
     header "ratio"
     export *
   }
   module regex {
     header "regex"
module unordered_set {
     export *
   }
   module utility {
     header "utility"
     export initializer_list
     export *
 
     module __utility {
-      module __decay_copy        { header "__utility/__decay_copy.h"        }
-      module as_const            { header "__utility/as_const.h"            }
-      module cmp                 { header "__utility/cmp.h"                 }
-      module declval             { header "__utility/declval.h"             }
-      module exchange            { header "__utility/exchange.h"            }
-      module forward             { header "__utility/forward.h"             }
-      module in_place            { header "__utility/in_place.h"            }
-      module integer_sequence    { header "__utility/integer_sequence.h"    }
-      module move                { header "__utility/move.h"                }
-      module pair                { header "__utility/pair.h"                }
-      module piecewise_construct { header "__utility/piecewise_construct.h" }
-      module rel_ops             { header "__utility/rel_ops.h"             }
-      module swap                { header "__utility/swap.h"                }
-      module to_underlying       { header "__utility/to_underlying.h"       }
+      module __decay_copy        { private header "__utility/__decay_copy.h"        }
+      module as_const            { private header "__utility/as_const.h"            }
+      module cmp                 { private header "__utility/cmp.h"                 }
+      module declval             { private header "__utility/declval.h"             }
+      module exchange            { private header "__utility/exchange.h"            }
+      module forward             { private header "__utility/forward.h"             }
+      module in_place            { private header "__utility/in_place.h"            }
+      module integer_sequence    { private header "__utility/integer_sequence.h"    }
+      module move                { private header "__utility/move.h"                }
+      module pair                { private header "__utility/pair.h"                }
+      module piecewise_construct { private header "__utility/piecewise_construct.h" }
+      module rel_ops             { private header "__utility/rel_ops.h"             }
+      module swap                { private header "__utility/swap.h"                }
+      module to_underlying       { private header "__utility/to_underlying.h"       }
     }
   }
   module valarray {
     header "valarray"
     export initializer_list
     export *
   }
   module variant {
     header "variant"
     export *
 
     module __variant {
-      module monostate { header "__variant/monostate.h" }
+      module monostate { private header "__variant/monostate.h" }
     }
   }
   module vector {
     header "vector"
     export initializer_list
     export *
   }
   module version {
     header "version"
     export *
   }
 
   // __config not modularised due to a bug in Clang
   // FIXME: These should be private.
   module __availability      { header "__availability"      export * }
-  module __bit_reference     { header "__bit_reference"     export * }
-  module __bits              { header "__bits"              export * }
+  module __bit_reference     { private header "__bit_reference"     export * }
+  module __bits              { private header "__bits"              export * }
   module __debug             { header "__debug"             export * }
   module __errc              { header "__errc"              export * }
-  module __function_like     { header "__function_like.h"   export * }
+  module __function_like     { private header "__function_like.h"   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 __nullptr           { header "__nullptr"           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 __locale            { private header "__locale"            export * }
+  module __mutex_base        { private header "__mutex_base"        export * }
+  module __node_handle       { private header "__node_handle"       export * }
+  module __nullptr           { private header "__nullptr"           export * }
+  module __split_buffer      { private header "__split_buffer"      export * }
+  module __std_stream        { private header "__std_stream"        export * }
+  module __string            { private header "__string"            export * }
+  module __threading_support { private header "__threading_support" export * }
   module __tree              { header "__tree"              export * }
-  module __tuple             { header "__tuple"             export * }
+  module __tuple             { private header "__tuple"             export * }
   module __undef_macros      { header "__undef_macros"      export * }
 
   module experimental {
     requires cplusplus11
 
     module algorithm {
       header "experimental/algorithm"
       export *

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/assign.copy.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
 // <copyable-box>& operator=(<copyable-box> const&)
 
 // ADDITIONAL_COMPILE_FLAGS: -Wno-self-assign-overloaded
 
-#include <__ranges/copyable_box.h>
+#include <ranges>
 
 #include <cassert>
 #include <type_traits>
 #include <utility> // in_place_t
 
 #include "test_macros.h"
 #include "types.h"
 

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/assign.move.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
 // <copyable-box>& operator=(<copyable-box>&&)
 
 // ADDITIONAL_COMPILE_FLAGS: -Wno-self-move
 
-#include <__ranges/copyable_box.h>
+#include <ranges>
 
 #include <cassert>
 #include <type_traits>
 #include <utility> // in_place_t
 
 #include "test_macros.h"
 #include "types.h"
 

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/ctor.default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
 // <copyable-box>::<copyable-box>()
 
-#include <__ranges/copyable_box.h>
+#include <ranges>
 
 #include <cassert>
 #include <type_traits>
 #include <utility> // in_place_t
 
 #include "types.h"
 
 template<class T>

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/ctor.in_place.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
 // template<class ...Args>
 // explicit <copyable-box>::<copyable-box>(in_place_t, Args&& ...args);
 
-#include <__ranges/copyable_box.h>
+#include <ranges>
 
 #include <cassert>
 #include <type_traits>
 #include <utility> // in_place_t
 
 #include "types.h"
 
 struct UnknownType { };

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/deref.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
 // T& <copyable-box>::operator*()
 // T const& <copyable-box>::operator*() const
 
-#include <__ranges/copyable_box.h>
+#include <ranges>
 
 #include <cassert>
 #include <type_traits>
 #include <utility> // in_place_t
 
 #include "types.h"
 
 template<class T>

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/has_value.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
 // bool <copyable-box>::__has_value() const
 
-#include <__ranges/copyable_box.h>
+#include <ranges>
 
 #include <cassert>
 #include <type_traits>
 #include <utility> // in_place_t
 
 #include "types.h"
 
 template<class T>

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/no_unique_address.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
 // This test ensures that <copyable-box> behaves correctly when it holds an empty type.
 
-#include <__ranges/copyable_box.h>
+#include <ranges>
 
 #include <cassert>
 #include <utility>
 
 bool copied = false;
 bool moved = false;
 
 struct Empty {

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/properties.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
 // Test various properties of <copyable-box>
 
-#include <__ranges/copyable_box.h>
+#include <ranges>
 
 #include <optional>
 
 #include "types.h"
 
 template <class T>
 constexpr bool valid_copyable_box = requires {
   typename std::ranges::__copyable_box<T>;

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/types.h

 //===----------------------------------------------------------------------===//
 //
 // 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 TEST_LIBCXX_RANGES_RANGE_ADAPTORS_RANGE_COPY_WRAP_TYPES_H
 #define TEST_LIBCXX_RANGES_RANGE_ADAPTORS_RANGE_COPY_WRAP_TYPES_H
 
-#include <__ranges/copyable_box.h>
+#include <ranges>
 #include <cassert>
 #include <concepts>
 #include <type_traits>
 
 #include "test_macros.h"
 
 // NOTE: These types are strongly tied to the implementation of __copyable_box. See the documentation
 //       in __copyable_box for the meaning of optimizations #1 and #2.