[libcxx][modularisation] adds several headers to the module map

[cjdb]

Summary

• <__algorithm/iter_swap.h>
• <__algorithm/swap_ranges.h>
• <__functional/is_transparent.h>
• <__memory/uses_allocator.h>
• <__ranges/drop_view.h>
• <__ranges/transform_view.h>
• <shared_mutex>
• <span>

Also updates header inclusions that were affected.

**NOTE: This is a proper subset of D105932. Since the content has already been LGTM'd, I intend to merge this patch without review, pending green CI. I decided it would be better to move these changes into their own commit since the former patch has undergone further changes and will need yet another light review. In the event any of that gets rolled back (for whatever reason), the changes in this patch won't be affected.

[cjdb]

rebases to account for directory_iterator failure

[cjdb]

CI flaked, so rebasing and reactivating CI

libcxx/include/__ranges/drop_view.h

 #define _LIBCPP___RANGES_DROP_VIEW_H
 
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/next.h>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
+#include <__ranges/concepts.h>
+#include <__ranges/enable_borrowed_range.h>
+#include <__ranges/size.h>
 #include <__ranges/view_interface.h>
 #include <optional>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 

libcxx/include/__ranges/transform_view.h

 #include <__iterator/concepts.h>
 #include <__iterator/iter_swap.h>
 #include <__iterator/iterator_traits.h>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/concepts.h>
 #include <__ranges/copyable_box.h>
 #include <__ranges/empty.h>
+#include <__ranges/size.h>
 #include <__ranges/view_interface.h>
+#include <concepts>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/module.modulemap

