[libcxx][modularisation] properly modularises advance, next, and prev

[cjdb]

Summary

__function_like wasn't being exported, so certain properties of the
ranges functions weren't being propagated in modules land.

[cjdb]

Distinct from D105076 since this patch does more than just splicing.

[cjdb]

• simplifies patch based on current libc++ trajectory

[zoecarver]

Thanks for the cleanup.

libcxx/include/module.modulemap

455–456

I don't like the formatting here. But whatever.

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/special_function.compile.pass.cpp

13–14

Don't we still support clang-13 or am I missing something? Does this patch work around the bug?

[• Quuxplusone]

libcxx/include/module.modulemap

455–456

There should be no need to export __function_like here. Then it'll all fit on one line, consistent with all the other lines, so there won't be a formatting problem anymore.

744–746

Probably this private is the original problem. What happens if you remove it?
(Compare to __hash_table, __nullptr, etc.)

[cjdb]

libcxx/include/module.modulemap

455–456

I don't like the formatting here. But whatever.

Yeah, I didn't notice till after I threw it up on Phab. Will fix before merging.

There should be no need to export __function_like here. Then it'll all fit on one line, consistent with all the other lines, so there won't be a formatting problem anymore.

There is a need to export __function_like. I've gone into this in other patches before, so I'm not going to repeat myself here.

744–746

Nope. Nothing gets fixed because this isn't the problem.

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/special_function.compile.pass.cpp

13–14

This patch isn't a workaround: it's the correct fix.

[Mordante]

LGTM, but please hold off landing a short time to give @Quuxplusone an opportunity to respond.

libcxx/include/module.modulemap

455–456

There should be no need to export __function_like here.

I agree, but clang disagrees. I had the same issue in my format series, before we made these headers private.
I know no other solution than what @cjdb did here.

[• Quuxplusone]

libcxx/include/__iterator/advance.h

61–62

Btw, should there be a private here? __next_fn and __prev_fn both use private inheritance here, not public inheritance. At least we should be consistent.
(obsoleted by D106567)

libcxx/include/module.modulemap

455–456

I've looked into it a bit, and uploaded D106567 with a simpler fix.

[cjdb]

@ldionne now needs to weigh in on this in order for any progress to be made, which I was hoping to avoid.

libcxx/include/module.modulemap

455–456

You have a strange definition of the word "simpler".

[ldionne]

Ah-Ah! So that was the issue all along then.

IMO this module-specific fix is cleaner than using a macro just to satisfy the modules build.

libcxx/include/CMakeLists.txt

