[libc++][NFC] Create and use test-defined simple_view concept

libcxx/test/libcxx/ranges/range.utility.helpers/simple_view.compile.pass.cpp

@@ -14,6 +14,7 @@
 
 #include "test_macros.h"
 #include "test_iterators.h"
+#include "test_range.h"
 
 struct SimpleView : std::ranges::view_base {
   int *begin() const;
@@ -48,3 +49,9 @@ static_assert(!std::ranges::__simple_view<WrongConstView>);
 static_assert(!std::ranges::__simple_view<NoConstView>);
 static_assert( std::ranges::__simple_view<DifferentSentinel>);
 static_assert(!std::ranges::__simple_view<WrongConstSentinel>);
+
+static_assert(simple_view<SimpleView>);
+static_assert(!simple_view<WrongConstView>);
+static_assert(!simple_view<NoConstView>);
+static_assert(simple_view<DifferentSentinel>);
+static_assert(!simple_view<WrongConstSentinel>);

libcxx/test/std/ranges/range.adaptors/range.drop/begin.pass.cpp

@@ -18,6 +18,7 @@
 
 #include "test_macros.h"
 #include "test_iterators.h"
+#include "test_range.h"
 #include "types.h"
 
 template<class T>
@@ -122,7 +123,7 @@ constexpr bool test() {
   {
     static_assert(std::ranges::random_access_range<const SimpleView>);
     static_assert(std::ranges::sized_range<const SimpleView>);
-    LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<SimpleView>);
+    static_assert(simple_view<SimpleView>);
     int non_const_calls = 0;
     int const_calls = 0;
     std::ranges::drop_view dropView(SimpleView{{}, &non_const_calls, &const_calls}, 4);
@@ -137,7 +138,7 @@ constexpr bool test() {
   {
     static_assert(std::ranges::random_access_range<const NonSimpleView>);
     static_assert(std::ranges::sized_range<const NonSimpleView>);
-    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleView>);
+    static_assert(!simple_view<NonSimpleView>);
     int non_const_calls = 0;
     int const_calls = 0;
     std::ranges::drop_view dropView(NonSimpleView{{}, &non_const_calls, &const_calls}, 4);

libcxx/test/std/ranges/range.adaptors/range.drop/types.h

@@ -15,21 +15,21 @@
 int globalBuff[8];
 
 template <class T>
-struct sentinel {
+struct drop_sentinel {
   T* ptr_;
   int* num_of_sentinel_cmp_calls;
 
 public:
-  friend constexpr bool operator==(sentinel const s, T* const ptr) noexcept {
+  friend constexpr bool operator==(drop_sentinel const s, T* const ptr) noexcept {
     ++(*s.num_of_sentinel_cmp_calls);
     return {s.ptr_ == ptr};
   }
-  friend constexpr bool operator==(T* const ptr, sentinel const s) noexcept {
+  friend constexpr bool operator==(T* const ptr, drop_sentinel const s) noexcept {
     ++(*s.num_of_sentinel_cmp_calls);
     return {s.ptr_ == ptr};
   }
-  friend constexpr bool operator!=(sentinel const s, T* const ptr) noexcept { return !(s == ptr); }
-  friend constexpr bool operator!=(T* const ptr, sentinel const s) noexcept { return !(s == ptr); }
+  friend constexpr bool operator!=(drop_sentinel const s, T* const ptr) noexcept { return !(s == ptr); }
+  friend constexpr bool operator!=(T* const ptr, drop_sentinel const s) noexcept { return !(s == ptr); }
 };
 
 template <bool IsSimple>
@@ -39,9 +39,9 @@ struct MaybeSimpleNonCommonView : std::ranges::view_base {
   constexpr std::size_t size() const { return 8; }
   constexpr int* begin() { return globalBuff + start_; }
   constexpr std::conditional_t<IsSimple, int*, const int*> begin() const { return globalBuff + start_; }
-  constexpr sentinel<int> end() { return sentinel<int>{globalBuff + size(), num_of_sentinel_cmp_calls}; }
+  constexpr drop_sentinel<int> end() { return drop_sentinel<int>{globalBuff + size(), num_of_sentinel_cmp_calls}; }
   constexpr auto end() const {
-    return std::conditional_t<IsSimple, sentinel<int>, sentinel<const int>>{
+    return std::conditional_t<IsSimple, drop_sentinel<int>, drop_sentinel<const int>>{
         globalBuff + size(), num_of_sentinel_cmp_calls};
   }
 };

libcxx/test/std/ranges/range.adaptors/range.elements/types.h

@@ -58,8 +58,8 @@ using NonSimpleCommonRandomAccessSized = NonSimpleCommon;
 static_assert(std::ranges::common_range<Common<true>>);
 static_assert(std::ranges::random_access_range<SimpleCommon>);
 static_assert(std::ranges::sized_range<SimpleCommon>);
-LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<SimpleCommon>);
-LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleCommon>);
+static_assert(simple_view<SimpleCommon>);
+static_assert(!simple_view<NonSimpleCommon>);
 
 template <bool Simple>
 struct NonCommon : TupleBufferView {
@@ -86,8 +86,8 @@ using NonSimpleNonCommon = NonCommon<false>;
 static_assert(!std::ranges::common_range<SimpleNonCommon>);
 static_assert(std::ranges::random_access_range<SimpleNonCommon>);
 static_assert(!std::ranges::sized_range<SimpleNonCommon>);
-LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<SimpleNonCommon>);
-LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleNonCommon>);
+static_assert(simple_view<SimpleNonCommon>);
+static_assert(!simple_view<NonSimpleNonCommon>);
 
 template <class Derived>
 struct IterBase {

libcxx/test/std/ranges/range.adaptors/range.join/range.join.sentinel/ctor.other.pass.cpp

@@ -15,6 +15,7 @@
 #include <ranges>
 
 #include "../types.h"
+#include "test_range.h"
 
 template <class T>
 struct convertible_sentinel_wrapper {
@@ -45,7 +46,7 @@ struct ConstConvertibleView : BufferView<BufferView<int*>*> {
 static_assert(!std::ranges::common_range<ConstConvertibleView>);
 static_assert(std::convertible_to<std::ranges::sentinel_t<ConstConvertibleView>,
                                   std::ranges::sentinel_t<ConstConvertibleView const>>);
-LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<ConstConvertibleView>);
+static_assert(!simple_view<ConstConvertibleView>);
 
 constexpr bool test() {
   int buffer[4][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}};

libcxx/test/std/ranges/range.adaptors/range.join/types.h

@@ -16,6 +16,7 @@
 
 #include "test_macros.h"
 #include "test_iterators.h"
+#include "test_range.h"
 
 inline int globalBuffer[4][4] = {
     {1111, 2222, 3333, 4444},
@@ -239,37 +240,37 @@ using SimpleInputCommonOuter = BufferView<common_input_iterator<Inner*>>;
 static_assert(!std::ranges::forward_range<SimpleInputCommonOuter<>>);
 static_assert(!std::ranges::bidirectional_range<SimpleInputCommonOuter<>>);
 static_assert(std::ranges::common_range<SimpleInputCommonOuter<>>);
-LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<SimpleInputCommonOuter<>>);
+static_assert(simple_view<SimpleInputCommonOuter<>>);
 
 template <class Inner = BufferView<int*>>
 using NonSimpleInputCommonOuter = BufferView<common_input_iterator<const Inner*>, common_input_iterator<const Inner*>,
                                              common_input_iterator< Inner*>, common_input_iterator< Inner*>>;
 static_assert(!std::ranges::forward_range<NonSimpleInputCommonOuter<>>);
 static_assert(!std::ranges::bidirectional_range<NonSimpleInputCommonOuter<>>);
 static_assert(std::ranges::common_range<NonSimpleInputCommonOuter<>>);
-LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleInputCommonOuter<>>);
+static_assert(!simple_view<NonSimpleInputCommonOuter<>>);
 
 template <class Inner = BufferView<int*>>
 using SimpleForwardCommonOuter = BufferView<forward_iterator<Inner*>>;
 static_assert(std::ranges::forward_range<SimpleForwardCommonOuter<>>);
 static_assert(!std::ranges::bidirectional_range<SimpleForwardCommonOuter<>>);
 static_assert(std::ranges::common_range<SimpleForwardCommonOuter<>>);
-LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<SimpleForwardCommonOuter<>>);
+static_assert(simple_view<SimpleForwardCommonOuter<>>);
 
 template <class Inner = BufferView<int*>>
 using NonSimpleForwardCommonOuter = BufferView<forward_iterator<const Inner*>, forward_iterator<const Inner*>,
                                                forward_iterator<Inner*>, forward_iterator<Inner*>>;
 static_assert(std::ranges::forward_range<NonSimpleForwardCommonOuter<>>);
 static_assert(!std::ranges::bidirectional_range<NonSimpleForwardCommonOuter<>>);
 static_assert(std::ranges::common_range<NonSimpleForwardCommonOuter<>>);
-LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleForwardCommonOuter<>>);
+static_assert(!simple_view<NonSimpleForwardCommonOuter<>>);
 
 template <class Inner = BufferView<int*>>
 using SimpleForwardNonCommonOuter = BufferView<forward_iterator<Inner*>, sentinel_wrapper<forward_iterator<Inner*>>>;
 static_assert(std::ranges::forward_range<SimpleForwardNonCommonOuter<>>);
 static_assert(!std::ranges::bidirectional_range<SimpleForwardNonCommonOuter<>>);
 static_assert(!std::ranges::common_range<SimpleForwardNonCommonOuter<>>);
-LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<SimpleForwardNonCommonOuter<>>);
+static_assert(simple_view<SimpleForwardNonCommonOuter<>>);
 
 template <class Inner = BufferView<int*>>
 using NonSimpleForwardNonCommonOuter =
@@ -278,13 +279,13 @@ using NonSimpleForwardNonCommonOuter =
 static_assert(std::ranges::forward_range<NonSimpleForwardNonCommonOuter<>>);
 static_assert(!std::ranges::bidirectional_range<NonSimpleForwardNonCommonOuter<>>);
 static_assert(!std::ranges::common_range<NonSimpleForwardNonCommonOuter<>>);
-LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleForwardNonCommonOuter<>>);
+static_assert(!simple_view<NonSimpleForwardNonCommonOuter<>>);
 
 template <class Inner = BufferView<int*>>
 using BidiCommonOuter = BufferView<bidirectional_iterator<Inner*>>;
 static_assert(std::ranges::bidirectional_range<BidiCommonOuter<>>);
 static_assert(std::ranges::common_range<BidiCommonOuter<>>);
-LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<BidiCommonOuter<>>);
+static_assert(simple_view<BidiCommonOuter<>>);
 
 // an iterator where its operator* makes a copy of underlying operator*
 template <class It>