module __algorithm {
       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 iter_swap                { header "__algorithm/iter_swap.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 __algorithm {
       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 swap_ranges              { header "__algorithm/swap_ranges.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 any {
module __functional {
       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 is_transparent             { header "__functional/is_transparent.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 __memory {
       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 uses_allocator           { header "__memory/uses_allocator.h"           }
     }
   }
   module mutex {
     header "mutex"
     export *
   }
   module new {
     header "new"
module ranges {
     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 drop_view              { header "__ranges/drop_view.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 transform_view         { header "__ranges/transform_view.h"        }
       module view_interface         { header "__ranges/view_interface.h"        }
     }
   }
   module ratio {
     header "ratio"
     export *
   }
   module regex {
module semaphore {
     header "semaphore"
     export *
   }
   module set {
     header "set"
     export initializer_list
     export *
   }
+  module shared_mutex {
+    header "shared_mutex"
+    export version
+  }
+  module span {
+    header "span"
+    export ranges.__ranges.enable_borrowed_range
+    export version
+  }
   module sstream {
     header "sstream"
     // FIXME: should re-export istream, ostream, ios, streambuf, string?
     export *
   }
   module stack {
     header "stack"
     export initializer_list

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/std/containers/views/span.sub/first.fail.cpp

 //  constexpr span<element_type, Count> first() const;
 //
 // constexpr span<element_type, dynamic_extent> first(size_type count) const;
 //
 //  Requires: Count <= size().
 
 #include <span>
 
+#include <cstddef>
+
 #include "test_macros.h"
 
 constexpr int carr[] = {1, 2, 3, 4};
 
 int main(int, char**) {
   std::span<const int, 4> sp(carr);
 
   //  Count too large

libcxx/test/std/containers/views/span.sub/last.fail.cpp

 //  constexpr span<element_type, Count> last() const;
 //
 // constexpr span<element_type, dynamic_extent> last(size_type count) const;
 //
 //  Requires: Count <= size().
 
 #include <span>
 
+#include <cstddef>
+
 #include "test_macros.h"
 
 constexpr int carr[] = {1, 2, 3, 4};
 
 int main(int, char**) {
   std::span<const int, 4> sp(carr);
 
   //  Count too large

libcxx/test/std/containers/views/span.sub/subspan.fail.cpp

 // constexpr span<element_type, dynamic_extent> subspan(
 //   size_type offset, size_type count = dynamic_extent) const;
 //
 //  Requires: offset <= size() &&
 //            (count == dynamic_extent || count <= size() - offset)
 
 #include <span>
 
+#include <cstddef>
+
 #include "test_macros.h"
 
 constexpr int carr[] = {1, 2, 3, 4};
 
 int main(int, char**) {
   std::span<const int, 4> sp(carr);
 
   //  Offset too large templatized

libcxx/test/std/ranges/range.adaptors/range.drop/dangling.cache.pass.cpp

 // UNSUPPORTED: gcc-10
 
 // If we have a copy-propagating cache, when we copy ZeroOnDestroy, we will get a
 // dangling reference to the copied-from object. This test ensures that we do not
 // propagate the cache on copy.
 
 #include <ranges>
 
+#include <cstddef>
+#include <cstring>
+
 #include "test_macros.h"
 #include "types.h"
 
 struct ZeroOnDestroy : std::ranges::view_base {
   unsigned count = 0;
   int buff[8] = {1, 2, 3, 4, 5, 6, 7, 8};
 
   constexpr ForwardIter begin() { return ForwardIter(buff); }

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_adopt_lock.pass.cpp

 // <shared_mutex>
 
 // template <class Mutex> class shared_lock;
 
 // shared_lock(mutex_type& m, adopt_lock_t);
 
 #include <shared_mutex>
 #include <cassert>
+#include <mutex>
 #include "nasty_containers.h"
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     typedef std::shared_timed_mutex M;

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_defer_lock.pass.cpp

 // <shared_mutex>
 
 // template <class Mutex> class shared_lock;
 
 // shared_lock(mutex_type& m, defer_lock_t);
 
 #include <shared_mutex>
 #include <cassert>
+#include <mutex>
 #include "nasty_containers.h"
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     typedef std::shared_timed_mutex M;

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock.pass.cpp

 // <shared_mutex>
 
 // template <class Mutex> class shared_lock;
 
 // bool try_lock();
 
 #include <shared_mutex>
 #include <cassert>
+#include <mutex>
 
 #include "test_macros.h"
 
 bool try_lock_called = false;
 
 struct mutex
 {
     bool try_lock_shared()

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_for.pass.cpp

 
 // template <class Mutex> class shared_lock;
 
 // template <class Rep, class Period>
 //   bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
 
 #include <shared_mutex>
 #include <cassert>
+#include <chrono>
+#include <mutex>
 
 #include "test_macros.h"
 
 bool try_lock_for_called = false;
 
 typedef std::chrono::milliseconds ms;
 
 struct mutex

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_until.pass.cpp

 
 // template <class Mutex> class shared_lock;
 
 // template <class Clock, class Duration>
 //   bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
 
 #include <shared_mutex>
 #include <cassert>
+#include <chrono>
+#include <mutex>
 
 #include "test_macros.h"
 
 bool try_lock_until_called = false;
 
 struct mutex
 {
     template <class Clock, class Duration>

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/unlock.pass.cpp

 // <shared_mutex>
 
 // template <class Mutex> class shared_lock;
 
 // void unlock();
 
 #include <shared_mutex>
 #include <cassert>
+#include <system_error>
 
 #include "test_macros.h"
 
 bool unlock_called = false;
 
 struct mutex
 {
     void lock_shared() {}

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/op_bool.pass.cpp

 // <shared_mutex>
 
 // template <class Mutex> class shared_lock;
 
 // explicit operator bool() const noexcept;
 
 #include <shared_mutex>
 #include <cassert>
+#include <type_traits>
 
 #include "test_macros.h"
 
 struct M {
     void lock_shared() {}
     void unlock_shared() {}
 };
 

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/types.pass.cpp

 // class shared_lock
 // {
 // public:
 //     typedef Mutex mutex_type;
 //     ...
 // };
 
 #include <shared_mutex>
+#include <mutex>
 #include <type_traits>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     static_assert((std::is_same<std::shared_lock<std::mutex>::mutex_type,
                    std::mutex>::value), "");
 
   return 0;
 }