[libcxx][ranges] Move `namespace views` into `namespace ranges` and add an alias.

[zoecarver]

libcxx/test/std/ranges/range.adaptors/range.all/all.pass.cpp

88

Intentionally testing this inconsistently so that we cover both std::ranges::views and std::views.

[cjdb]

LGTM! Please add a test to make sure that std::views::X is the same as std::ranges::views::X before committing.

[• Quuxplusone]

libcxx/include/__ranges/all.h

35–36

Any appetite for namespace ranges::views { here? I have a slight preference for it, but won't push hard for it right now.

libcxx/test/std/ranges/range.adaptors/range.all/all.pass.cpp

88

I don't particularly object, because I probably wouldn't have noticed if the test had been committed this way to begin with. But if you want to test that std::views is the same as std::ranges::views, the right place for that test is not semi-accidentally inside all.pass.cpp; it may deserve a dedicated test file.
(However, IMHO it also doesn't need a test of its own, because it's super obvious.)

[zoecarver]

libcxx/include/__ranges/all.h

35–36

Good idea. Done.

libcxx/test/std/ranges/range.adaptors/range.all/all.pass.cpp

88

I updated these to have a specific test in the same file.

libcxx/include/__ranges/all.h

 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 
+namespace ranges {
 namespace views {
 
 namespace __all {
   struct __fn {
     template<class _Tp>
       requires ranges::view<decay_t<_Tp>>
     _LIBCPP_HIDE_FROM_ABI
     constexpr auto operator()(_Tp&& __t) const
       noexcept(noexcept(_VSTD::__decay_copy(_VSTD::forward<_Tp>(__t))))

 inline namespace __cpo {
   inline constexpr auto all = __all::__fn{};
 } // namespace __cpo
 
 template<ranges::viewable_range _Range>
 using all_t = decltype(views::all(declval<_Range>()));
 
 } // namespace views
+} // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___RANGES_ALL_H

libcxx/include/__ranges/counted.h

 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 
+namespace ranges {
 namespace views {
 
 namespace __counted {
   template<class _From, class _To>
   concept __explicitly_convertible = requires {
     _To(_From{});
   };
 
namespace __counted {
   };
 }
 
 inline namespace __cpo {
   inline constexpr auto counted = __counted::__fn{};
 } // namespace __cpo
 
 } // namespace views
+} // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___RANGES_COUNTED_H

libcxx/include/__ranges/iota_view.h

//       }
 
   template<class _Start, class _Bound>
     requires (!__integer_like<_Start> || !__integer_like<_Bound> ||
               (__signed_integer_like<_Start> == __signed_integer_like<_Bound>))
   iota_view(_Start, _Bound) -> iota_view<_Start, _Bound>;
 
   template<class _Start, class _Bound>
   inline constexpr bool enable_borrowed_range<iota_view<_Start, _Bound>> = true;
-} // namespace ranges
 
 namespace views {
 namespace __iota {
   struct __fn {
     template<class _Start>
     _LIBCPP_HIDE_FROM_ABI
     constexpr auto operator()(_Start&& __start) const
       noexcept(noexcept(ranges::iota_view(_VSTD::forward<_Start>(__start))))
struct __fn {
     }
   };
 } // namespace __iota
 
 inline namespace __cpo {
   inline constexpr auto iota = __iota::__fn{};
 }
 } // namespace views
+} // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_IOTA_VIEW_H

libcxx/include/ranges

 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_RANGES)
 
+namespace views = ranges::views;
+
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 #endif // _LIBCPP_RANGES

libcxx/test/std/ranges/range.adaptors/range.all/all.pass.cpp