@@ -349,7 +350,7 @@ struct InnerRValue : Outer {
 static_assert(std::ranges::forward_range<InnerRValue<SimpleForwardCommonOuter<>>>);
 static_assert(!std::ranges::bidirectional_range<InnerRValue<SimpleForwardCommonOuter<>>>);
 static_assert(std::ranges::common_range<InnerRValue<SimpleForwardCommonOuter<>>>);
-LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<InnerRValue<SimpleForwardCommonOuter<>>>);
+static_assert(simple_view<InnerRValue<SimpleForwardCommonOuter<>>>);
 static_assert(!std::is_lvalue_reference_v<std::ranges::range_reference_t<InnerRValue<SimpleForwardCommonOuter<>>>>);
 
 struct move_swap_aware_iter {

libcxx/test/std/ranges/range.adaptors/range.lazy.split/begin.pass.cpp

@@ -16,6 +16,7 @@
 #include <cassert>
 #include <utility>
 #include "test_iterators.h"
+#include "test_range.h"
 #include "types.h"
 
 template <class View>
@@ -32,8 +33,8 @@ constexpr bool test() {
 
     static_assert(std::ranges::forward_range<V>);
     static_assert(std::ranges::forward_range<const V>);
-    LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<V>);
-    LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<P>);
+    static_assert(simple_view<V>);
+    static_assert(simple_view<P>);
 
     {
       std::ranges::lazy_split_view<V, P> v;
@@ -58,8 +59,8 @@ constexpr bool test() {
 
     static_assert(std::ranges::forward_range<V>);
     static_assert(std::ranges::forward_range<const V>);
-    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<V>);
-    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<P>);
+    static_assert(!simple_view<V>);
+    static_assert(!simple_view<P>);
 
     {
       std::ranges::lazy_split_view<V, P> v;
@@ -83,8 +84,8 @@ constexpr bool test() {
     using P = V;
     static_assert(std::ranges::forward_range<V>);
     static_assert(!std::ranges::forward_range<const V>);
-    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<V>);
-    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<P>);
+    static_assert(!simple_view<V>);
+    static_assert(!simple_view<P>);
 
     std::ranges::lazy_split_view<V, P> v;
     auto it = v.begin();
