[libc++] Move iota_view::iterator and sentinel out of iota_view

[philnik]

Summary

This makes it a lot easier to specialize traits types for it, like __segmented_iterator_traits.

[philnik]

Try to fix CI

[philnik]

Try to fix CI

libcxx/include/__ranges/iota_view.h

requires(_Iter __i, const _Iter __j, const _IotaDiffT<_Iter> __n) {
       { __i += __n } -> same_as<_Iter&>;
       { __i -= __n } -> same_as<_Iter&>;
       _Iter(__j + __n);
       _Iter(__n + __j);
       _Iter(__j - __n);
       { __j - __j } -> convertible_to<_IotaDiffT<_Iter>>;
     };
 
+  template <weakly_incrementable _Start>
+    requires copyable<_Start>
+  struct __iota_view_iterator;
+
+  template <weakly_incrementable _Start, semiregular _BoundSentinel>
+    requires __weakly_equality_comparable_with<_Start, _BoundSentinel> && copyable<_Start>
+  struct __iota_view_sentinel;
+
   template<class>
   struct __iota_iterator_category {};
 
   template<incrementable _Tp>
   struct __iota_iterator_category<_Tp> {
     using iterator_category = input_iterator_tag;
   };
 
   template <weakly_incrementable _Start, semiregular _BoundSentinel = unreachable_sentinel_t>
     requires __weakly_equality_comparable_with<_Start, _BoundSentinel> && copyable<_Start>
   class iota_view : public view_interface<iota_view<_Start, _BoundSentinel>> {
-    struct __iterator : public __iota_iterator_category<_Start> {
-      friend class iota_view;
+
+    using __iterator = __iota_view_iterator<_Start>;
+    using __sentinel = __iota_view_sentinel<_Start, _BoundSentinel>;
+
+    _Start __value_ = _Start();
+    _BoundSentinel __bound_sentinel_ = _BoundSentinel();
+
+  public:
+    _LIBCPP_HIDE_FROM_ABI
+    iota_view() requires default_initializable<_Start> = default;
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr explicit iota_view(_Start __value) : __value_(std::move(__value)) { }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr iota_view(type_identity_t<_Start> __value, type_identity_t<_BoundSentinel> __bound_sentinel)
+        : __value_(std::move(__value)), __bound_sentinel_(std::move(__bound_sentinel)) {
+      // Validate the precondition if possible.
+      if constexpr (totally_ordered_with<_Start, _BoundSentinel>) {
+        _LIBCPP_ASSERT(ranges::less_equal()(__value_, __bound_sentinel_),
+                       "Precondition violated: value is greater than bound.");
+      }
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr iota_view(__iterator __first, __iterator __last)
+      requires same_as<_Start, _BoundSentinel>
+    : iota_view(std::move(__first.__value_), std::move(__last.__value_)) {}
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr iota_view(__iterator __first, _BoundSentinel __last)
+      requires same_as<_BoundSentinel, unreachable_sentinel_t>
+    : iota_view(std::move(__first.__value_), std::move(__last)) {}
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr iota_view(__iterator __first, __sentinel __last)
+      requires(!same_as<_Start, _BoundSentinel> && !same_as<_Start, unreachable_sentinel_t>)
+    : iota_view(std::move(__first.__value_), std::move(__last.__bound_sentinel_)) {}
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __iterator begin() const { return __iterator{__value_}; }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto end() const {
+      if constexpr (same_as<_BoundSentinel, unreachable_sentinel_t>)
+        return unreachable_sentinel;
+      else
+        return __sentinel{__bound_sentinel_};
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __iterator end() const
+      requires same_as<_Start, _BoundSentinel>
+    {
+      return __iterator{__bound_sentinel_};
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto size() const
+      requires(same_as<_Start, _BoundSentinel> && __advanceable<_Start>) ||
+              (integral<_Start> && integral<_BoundSentinel>) || sized_sentinel_for<_BoundSentinel, _Start>
+    {
+      if constexpr (__integer_like<_Start> && __integer_like<_BoundSentinel>) {
+        if (__value_ < 0) {
+          if (__bound_sentinel_ < 0) {
+            return std::__to_unsigned_like(-__value_) - std::__to_unsigned_like(-__bound_sentinel_);
+          }
+          return std::__to_unsigned_like(__bound_sentinel_) + std::__to_unsigned_like(-__value_);
+        }
+        return std::__to_unsigned_like(__bound_sentinel_) - std::__to_unsigned_like(__value_);
+      }
+      return std::__to_unsigned_like(__bound_sentinel_ - __value_);
+    }
+  };
+
+  template <class _Start, class _BoundSentinel>
+    requires(!__integer_like<_Start> || !__integer_like<_BoundSentinel> ||
+             (__signed_integer_like<_Start> == __signed_integer_like<_BoundSentinel>))
+  iota_view(_Start, _BoundSentinel) -> iota_view<_Start, _BoundSentinel>;
+
+  template <class _Start, class _BoundSentinel>
+  inline constexpr bool enable_borrowed_range<iota_view<_Start, _BoundSentinel>> = true;
+
+  template <weakly_incrementable _Start>
+    requires copyable<_Start>
+  struct __iota_view_iterator : public __iota_iterator_category<_Start> {
+
+    template <weakly_incrementable _StartT, semiregular _BoundSentinelT>
+      requires __weakly_equality_comparable_with<_StartT, _BoundSentinelT> && copyable<_StartT>
 
-      using iterator_concept =
-        _If<__advanceable<_Start>,   random_access_iterator_tag,
-        _If<__decrementable<_Start>, bidirectional_iterator_tag,
-        _If<incrementable<_Start>,   forward_iterator_tag,
-        /*Else*/                     input_iterator_tag>>>;
 
-      using value_type = _Start;
-      using difference_type = _IotaDiffT<_Start>;
 
-      _Start __value_ = _Start();
 
-      _LIBCPP_HIDE_FROM_ABI
-      __iterator() requires default_initializable<_Start> = default;
+    __iota_view_iterator() requires default_initializable<_Start> = default;
 
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr explicit __iterator(_Start __value) : __value_(std::move(__value)) {}
+    constexpr explicit __iota_view_iterator(_Start __value) : __value_(std::move(__value)) {}
 
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr _Start operator*() const noexcept(is_nothrow_copy_constructible_v<_Start>) {
-        return __value_;
-      }
 
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr __iterator& operator++() {
-        ++__value_;
-        return *this;
-      }
+    constexpr __iota_view_iterator& operator++() {
 
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr void operator++(int) { ++*this; }
 
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr __iterator operator++(int) requires incrementable<_Start> {
-        auto __tmp = *this;
-        ++*this;
-        return __tmp;
-      }
+    constexpr __iota_view_iterator operator++(int) requires incrementable<_Start> {
 
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr __iterator& operator--() requires __decrementable<_Start> {
-        --__value_;
-        return *this;
-      }
+    constexpr __iota_view_iterator& operator--() requires __decrementable<_Start> {
 
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr __iterator  operator--(int) requires __decrementable<_Start> {
-        auto __tmp = *this;
-        --*this;
-        return __tmp;
-      }
+    constexpr __iota_view_iterator  operator--(int) requires __decrementable<_Start> {
 
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr __iterator& operator+=(difference_type __n)
-        requires __advanceable<_Start>
-      {
-        if constexpr (__integer_like<_Start> && !__signed_integer_like<_Start>) {
-          if (__n >= difference_type(0)) {
-            __value_ += static_cast<_Start>(__n);
-          } else {
-            __value_ -= static_cast<_Start>(-__n);
-          }
-        } else {
-          __value_ += __n;
-        }
-        return *this;
-      }
+    constexpr __iota_view_iterator& operator+=(difference_type __n)
 
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr __iterator& operator-=(difference_type __n)
-        requires __advanceable<_Start>
-      {
-        if constexpr (__integer_like<_Start> && !__signed_integer_like<_Start>) {
-          if (__n >= difference_type(0)) {
-            __value_ -= static_cast<_Start>(__n);
-          } else {
-            __value_ += static_cast<_Start>(-__n);
-          }
-        } else {
-          __value_ -= __n;
-        }
-        return *this;
-      }
+    constexpr __iota_view_iterator& operator-=(difference_type __n)
 
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr _Start operator[](difference_type __n) const
-        requires __advanceable<_Start>
-      {
-        return _Start(__value_ + __n);
-      }
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
-        requires equality_comparable<_Start>
-      {
-        return __x.__value_ == __y.__value_;
-      }
+    friend constexpr bool operator==(const __iota_view_iterator& __x, const __iota_view_iterator& __y)
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr bool operator<(const __iterator& __x, const __iterator& __y)
-        requires totally_ordered<_Start>
-      {
-        return __x.__value_ < __y.__value_;
-      }
+    friend constexpr bool operator<(const __iota_view_iterator& __x, const __iota_view_iterator& __y)
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr bool operator>(const __iterator& __x, const __iterator& __y)
-        requires totally_ordered<_Start>
-      {
-        return __y < __x;
-      }
+    friend constexpr bool operator>(const __iota_view_iterator& __x, const __iota_view_iterator& __y)
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y)
-        requires totally_ordered<_Start>
-      {
-        return !(__y < __x);
-      }
+    friend constexpr bool operator<=(const __iota_view_iterator& __x, const __iota_view_iterator& __y)
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y)
-        requires totally_ordered<_Start>
-      {
-        return !(__x < __y);
-      }
+    friend constexpr bool operator>=(const __iota_view_iterator& __x, const __iota_view_iterator& __y)
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
-        requires totally_ordered<_Start> && three_way_comparable<_Start>
-      {
-        return __x.__value_ <=> __y.__value_;
-      }
+    friend constexpr auto operator<=>(const __iota_view_iterator& __x, const __iota_view_iterator& __y)
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr __iterator operator+(__iterator __i, difference_type __n)
-        requires __advanceable<_Start>
-      {
-        __i += __n;
-        return __i;
-      }
+    friend constexpr __iota_view_iterator operator+(__iota_view_iterator __i, difference_type __n)
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr __iterator operator+(difference_type __n, __iterator __i)
-        requires __advanceable<_Start>
-      {
-        return __i + __n;
-      }
+    friend constexpr __iota_view_iterator operator+(difference_type __n, __iota_view_iterator __i)
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr __iterator operator-(__iterator __i, difference_type __n)
-        requires __advanceable<_Start>
-      {
-        __i -= __n;
-        return __i;
-      }
+    friend constexpr __iota_view_iterator operator-(__iota_view_iterator __i, difference_type __n)
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
-        requires __advanceable<_Start>
-      {
-        if constexpr (__integer_like<_Start>) {
-          if constexpr (__signed_integer_like<_Start>) {
-            return difference_type(difference_type(__x.__value_) - difference_type(__y.__value_));
-          }
-          if (__y.__value_ > __x.__value_) {
-            return difference_type(-difference_type(__y.__value_ - __x.__value_));
-          }
-          return difference_type(__x.__value_ - __y.__value_);
-        }
-        return __x.__value_ - __y.__value_;
-      }
-    };
+    friend constexpr difference_type operator-(const __iota_view_iterator& __x, const __iota_view_iterator& __y)
 
-    struct __sentinel {
-      friend class iota_view;
+  template <weakly_incrementable _Start, semiregular _BoundSentinel>
+    requires __weakly_equality_comparable_with<_Start, _BoundSentinel> && copyable<_Start>
+  struct __iota_view_sentinel {
+
+    template <weakly_incrementable _StartT, semiregular _BoundSentinelT>
+      requires __weakly_equality_comparable_with<_StartT, _BoundSentinelT> && copyable<_StartT>
 
-    private:
-      _BoundSentinel __bound_sentinel_ = _BoundSentinel();
+    using __iterator = __iota_view_iterator<_Start>;
+
 
-    public:
-      _LIBCPP_HIDE_FROM_ABI
-      __sentinel() = default;
-      constexpr explicit __sentinel(_BoundSentinel __bound_sentinel) : __bound_sentinel_(std::move(__bound_sentinel)) {}
+    __iota_view_sentinel() = default;
+    constexpr explicit __iota_view_sentinel(_BoundSentinel __bound_sentinel) : __bound_sentinel_(std::move(__bound_sentinel)) {}
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr bool operator==(const __iterator& __x, const __sentinel& __y) {
-        return __x.__value_ == __y.__bound_sentinel_;
-      }
+    friend constexpr bool operator==(const __iterator& __x, const __iota_view_sentinel& __y) {
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr iter_difference_t<_Start> operator-(const __iterator& __x, const __sentinel& __y)
-        requires sized_sentinel_for<_BoundSentinel, _Start>
-      {
-        return __x.__value_ - __y.__bound_sentinel_;
-      }
+    friend constexpr iter_difference_t<_Start> operator-(const __iterator& __x, const __iota_view_sentinel& __y)
 
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr iter_difference_t<_Start> operator-(const __sentinel& __x, const __iterator& __y)
-        requires sized_sentinel_for<_BoundSentinel, _Start>
-      {
-        return -(__y - __x);
-      }
-    };
+    friend constexpr iter_difference_t<_Start> operator-(const __iota_view_sentinel& __x, const __iterator& __y)
 
-    _Start __value_ = _Start();
-    _BoundSentinel __bound_sentinel_ = _BoundSentinel();
-
-  public:
-    _LIBCPP_HIDE_FROM_ABI
-    iota_view() requires default_initializable<_Start> = default;
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit iota_view(_Start __value) : __value_(std::move(__value)) { }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr iota_view(type_identity_t<_Start> __value, type_identity_t<_BoundSentinel> __bound_sentinel)
-        : __value_(std::move(__value)), __bound_sentinel_(std::move(__bound_sentinel)) {
-      // Validate the precondition if possible.
-      if constexpr (totally_ordered_with<_Start, _BoundSentinel>) {
-        _LIBCPP_ASSERT(ranges::less_equal()(__value_, __bound_sentinel_),
-                       "Precondition violated: value is greater than bound.");
-      }
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr iota_view(__iterator __first, __iterator __last)
-      requires same_as<_Start, _BoundSentinel>
-    : iota_view(std::move(__first.__value_), std::move(__last.__value_)) {}
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr iota_view(__iterator __first, _BoundSentinel __last)
-      requires same_as<_BoundSentinel, unreachable_sentinel_t>
-    : iota_view(std::move(__first.__value_), std::move(__last)) {}
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr iota_view(__iterator __first, __sentinel __last)
-      requires(!same_as<_Start, _BoundSentinel> && !same_as<_Start, unreachable_sentinel_t>)
-    : iota_view(std::move(__first.__value_), std::move(__last.__bound_sentinel_)) {}
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator begin() const { return __iterator{__value_}; }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto end() const {
-      if constexpr (same_as<_BoundSentinel, unreachable_sentinel_t>)
-        return unreachable_sentinel;
-      else
-        return __sentinel{__bound_sentinel_};
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator end() const
-      requires same_as<_Start, _BoundSentinel>
-    {
-      return __iterator{__bound_sentinel_};
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto size() const
-      requires(same_as<_Start, _BoundSentinel> && __advanceable<_Start>) ||
-              (integral<_Start> && integral<_BoundSentinel>) || sized_sentinel_for<_BoundSentinel, _Start>
-    {
-      if constexpr (__integer_like<_Start> && __integer_like<_BoundSentinel>) {
-        if (__value_ < 0) {
-          if (__bound_sentinel_ < 0) {
-            return std::__to_unsigned_like(-__value_) - std::__to_unsigned_like(-__bound_sentinel_);
-          }
-          return std::__to_unsigned_like(__bound_sentinel_) + std::__to_unsigned_like(-__value_);
-        }
-        return std::__to_unsigned_like(__bound_sentinel_) - std::__to_unsigned_like(__value_);
-      }
-      return std::__to_unsigned_like(__bound_sentinel_ - __value_);
-    }
-  };
-
-  template <class _Start, class _BoundSentinel>
-    requires(!__integer_like<_Start> || !__integer_like<_BoundSentinel> ||
-             (__signed_integer_like<_Start> == __signed_integer_like<_BoundSentinel>))
-  iota_view(_Start, _BoundSentinel) -> iota_view<_Start, _BoundSentinel>;
-
-  template <class _Start, class _BoundSentinel>
-  inline constexpr bool enable_borrowed_range<iota_view<_Start, _BoundSentinel>> = true;
-
  namespace views {
  namespace __iota {
   struct __fn {
     template<class _Start>
     _LIBCPP_HIDE_FROM_ABI
     constexpr auto operator()(_Start&& __start) const
       noexcept(noexcept(ranges::iota_view(std::forward<_Start>(__start))))
       -> decltype(      ranges::iota_view(std::forward<_Start>(__start)))

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

 
 #include "../types.h"
 
 struct NotNoexceptCopy {
   using difference_type = int;
 
   int value_;
   constexpr explicit NotNoexceptCopy(int value = 0) : value_(value) {}
-  NotNoexceptCopy(const NotNoexceptCopy&) noexcept(false) = default;
+  constexpr NotNoexceptCopy(const NotNoexceptCopy& other) noexcept(false) : value_(other.value_) {}
 
   bool operator==(const NotNoexceptCopy&) const = default;
 
   friend constexpr NotNoexceptCopy& operator+=(NotNoexceptCopy &lhs, const NotNoexceptCopy& rhs) {
     lhs.value_ += rhs.value_; return lhs;
   }
   friend constexpr NotNoexceptCopy& operator-=(NotNoexceptCopy &lhs, const NotNoexceptCopy& rhs) {
     lhs.value_ -= rhs.value_; return lhs;