set(files
   __iterator/iterator_traits.h
   __iterator/iterator.h
   __iterator/move_iterator.h
   __iterator/next.h
   __iterator/ostream_iterator.h
   __iterator/ostreambuf_iterator.h
   __iterator/prev.h
   __iterator/projected.h
+  __iterator/ranges/advance.h
+  __iterator/ranges/next.h
+  __iterator/ranges/prev.h
   __iterator/readable_traits.h
   __iterator/reverse_iterator.h
   __iterator/wrap_iter.h
   __libcpp_version
   __locale
   __memory/addressof.h
   __memory/allocation_guard.h
   __memory/allocator.h

libcxx/include/__iterator/advance.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ITERATOR_ADVANCE_H
 #define _LIBCPP___ITERATOR_ADVANCE_H
 
 #include <__config>
 #include <__debug>
-#include <__function_like.h>
-#include <__iterator/concepts.h>
-#include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
-#include <concepts>
-#include <limits>
 #include <type_traits>
-#include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
template <
     class = typename enable_if<is_integral<decltype(_VSTD::__convert_to_integral(declval<_Distance>()))>::value>::type>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 void advance(_InputIter& __i, _Distance __orig_n) {
   typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize;
   _IntegralSize __n = __orig_n;
   _LIBCPP_ASSERT(__n >= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
                  "Attempt to advance(it, n) with negative n on a non-bidirectional iterator");
   _VSTD::__advance(__i, __n, typename iterator_traits<_InputIter>::iterator_category());
 }
 
-#if !defined(_LIBCPP_HAS_NO_RANGES)
-
-namespace ranges {
-// [range.iter.op.advance]
-struct __advance_fn final : __function_like {
-private:
-  template <class _Tp>
-  static constexpr _Tp __abs(_Tp __n) noexcept {
-    return __n < 0 ? -__n : __n;
-  }
-
-  template <class _Ip>
-  static constexpr void __advance_forward(_Ip& __i, iter_difference_t<_Ip> __n) {
-    while (__n > 0) {
-      --__n;
-      ++__i;
-    }
-  }
-
-  template <class _Ip>
-  static constexpr void __advance_backward(_Ip& __i, iter_difference_t<_Ip> __n) {
-    while (__n < 0) {
-      ++__n;
-      --__i;
-    }
-  }
-
-public:
-  constexpr explicit __advance_fn(__tag __x) noexcept : __function_like(__x) {}
-
-  // Preconditions: If `I` does not model `bidirectional_iterator`, `n` is not negative.
-  template <input_or_output_iterator _Ip>
-  constexpr void operator()(_Ip& __i, iter_difference_t<_Ip> __n) const {
-    _LIBCPP_ASSERT(__n >= 0 || bidirectional_iterator<_Ip>,
-                   "If `n < 0`, then `bidirectional_iterator<I>` must be true.");
-
-    // If `I` models `random_access_iterator`, equivalent to `i += n`.
-    if constexpr (random_access_iterator<_Ip>) {
-      __i += __n;
-      return;
-    } else if constexpr (bidirectional_iterator<_Ip>) {
-      // Otherwise, if `n` is non-negative, increments `i` by `n`.
-      __advance_forward(__i, __n);
-      // Otherwise, decrements `i` by `-n`.
-      __advance_backward(__i, __n);
-      return;
-    } else {
-      // Otherwise, if `n` is non-negative, increments `i` by `n`.
-      __advance_forward(__i, __n);
-      return;
-    }
-  }
-
-  // Preconditions: Either `assignable_from<I&, S> || sized_sentinel_for<S, I>` is modeled, or [i, bound) denotes a range.
-  template <input_or_output_iterator _Ip, sentinel_for<_Ip> _Sp>
-  constexpr void operator()(_Ip& __i, _Sp __bound) const {
-    // If `I` and `S` model `assignable_from<I&, S>`, equivalent to `i = std::move(bound)`.
-    if constexpr (assignable_from<_Ip&, _Sp>) {
-      __i = std::move(__bound);
-    }
-    // Otherwise, if `S` and `I` model `sized_sentinel_for<S, I>`, equivalent to `ranges::advance(i, bound - i)`.
-    else if constexpr (sized_sentinel_for<_Sp, _Ip>) {
-      (*this)(__i, __bound - __i);
-    }
-    // Otherwise, while `bool(i != bound)` is true, increments `i`.
-    else {
-      while (__i != __bound) {
-        ++__i;
-      }
-    }
-  }
-
-  // Preconditions:
-  //   * If `n > 0`, [i, bound) denotes a range.
-  //   * If `n == 0`, [i, bound) or [bound, i) denotes a range.
-  //   * If `n < 0`, [bound, i) denotes a range, `I` models `bidirectional_iterator`, and `I` and `S` model `same_as<I, S>`.
-  // Returns: `n - M`, where `M` is the difference between the the ending and starting position.
-  template <input_or_output_iterator _Ip, sentinel_for<_Ip> _Sp>
-  constexpr iter_difference_t<_Ip> operator()(_Ip& __i, iter_difference_t<_Ip> __n, _Sp __bound) const {
-    _LIBCPP_ASSERT(__n >= 0 || (bidirectional_iterator<_Ip> && same_as<_Ip, _Sp>),
-                   "If `n < 0`, then `bidirectional_iterator<I> && same_as<I, S>` must be true.");
-    // If `S` and `I` model `sized_sentinel_for<S, I>`:
-    if constexpr (sized_sentinel_for<_Sp, _Ip>) {
-      // If |n| >= |bound - i|, equivalent to `ranges::advance(i, bound)`.
-      if (const auto __M = __bound - __i; __abs(__n) >= __abs(__M)) {
-        (*this)(__i, __bound);
-        return __n - __M;
-      }
-
-      // Otherwise, equivalent to `ranges::advance(i, n)`.
-      (*this)(__i, __n);
-      return 0;
-    } else {
-      // Otherwise, if `n` is non-negative, while `bool(i != bound)` is true, increments `i` but at
-      // most `n` times.
-      while (__i != __bound && __n > 0) {
-        ++__i;
-        --__n;
-      }
-
-      // Otherwise, while `bool(i != bound)` is true, decrements `i` but at most `-n` times.
-      if constexpr (bidirectional_iterator<_Ip> && same_as<_Ip, _Sp>) {
-        while (__i != __bound && __n < 0) {
-          --__i;
-          ++__n;
-        }
-      }
-      return __n;
-    }
-
-    _LIBCPP_UNREACHABLE();
-  }
-};
-
-inline constexpr auto advance = __advance_fn(__function_like::__tag());
-} // namespace ranges
-
-#endif // !defined(_LIBCPP_HAS_NO_RANGES)
-
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___ITERATOR_ADVANCE_H

libcxx/include/__iterator/next.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ITERATOR_NEXT_H
 #define _LIBCPP___ITERATOR_NEXT_H
 
 #include <__config>
 #include <__debug>
-#include <__function_like.h>
 #include <__iterator/advance.h>
-#include <__iterator/concepts.h>
-#include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIter>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     typename enable_if<__is_cpp17_input_iterator<_InputIter>::value, _InputIter>::type
     next(_InputIter __x, typename iterator_traits<_InputIter>::difference_type __n = 1) {
   _LIBCPP_ASSERT(__n >= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
                  "Attempt to next(it, n) with negative n on a non-bidirectional iterator");
 
   _VSTD::advance(__x, __n);
   return __x;
 }
 
-#if !defined(_LIBCPP_HAS_NO_RANGES)
-
-namespace ranges {
-struct __next_fn final : private __function_like {
-  constexpr explicit __next_fn(__tag __x) noexcept : __function_like(__x) {}
-
-  template <input_or_output_iterator _Ip>
-  constexpr _Ip operator()(_Ip __x) const {
-    ++__x;
-    return __x;
-  }
-
-  template <input_or_output_iterator _Ip>
-  constexpr _Ip operator()(_Ip __x, iter_difference_t<_Ip> __n) const {
-    ranges::advance(__x, __n);
-    return __x;
-  }
-
-  template <input_or_output_iterator _Ip, sentinel_for<_Ip> _Sp>
-  constexpr _Ip operator()(_Ip __x, _Sp __bound) const {
-    ranges::advance(__x, __bound);
-    return __x;
-  }
-
-  template <input_or_output_iterator _Ip, sentinel_for<_Ip> _Sp>
-  constexpr _Ip operator()(_Ip __x, iter_difference_t<_Ip> __n, _Sp __bound) const {
-    ranges::advance(__x, __n, __bound);
-    return __x;
-  }
-};
-
-inline constexpr auto next = __next_fn(__function_like::__tag());
-} // namespace ranges
-
-#endif // !defined(_LIBCPP_HAS_NO_RANGES)
-
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___ITERATOR_PRIMITIVES_H

libcxx/include/__iterator/prev.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ITERATOR_PREV_H
 #define _LIBCPP___ITERATOR_PREV_H
 
 #include <__config>
 #include <__debug>
-#include <__function_like.h>
 #include <__iterator/advance.h>
-#include <__iterator/concepts.h>
-#include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIter>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     typename enable_if<__is_cpp17_input_iterator<_InputIter>::value, _InputIter>::type
     prev(_InputIter __x, typename iterator_traits<_InputIter>::difference_type __n = 1) {
   _LIBCPP_ASSERT(__n <= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
                  "Attempt to prev(it, n) with a positive n on a non-bidirectional iterator");
   _VSTD::advance(__x, -__n);
   return __x;
 }
 
-#if !defined(_LIBCPP_HAS_NO_RANGES)
-
-namespace ranges {
-struct __prev_fn final : private __function_like {
-  constexpr explicit __prev_fn(__tag __x) noexcept : __function_like(__x) {}
-
-  template <bidirectional_iterator _Ip>
-  constexpr _Ip operator()(_Ip __x) const {
-    --__x;
-    return __x;
-  }
-
-  template <bidirectional_iterator _Ip>
-  constexpr _Ip operator()(_Ip __x, iter_difference_t<_Ip> __n) const {
-    ranges::advance(__x, -__n);
-    return __x;
-  }
-
-  template <bidirectional_iterator _Ip>
-  constexpr _Ip operator()(_Ip __x, iter_difference_t<_Ip> __n, _Ip __bound) const {
-    ranges::advance(__x, -__n, __bound);
-    return __x;
-  }
-};
-
-inline constexpr auto prev = __prev_fn(__function_like::__tag());
-} // namespace ranges
-
-#endif // !defined(_LIBCPP_HAS_NO_RANGES)
-
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___ITERATOR_PREV_H

libcxx/include/__iterator/ranges/advance.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef _LIBCPP___ITERATOR_ADVANCE_H
-#define _LIBCPP___ITERATOR_ADVANCE_H
+#ifndef _LIBCPP___ITERATOR_RANGES_ADVANCE_H
+#define _LIBCPP___ITERATOR_RANGES_ADVANCE_H
 
 #include <__config>
 #include <__debug>
 #include <__function_like.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
-#include <__iterator/iterator_traits.h>
+#include <__utility/move.h>
 #include <concepts>
-#include <limits>
 #include <type_traits>
-#include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _InputIter>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 void
-__advance(_InputIter& __i, typename iterator_traits<_InputIter>::difference_type __n, input_iterator_tag) {
-  for (; __n > 0; --__n)
-    ++__i;
-}
-
-template <class _BiDirIter>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 void
-__advance(_BiDirIter& __i, typename iterator_traits<_BiDirIter>::difference_type __n, bidirectional_iterator_tag) {
-  if (__n >= 0)
-    for (; __n > 0; --__n)
-      ++__i;
-  else
-    for (; __n < 0; ++__n)
-      --__i;
-}
-
-template <class _RandIter>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 void
-__advance(_RandIter& __i, typename iterator_traits<_RandIter>::difference_type __n, random_access_iterator_tag) {
-  __i += __n;
-}
-
-template <
-    class _InputIter, class _Distance,
-    class = typename enable_if<is_integral<decltype(_VSTD::__convert_to_integral(declval<_Distance>()))>::value>::type>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 void advance(_InputIter& __i, _Distance __orig_n) {
-  typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize;
-  _IntegralSize __n = __orig_n;
-  _LIBCPP_ASSERT(__n >= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
-                 "Attempt to advance(it, n) with negative n on a non-bidirectional iterator");
-  _VSTD::__advance(__i, __n, typename iterator_traits<_InputIter>::iterator_category());
-}
-
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 
 namespace ranges {
 // [range.iter.op.advance]
 struct __advance_fn final : __function_like {
 private:
   template <class _Tp>
   static constexpr _Tp __abs(_Tp __n) noexcept {

 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
-#endif // _LIBCPP___ITERATOR_ADVANCE_H
+#endif // _LIBCPP___ITERATOR_RANGES_ADVANCE_H

libcxx/include/__iterator/ranges/next.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ITERATOR_NEXT_H
 #define _LIBCPP___ITERATOR_NEXT_H
 
 #include <__config>
-#include <__debug>
 #include <__function_like.h>
-#include <__iterator/advance.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
-#include <__iterator/iterator_traits.h>
+#include <__iterator/ranges/advance.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _InputIter>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-    typename enable_if<__is_cpp17_input_iterator<_InputIter>::value, _InputIter>::type
-    next(_InputIter __x, typename iterator_traits<_InputIter>::difference_type __n = 1) {
-  _LIBCPP_ASSERT(__n >= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
-                 "Attempt to next(it, n) with negative n on a non-bidirectional iterator");
-
-  _VSTD::advance(__x, __n);
-  return __x;
-}
-
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 
 namespace ranges {
 struct __next_fn final : private __function_like {
   constexpr explicit __next_fn(__tag __x) noexcept : __function_like(__x) {}
 
   template <input_or_output_iterator _Ip>
   constexpr _Ip operator()(_Ip __x) const {

libcxx/include/__iterator/ranges/prev.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ITERATOR_PREV_H
 #define _LIBCPP___ITERATOR_PREV_H
 
 #include <__config>
-#include <__debug>
 #include <__function_like.h>
-#include <__iterator/advance.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
-#include <__iterator/iterator_traits.h>
+#include <__iterator/ranges/advance.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _InputIter>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-    typename enable_if<__is_cpp17_input_iterator<_InputIter>::value, _InputIter>::type
-    prev(_InputIter __x, typename iterator_traits<_InputIter>::difference_type __n = 1) {
-  _LIBCPP_ASSERT(__n <= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
-                 "Attempt to prev(it, n) with a positive n on a non-bidirectional iterator");
-  _VSTD::advance(__x, -__n);
-  return __x;
-}
-
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 
 namespace ranges {
 struct __prev_fn final : private __function_like {
   constexpr explicit __prev_fn(__tag __x) noexcept : __function_like(__x) {}
 
   template <bidirectional_iterator _Ip>
   constexpr _Ip operator()(_Ip __x) const {

libcxx/include/__ranges/drop_view.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP___RANGES_DROP_VIEW_H
 #define _LIBCPP___RANGES_DROP_VIEW_H
 
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/concepts.h>
+#include <__iterator/ranges/next.h>
 #include <__ranges/access.h>
 #include <__ranges/view_interface.h>
 #include <__ranges/all.h>
 #include <type_traits>
 #include <optional>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

libcxx/include/__ranges/subrange.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP___RANGES_SUBRANGE_H
 #define _LIBCPP___RANGES_SUBRANGE_H
 
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
-#include <__iterator/advance.h>
+#include <__iterator/ranges/advance.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
 #include <__ranges/view_interface.h>
 #include <concepts>
 #include <type_traits>

libcxx/include/__ranges/view_interface.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP___RANGES_VIEW_INTERFACE_H
 #define _LIBCPP___RANGES_VIEW_INTERFACE_H
 
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
-#include <__iterator/prev.h>
+#include <__iterator/ranges/prev.h>
 #include <__memory/pointer_traits.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/empty.h>
 #include <__ranges/enable_view.h>
 #include <concepts>
 #include <type_traits>
 

libcxx/include/iterator

 #include <__iterator/iterator_traits.h>
 #include <__iterator/iterator.h>
 #include <__iterator/move_iterator.h>
 #include <__iterator/next.h>
 #include <__iterator/ostream_iterator.h>
 #include <__iterator/ostreambuf_iterator.h>
 #include <__iterator/prev.h>
 #include <__iterator/projected.h>
+#include <__iterator/ranges/advance.h>
+#include <__iterator/ranges/next.h>
+#include <__iterator/ranges/prev.h>
 #include <__iterator/readable_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__iterator/wrap_iter.h>
 #include <__memory/addressof.h>
 #include <__memory/pointer_traits.h>
 #include <__utility/forward.h>
 #include <compare>
 #include <concepts> // Mandated by the Standard.

libcxx/include/module.modulemap

module istream {
     header "istream"
     // FIXME: should re-export ios, streambuf?
     export *
   }
   module iterator {
     header "iterator"
     export *
 
     module __iterator {
       module advance                { header "__iterator/advance.h"               }
       module back_insert_iterator   { header "__iterator/back_insert_iterator.h"  }
       module concepts               { header "__iterator/concepts.h"              }
       module default_sentinel       { header "__iterator/default_sentinel.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_iterator       { header "__iterator/reverse_iterator.h"      }
       module wrap_iter              { header "__iterator/wrap_iter.h"             }
+
+      module ranges {
+        module advance {
+          header "__iterator/ranges/advance.h"
+          export __function_like
+        }
+
+        module next {
+          header "__iterator/ranges/next.h"
+          export __function_like
+        }
+
+        module prev {
+          header "__iterator/ranges/prev.h"
+          export __function_like
+        }
+      }
     }
   }
   module latch {
     requires cplusplus14
     header "latch"
     export *
   }
   module limits {
module std [system] {
   // __config not modularised due to a bug in Clang
   // __functional(_03)?_base not modularised since it's designed for textual inclusion
   // libcpp_version not modularised since it's just a version number
   // FIXME: These should be private.
   module __availability      { header "__availability"      export * }
   module __bit_reference     { header "__bit_reference"     export * }
   module __bits              { header "__bits"              export * }
   module __debug             { header "__debug"             export * }
   module __errc              { header "__errc"              export * }
   module __function_like     { header "__function_like.h"   export * }
   module __functional_base   { header "__functional_base"   export * }
   module __hash_table        { header "__hash_table"        export * }
   module __locale            { header "__locale"            export * }
   module __mutex_base        { header "__mutex_base"        export * }
   module __node_handle       { header "__node_handle"       export * }
   module __nullptr           { header "__nullptr"           export * }
   module __split_buffer      { header "__split_buffer"      export * }
   module __std_stream        { header "__std_stream"        export * }
   module __string            { header "__string"            export * }

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/special_function.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
-// XFAIL: clang-11 && modules-build
-// XFAIL: clang-12 && modules-build
 
 // ranges::advance
 
 #include <iterator>
 
 #include "test_standard_function.h"
 
 static_assert(is_function_like<decltype(std::ranges::advance)>());
 

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/special_function.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
-// XFAIL: clang-11 && modules-build
-// XFAIL: clang-12 && modules-build
 
 // ranges::next
 
 #include <iterator>
 
 #include "test_standard_function.h"
 
 static_assert(is_function_like<decltype(std::ranges::next)>());

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.prev/special_function.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
-// XFAIL: clang-11 && modules-build
-// XFAIL: clang-12 && modules-build
 
 // ranges::prev
 
 #include <iterator>
 
 #include "test_iterators.h"
 #include "test_standard_function.h"