@@ -102,8 +103,8 @@ constexpr bool test() {
 
     static_assert(std::ranges::forward_range<V>);
     static_assert(std::ranges::forward_range<const V>);
-    LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<V>);
-    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<P>);
+    static_assert(simple_view<V>);
+    static_assert(!simple_view<P>);
 
     {
       std::ranges::lazy_split_view<V, P> v;

libcxx/test/std/ranges/range.adaptors/range.lazy.split/end.pass.cpp

@@ -16,6 +16,7 @@
 #include <cassert>
 #include <utility>
 #include "test_iterators.h"
+#include "test_range.h"
 #include "types.h"
 
 struct ForwardViewCommonIfConst : std::ranges::view_base {
@@ -59,8 +60,8 @@ constexpr bool test() {
 
     static_assert(std::ranges::forward_range<V>);
     static_assert(std::ranges::common_range<const V>);
-    LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<V>);
-    LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<P>);
+    static_assert(simple_view<V>);
+    static_assert(simple_view<P>);
 
     {
       std::ranges::lazy_split_view<V, P> v;
@@ -85,8 +86,8 @@ constexpr bool test() {
 
     static_assert(std::ranges::forward_range<V>);
     static_assert(std::ranges::common_range<V>);
-    LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<V>);
-    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<P>);
+    static_assert(simple_view<V>);
+    static_assert(!simple_view<P>);
     static_assert(std::ranges::forward_range<const V>);
     static_assert(std::ranges::common_range<const V>);
 

libcxx/test/std/ranges/range.adaptors/range.take.while/types.h

@@ -36,7 +36,7 @@ struct SimpleView : IntBufferViewBase {
   constexpr int* begin() const { return buffer_; }
   constexpr int* end() const { return buffer_ + size_; }
 };
-LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<SimpleView>);
+static_assert(simple_view<SimpleView>);
 
 struct ConstNotRange : IntBufferViewBase {
   using IntBufferViewBase::IntBufferViewBase;
@@ -54,6 +54,6 @@ struct NonSimple : IntBufferViewBase {
   constexpr int* end() { return buffer_ + size_; }
 };
 static_assert(std::ranges::view<NonSimple>);
-LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimple>);
+static_assert(!simple_view<NonSimple>);
 
 #endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_TAKE_WHILE_TYPES_H