struct RandomAccessRange {
   constexpr random_access_iterator<int*> begin() { return random_access_iterator<int*>{globalBuff}; }
   constexpr sentinel end() { return {}; }
 };
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<RandomAccessRange> = true;
 
 constexpr bool test() {
   {
-    ASSERT_SAME_TYPE(decltype(std::views::all(View<true>())), View<true>);
-    static_assert(noexcept(std::views::all(View<true>())));
-    static_assert(!noexcept(std::views::all(View<false>())));
+    ASSERT_SAME_TYPE(decltype(std::ranges::views::all(View<true>())), View<true>);
+    static_assert(noexcept(std::ranges::views::all(View<true>())));
+    static_assert(!noexcept(std::ranges::views::all(View<false>())));
 
     auto viewCopy = std::views::all(View<true>(2));
     ASSERT_SAME_TYPE(decltype(viewCopy), View<true>);
     assert(std::ranges::begin(viewCopy) == globalBuff + 2);
     assert(std::ranges::end(viewCopy) == globalBuff + 8);
   }
 
   {
-    ASSERT_SAME_TYPE(decltype(std::views::all(std::declval<const CopyableView<true>&>())), CopyableView<true>);
-    static_assert(noexcept(std::views::all(CopyableView<true>())));
-    static_assert(!noexcept(std::views::all(CopyableView<false>())));
+    ASSERT_SAME_TYPE(decltype(std::ranges::views::all(std::declval<const CopyableView<true>&>())), CopyableView<true>);
+    static_assert(noexcept(std::ranges::views::all(CopyableView<true>())));
+    static_assert(!noexcept(std::ranges::views::all(CopyableView<false>())));
 
     CopyableView<true> view(2);
     auto viewCopy = std::views::all(view);
     ASSERT_SAME_TYPE(decltype(viewCopy), CopyableView<true>);
     assert(std::ranges::begin(viewCopy) == globalBuff + 2);
     assert(std::ranges::end(viewCopy) == globalBuff + 8);
   }
 

libcxx/test/std/ranges/range.adaptors/range.counted/counted.pass.cpp

int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
     static_assert(!CountedInvocable<contiguous_iterator<int*>, Unrelated>);
 
     static_assert(std::semiregular<std::remove_const_t<decltype(std::views::counted)>>);
   }
 
   {
     {
       contiguous_iterator<int*> iter(buffer);
-      std::span<int> s = std::views::counted(iter, 8);
+      std::span<int> s = std::ranges::views::counted(iter, 8);
       assert(s.size() == 8);
       assert(s.data() == buffer);
 
       ASSERT_SAME_TYPE(decltype(std::views::counted(iter, 8)), std::span<int>);
     }
     {
       const contiguous_iterator<int*> iter(buffer);
-      std::span<int> s = std::views::counted(iter, 8);
+      std::span<int> s = std::ranges::views::counted(iter, 8);
       assert(s.size() == 8);
       assert(s.data() == buffer);
 
       ASSERT_SAME_TYPE(decltype(std::views::counted(iter, 8)), std::span<int>);
     }
     {
       contiguous_iterator<const int*> iter(buffer);
-      std::span<const int> s = std::views::counted(iter, 8);
+      std::span<const int> s = std::ranges::views::counted(iter, 8);
       assert(s.size() == 8);
       assert(s.data() == buffer);
 
       ASSERT_SAME_TYPE(decltype(std::views::counted(iter, 8)), std::span<const int>);
     }
     {
       const contiguous_iterator<const int*> iter(buffer);
-      std::span<const int> s = std::views::counted(iter, 8);
+      std::span<const int> s = std::ranges::views::counted(iter, 8);
       assert(s.size() == 8);
       assert(s.data() == buffer);
 
       ASSERT_SAME_TYPE(decltype(std::views::counted(iter, 8)), std::span<const int>);
     }
   }
 
   {

libcxx/test/std/ranges/range.factories/range.iota.view/views_iota.pass.cpp

 #include "test_macros.h"
 #include "types.h"
 
 template<class T, class U>
 constexpr void testType(U u) {
   // Test that this generally does the right thing.
   // Test with only one argument.
   {
-    assert(*std::views::iota(T(0)).begin() == T(0));
+    assert(*std::ranges::views::iota(T(0)).begin() == T(0));
   }
   {
-    const auto io = std::views::iota(T(10));
+    const auto io = std::ranges::views::iota(T(10));
     assert(*io.begin() == T(10));
   }
   // Test with two arguments.
   {
-    assert(*std::views::iota(T(0), u).begin() == T(0));
+    assert(*std::ranges::views::iota(T(0), u).begin() == T(0));
   }
   {
     const auto io = std::views::iota(T(10), u);
     assert(*io.begin() == T(10));
   }
   // Test that we return the correct type.
   {
     ASSERT_SAME_TYPE(decltype(std::views::iota(T(10))), std::ranges::iota_view<T>);