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

[philnik]

Try to fix Ci

[ldionne]

Can you add a comment to the commit message explaining why you're doing that. I remember we talked about it during a review at some point but leaving breadcrumbs would be nice.

Also CC @var-const in case you want to do a few of them.

[philnik]

In D139273#3981777, @ldionne wrote:

Can you add a comment to the commit message explaining why you're doing that. I remember we talked about it during a review at some point but leaving breadcrumbs would be nice.

Also CC @var-const in case you want to do a few of them.

Sorry, I forgot to update the commit message. In case anybody finds this patch in the future, D138413#inline-1335968 contains the reason for this change. Basically, you can't easily specialize traits classes with dependent types.

libcxx/include/__ranges/filter_view.h

 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
 namespace ranges {
+
+  template <input_range _View, indirect_unary_predicate<iterator_t<_View>> _Pred>
+    requires view<_View> && is_object_v<_Pred>
+  class __filter_view_iterator;
+
+  template <input_range _View, indirect_unary_predicate<iterator_t<_View>> _Pred>
+    requires view<_View> && is_object_v<_Pred>
+  class __filter_view_sentinel;
+
   template<input_range _View, indirect_unary_predicate<iterator_t<_View>> _Pred>
     requires view<_View> && is_object_v<_Pred>
   class filter_view : public view_interface<filter_view<_View, _Pred>> {
     _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
     _LIBCPP_NO_UNIQUE_ADDRESS __copyable_box<_Pred> __pred_;
 
     // We cache the result of begin() to allow providing an amortized O(1) begin() whenever
     // the underlying range is at least a forward_range.
     static constexpr bool _UseCache = forward_range<_View>;
     using _Cache = _If<_UseCache, __non_propagating_cache<iterator_t<_View>>, __empty_cache>;
     _LIBCPP_NO_UNIQUE_ADDRESS _Cache __cached_begin_ = _Cache();
 
-    class __iterator;
-    class __sentinel;
+    using __iterator = __filter_view_iterator<_View, _Pred>;
+    using __sentinel = __filter_view_sentinel<_View, _Pred>;
+
+    friend __iterator;
+    friend __sentinel;
 
   public:
     _LIBCPP_HIDE_FROM_ABI
     filter_view() requires default_initializable<_View> && default_initializable<_Pred> = default;
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr filter_view(_View __base, _Pred __pred)
       : __base_(std::move(__base)), __pred_(in_place, std::move(__pred))
using iterator_category =
       _If<derived_from<_Cat, bidirectional_iterator_tag>, bidirectional_iterator_tag,
       _If<derived_from<_Cat, forward_iterator_tag>,       forward_iterator_tag,
       /* else */                                          _Cat
     >>;
   };
 
   template<input_range _View, indirect_unary_predicate<iterator_t<_View>> _Pred>
     requires view<_View> && is_object_v<_Pred>
-  class filter_view<_View, _Pred>::__iterator : public __filter_iterator_category<_View> {
+  class __filter_view_iterator : public __filter_iterator_category<_View> {
+
+    using __filter_view = filter_view<_View, _Pred>;
+
   public:
     _LIBCPP_NO_UNIQUE_ADDRESS iterator_t<_View> __current_ = iterator_t<_View>();
-    _LIBCPP_NO_UNIQUE_ADDRESS filter_view* __parent_ = nullptr;
+    _LIBCPP_NO_UNIQUE_ADDRESS __filter_view* __parent_ = nullptr;
 
     using iterator_concept =
       _If<bidirectional_range<_View>, bidirectional_iterator_tag,
       _If<forward_range<_View>,       forward_iterator_tag,
       /* else */                      input_iterator_tag
     >>;
     // using iterator_category = inherited;
     using value_type = range_value_t<_View>;
     using difference_type = range_difference_t<_View>;
 
     _LIBCPP_HIDE_FROM_ABI
-    __iterator() requires default_initializable<iterator_t<_View>> = default;
+    __filter_view_iterator() requires default_initializable<iterator_t<_View>> = default;
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator(filter_view& __parent, iterator_t<_View> __current)
+    constexpr __filter_view_iterator(__filter_view& __parent, iterator_t<_View> __current)
       : __current_(std::move(__current)), __parent_(std::addressof(__parent))
     { }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr iterator_t<_View> const& base() const& noexcept { return __current_; }
     _LIBCPP_HIDE_FROM_ABI
     constexpr iterator_t<_View> base() && { return std::move(__current_); }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr range_reference_t<_View> operator*() const { return *__current_; }
     _LIBCPP_HIDE_FROM_ABI
     constexpr iterator_t<_View> operator->() const
       requires __has_arrow<iterator_t<_View>> && copyable<iterator_t<_View>>
     {
       return __current_;
     }
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator& operator++() {
+    constexpr __filter_view_iterator& operator++() {
       __current_ = ranges::find_if(std::move(++__current_), ranges::end(__parent_->__base_),
                                    std::ref(*__parent_->__pred_));
       return *this;
     }
     _LIBCPP_HIDE_FROM_ABI
     constexpr void operator++(int) { ++*this; }
     _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator operator++(int) requires forward_range<_View> {
+    constexpr __filter_view_iterator operator++(int) requires forward_range<_View> {
       auto __tmp = *this;
       ++*this;
       return __tmp;
     }
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator& operator--() requires bidirectional_range<_View> {
+    constexpr __filter_view_iterator& operator--() requires bidirectional_range<_View> {
       do {
         --__current_;
       } while (!std::invoke(*__parent_->__pred_, *__current_));
       return *this;
     }
     _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator operator--(int) requires bidirectional_range<_View> {
+    constexpr __filter_view_iterator operator--(int) requires bidirectional_range<_View> {
       auto tmp = *this;
       --*this;
       return tmp;
     }
 
     _LIBCPP_HIDE_FROM_ABI
-    friend constexpr bool operator==(__iterator const& __x, __iterator const& __y)
+    friend constexpr bool operator==(__filter_view_iterator const& __x, __filter_view_iterator const& __y)
       requires equality_comparable<iterator_t<_View>>
     {
       return __x.__current_ == __y.__current_;
     }
 
     _LIBCPP_HIDE_FROM_ABI
-    friend constexpr range_rvalue_reference_t<_View> iter_move(__iterator const& __it)
+    friend constexpr range_rvalue_reference_t<_View> iter_move(__filter_view_iterator const& __it)
       noexcept(noexcept(ranges::iter_move(__it.__current_)))
     {
       return ranges::iter_move(__it.__current_);
     }
 
     _LIBCPP_HIDE_FROM_ABI
-    friend constexpr void iter_swap(__iterator const& __x, __iterator const& __y)
+    friend constexpr void iter_swap(__filter_view_iterator const& __x, __filter_view_iterator const& __y)
       noexcept(noexcept(ranges::iter_swap(__x.__current_, __y.__current_)))
       requires indirectly_swappable<iterator_t<_View>>
     {
       return ranges::iter_swap(__x.__current_, __y.__current_);
     }
   };
 
   template<input_range _View, indirect_unary_predicate<iterator_t<_View>> _Pred>
     requires view<_View> && is_object_v<_Pred>
-  class filter_view<_View, _Pred>::__sentinel {
+  class __filter_view_sentinel {
+    using __filter_view = filter_view<_View, _Pred>;
+
   public:
     sentinel_t<_View> __end_ = sentinel_t<_View>();
 
     _LIBCPP_HIDE_FROM_ABI
-    __sentinel() = default;
+    __filter_view_sentinel() = default;
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit __sentinel(filter_view& __parent)
+    constexpr explicit __filter_view_sentinel(__filter_view& __parent)
       : __end_(ranges::end(__parent.__base_))
     { }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr sentinel_t<_View> base() const { return __end_; }
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr bool operator==(__iterator const& __x, __sentinel const& __y) {
+    _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+    operator==(__filter_view_iterator<_View, _Pred> const& __x, __filter_view_sentinel const& __y) {
       return __x.__current_ == __y.__end_;
     }
   };
 
 namespace views {
 namespace __filter {
   struct __fn {
     template<class _Range, class _Pred>