libcxx/test/std/ranges/range.adaptors/range.take/begin.pass.cpp

@@ -69,7 +69,7 @@ constexpr bool test() {
     ASSERT_SAME_TYPE(decltype(tv.begin()), std::counted_iterator<int*>);
   }
 
-  // __simple_view<V> && sized_range<V> && !size_range<!V>
+  // simple-view<V> && sized_range<V> && !size_range<!V>
   {
     std::ranges::take_view<NonCommonSimpleView> tv{};
     ASSERT_SAME_TYPE(decltype(tv.begin()), std::counted_iterator<int*>);

libcxx/test/std/ranges/range.adaptors/range.zip/sentinel/ctor.other.pass.cpp

@@ -46,7 +46,7 @@ static_assert(std::ranges::random_access_range<NonSimpleNonCommonConvertibleView
 static_assert(!std::ranges::sized_range<NonSimpleNonCommonConvertibleView>);
 static_assert(std::convertible_to<std::ranges::sentinel_t<NonSimpleNonCommonConvertibleView>,
                                   std::ranges::sentinel_t<NonSimpleNonCommonConvertibleView const>>);
-LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleNonCommonConvertibleView>);
+static_assert(!simple_view<NonSimpleNonCommonConvertibleView>);
 
 constexpr bool test() {
   int buffer1[4] = {1, 2, 3, 4};

libcxx/test/std/ranges/range.adaptors/range.zip/sentinel/eq.pass.cpp

@@ -67,7 +67,7 @@ constexpr bool test() {
     // simple-view: const and non-const have the same iterator/sentinel type
     std::ranges::zip_view v{SimpleNonCommon(buffer1), SimpleNonCommon(buffer2), SimpleNonCommon(buffer3)};
     static_assert(!std::ranges::common_range<decltype(v)>);
-    LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<decltype(v)>);
+    static_assert(simple_view<decltype(v)>);
 
     assert(v.begin() != v.end());
     assert(v.begin() + 1 != v.end());
@@ -80,7 +80,7 @@ constexpr bool test() {
     // !simple-view: const and non-const have different iterator/sentinel types
     std::ranges::zip_view v{NonSimpleNonCommon(buffer1), SimpleNonCommon(buffer2), SimpleNonCommon(buffer3)};
     static_assert(!std::ranges::common_range<decltype(v)>);
-    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<decltype(v)>);
+    static_assert(!simple_view<decltype(v)>);
 
     assert(v.begin() != v.end());
     assert(v.begin() + 4 == v.end());
@@ -105,7 +105,7 @@ constexpr bool test() {
     // underlying const/non-const sentinel can be compared with both const/non-const iterator
     std::ranges::zip_view v{ComparableView(buffer1), ComparableView(buffer2)};
     static_assert(!std::ranges::common_range<decltype(v)>);
-    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<decltype(v)>);
+    static_assert(!simple_view<decltype(v)>);
 
     assert(v.begin() != v.end());
     assert(v.begin() + 4 == v.end());
@@ -130,7 +130,7 @@ constexpr bool test() {
     // underlying const/non-const sentinel cannot be compared with non-const/const iterator
     std::ranges::zip_view v{ComparableView(buffer1), ConstIncompatibleView{}};
     static_assert(!std::ranges::common_range<decltype(v)>);
-    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<decltype(v)>);
+    static_assert(!simple_view<decltype(v)>);
 
     using Iter = std::ranges::iterator_t<decltype(v)>;
     using ConstIter = std::ranges::iterator_t<const decltype(v)>;

libcxx/test/std/ranges/range.adaptors/range.zip/sentinel/minus.pass.cpp

@@ -120,7 +120,7 @@ constexpr bool test() {
     // simple-view
     std::ranges::zip_view v{ForwardSizedNonCommon(buffer1)};
     static_assert(!std::ranges::common_range<decltype(v)>);
-    LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<decltype(v)>);
+    static_assert(simple_view<decltype(v)>);
 
     auto it = v.begin();
     auto st = v.end();
@@ -159,7 +159,7 @@ constexpr bool test() {
     // underlying sentinels cannot subtract underlying const iterators
     std::ranges::zip_view v(NonSimpleForwardSizedNonCommon{buffer1});
     static_assert(!std::ranges::common_range<decltype(v)>);
-    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<decltype(v)>);
+    static_assert(!simple_view<decltype(v)>);
 
     using Iter = std::ranges::iterator_t<decltype(v)>;
     using ConstIter = std::ranges::iterator_t<const decltype(v)>;
@@ -191,7 +191,7 @@ constexpr bool test() {
     // const compatible allow non-const to const conversion
     std::ranges::zip_view v(ConstCompatibleForwardSized{buffer1});
     static_assert(!std::ranges::common_range<decltype(v)>);
-    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<decltype(v)>);
+    static_assert(!simple_view<decltype(v)>);
 
     using Iter = std::ranges::iterator_t<decltype(v)>;
     using ConstIter = std::ranges::iterator_t<const decltype(v)>;