libstdc++: Rename concat_view::iterator to ::_Iterator

Even though 'iterator' is a reserved macro name, we can't use it as the
name of this implementation detail type since it could introduce name
lookup ambiguity in valid code, e.g.

  struct A { using iterator = void; }
  struct B : concat_view<...>, A { using type = iterator; };

libstdc++-v3/ChangeLog:

	* include/std/ranges (concat_view::iterator): Rename to ...
	(concat_view::_Iterator): ... this throughout.

Reviewed-by: Jonathan Wakely <jwakely@redhat.com>

diff --git a/libstdc++-v3/include/std/ranges b/libstdc++-v3/include/std/ranges
index 22e0c9cae4478298241834d6c4971bd12b3bf7b3..6c65722b687e439f2418be2a92562fae78451cbb 100644 (file)
--- a/libstdc++-v3/include/std/ranges
+++ b/libstdc++-v3/include/std/ranges
@@ -9693,7 +9693,7 @@ namespace ranges
   {
     tuple<_Vs...> _M_views;
 
-    template<bool _Const> class iterator;
+    template<bool _Const> class _Iterator;
 
   public:
     constexpr concat_view() = default;
@@ -9703,18 +9703,18 @@ namespace ranges
     : _M_views(std::move(__views)...)
     { }
 
-    constexpr iterator<false>
+    constexpr _Iterator<false>
     begin() requires (!(__detail::__simple_view<_Vs> && ...))
     {
-      iterator<false> __it(this, in_place_index<0>, ranges::begin(std::get<0>(_M_views)));
+      _Iterator<false> __it(this, in_place_index<0>, ranges::begin(std::get<0>(_M_views)));
       __it.template _M_satisfy<0>();
       return __it;
     }
 
-    constexpr iterator<true>
+    constexpr _Iterator<true>
     begin() const requires (range<const _Vs> && ...) && __detail::__concatable<const _Vs...>
     {
-      iterator<true> __it(this, in_place_index<0>, ranges::begin(std::get<0>(_M_views)));
+      _Iterator<true> __it(this, in_place_index<0>, ranges::begin(std::get<0>(_M_views)));
       __it.template _M_satisfy<0>();
       return __it;
     }
@@ -9725,8 +9725,8 @@ namespace ranges
       constexpr auto __n = sizeof...(_Vs);
       if constexpr ((semiregular<iterator_t<_Vs>> && ...)
                    && common_range<_Vs...[__n - 1]>)
-       return iterator<false>(this, in_place_index<__n - 1>,
-                              ranges::end(std::get<__n - 1>(_M_views)));
+       return _Iterator<false>(this, in_place_index<__n - 1>,
+                               ranges::end(std::get<__n - 1>(_M_views)));
       else
        return default_sentinel;
     }
@@ -9737,8 +9737,8 @@ namespace ranges
       constexpr auto __n = sizeof...(_Vs);
       if constexpr ((semiregular<iterator_t<const _Vs>> && ...)
                    && common_range<const _Vs...[__n - 1]>)
-       return iterator<true>(this, in_place_index<__n - 1>,
-                             ranges::end(std::get<__n - 1>(_M_views)));
+       return _Iterator<true>(this, in_place_index<__n - 1>,
+                              ranges::end(std::get<__n - 1>(_M_views)));
       else
        return default_sentinel;
     }
@@ -9801,7 +9801,7 @@ namespace ranges
   template<input_range... _Vs>
     requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0) && __detail::__concatable<_Vs...>
   template<bool _Const>
-  class concat_view<_Vs...>::iterator
+  class concat_view<_Vs...>::_Iterator
   : public __detail::__concat_view_iter_cat<_Const, _Vs...>
   {
     static auto
@@ -9818,7 +9818,7 @@ namespace ranges
     }
 
     friend concat_view;
-    friend iterator<!_Const>;
+    friend _Iterator<!_Const>;
 
   public:
     // iterator_category defined in __concat_view_iter_cat
@@ -9929,16 +9929,16 @@ namespace ranges
 
     template<typename... _Args>
       explicit constexpr
-      iterator(__maybe_const_t<_Const, concat_view>* __parent, _Args&&... __args)
+      _Iterator(__maybe_const_t<_Const, concat_view>* __parent, _Args&&... __args)
        requires constructible_from<__base_iter, _Args&&...>
       : _M_parent(__parent), _M_it(std::forward<_Args>(__args)...)
       { }
 
   public:
-    iterator() = default;
+    _Iterator() = default;
 
     constexpr
-    iterator(iterator<!_Const> __it)
+    _Iterator(_Iterator<!_Const> __it)
       requires _Const && (convertible_to<iterator_t<_Vs>, iterator_t<const _Vs>> && ...)
     : _M_parent(__it._M_parent)
     {
@@ -9955,7 +9955,7 @@ namespace ranges
       return std::visit([](auto&& __it) -> reference { return *__it; }, _M_it);
     }
 
-    constexpr iterator&
+    constexpr _Iterator&
     operator++()
     {
       _M_invoke_with_runtime_index([this]<size_t _Idx>() {
@@ -9969,7 +9969,7 @@ namespace ranges
     operator++(int)
     { ++*this; }
 
-    constexpr iterator
+    constexpr _Iterator
     operator++(int)
       requires __detail::__all_forward<_Const, _Vs...>
     {
@@ -9978,7 +9978,7 @@ namespace ranges
       return __tmp;
     }
 
-    constexpr iterator&
+    constexpr _Iterator&
     operator--()
       requires __detail::__concat_is_bidirectional<_Const, _Vs...>
     {
@@ -9989,7 +9989,7 @@ namespace ranges
       return *this;
     }
 
-    constexpr iterator
+    constexpr _Iterator
     operator--(int)
       requires __detail::__concat_is_bidirectional<_Const, _Vs...>
     {
@@ -9998,7 +9998,7 @@ namespace ranges
       return __tmp;
     }
 
-    constexpr iterator&
+    constexpr _Iterator&
     operator+=(difference_type __n)
       requires __detail::__concat_is_random_access<_Const, _Vs...>
     {
@@ -10013,7 +10013,7 @@ namespace ranges
       return *this;
     }
 
-    constexpr iterator&
+    constexpr _Iterator&
     operator-=(difference_type __n)
       requires __detail::__concat_is_random_access<_Const, _Vs...>
     {
@@ -10027,7 +10027,7 @@ namespace ranges
     { return *((*this) + __n); }
 
     friend constexpr bool
-    operator==(const iterator& __x, const iterator& __y)
+    operator==(const _Iterator& __x, const _Iterator& __y)
       requires (equality_comparable<iterator_t<__maybe_const_t<_Const, _Vs>>> && ...)
     {
       __glibcxx_assert(!__x._M_it.valueless_by_exception());
@@ -10036,7 +10036,7 @@ namespace ranges
     }
 
     friend constexpr bool
-    operator==(const iterator& __it, default_sentinel_t)
+    operator==(const _Iterator& __it, default_sentinel_t)
     {
       __glibcxx_assert(!__it._M_it.valueless_by_exception());
       constexpr auto __last_idx = sizeof...(_Vs) - 1;
@@ -10046,48 +10046,48 @@ namespace ranges
     }
 
     friend constexpr bool
-    operator<(const iterator& __x, const iterator& __y)
+    operator<(const _Iterator& __x, const _Iterator& __y)
       requires __detail::__all_random_access<_Const, _Vs...>
     { return __x._M_it < __y._M_it; }
 
     friend constexpr bool
-    operator>(const iterator& __x, const iterator& __y)
+    operator>(const _Iterator& __x, const _Iterator& __y)
       requires __detail::__all_random_access<_Const, _Vs...>
     { return __x._M_it > __y._M_it; }
 
     friend constexpr bool
-    operator<=(const iterator& __x, const iterator& __y)
+    operator<=(const _Iterator& __x, const _Iterator& __y)
       requires __detail::__all_random_access<_Const, _Vs...>
     { return __x._M_it <= __y._M_it; }
 
     friend constexpr bool
-    operator>=(const iterator& __x, const iterator& __y)
+    operator>=(const _Iterator& __x, const _Iterator& __y)
       requires __detail::__all_random_access<_Const, _Vs...>
     { return __x._M_it >= __y._M_it; }
 
     friend constexpr auto
-    operator<=>(const iterator& __x, const iterator& __y)
+    operator<=>(const _Iterator& __x, const _Iterator& __y)
       requires __detail::__all_random_access<_Const, _Vs...>
        && (three_way_comparable<iterator_t<__maybe_const_t<_Const, _Vs>>> && ...)
     { return __x._M_it <=> __y._M_it; }
 
-    friend constexpr iterator
-    operator+(const iterator& __it, difference_type __n)
+    friend constexpr _Iterator
+    operator+(const _Iterator& __it, difference_type __n)
       requires __detail::__concat_is_random_access<_Const, _Vs...>
     { return auto(__it) += __n; }
 
-    friend constexpr iterator
-    operator+(difference_type __n, const iterator& __it)
+    friend constexpr _Iterator
+    operator+(difference_type __n, const _Iterator& __it)
       requires __detail::__concat_is_random_access<_Const, _Vs...>
     { return __it + __n; }
 
-    friend constexpr iterator
-    operator-(const iterator& __it, difference_type __n)
+    friend constexpr _Iterator
+    operator-(const _Iterator& __it, difference_type __n)
       requires __detail::__concat_is_random_access<_Const, _Vs...>
     { return auto(__it) -= __n; }
 
     friend constexpr difference_type
-    operator-(const iterator& __x, const iterator& __y)
+    operator-(const _Iterator& __x, const _Iterator& __y)
       requires __detail::__concat_is_random_access<_Const, _Vs...>
     {
       return _S_invoke_with_runtime_index([&]<size_t _Ix>() -> difference_type {
@@ -10119,7 +10119,7 @@ namespace ranges
     }
 
     friend constexpr difference_type
-    operator-(const iterator& __x, default_sentinel_t)
+    operator-(const _Iterator& __x, default_sentinel_t)
       requires (sized_sentinel_for<sentinel_t<__maybe_const_t<_Const, _Vs>>,
                                   iterator_t<__maybe_const_t<_Const, _Vs>>> && ...)
        && __detail::__all_but_first_sized<__maybe_const_t<_Const, _Vs>...>::value
@@ -10140,14 +10140,14 @@ namespace ranges
     }
 
     friend constexpr difference_type
-    operator-(default_sentinel_t, const iterator& __x)
+    operator-(default_sentinel_t, const _Iterator& __x)
       requires (sized_sentinel_for<sentinel_t<__maybe_const_t<_Const, _Vs>>,
                                   iterator_t<__maybe_const_t<_Const, _Vs>>> && ...)
        && __detail::__all_but_first_sized<__maybe_const_t<_Const, _Vs>...>::value
     { return -(__x - default_sentinel); }
 
     friend constexpr decltype(auto)
-    iter_move(const iterator& __it)
+    iter_move(const _Iterator& __it)
     {
       using _Res = __detail::__concat_rvalue_reference_t<__maybe_const_t<_Const, _Vs>...>;
       return std::visit([](const auto& __i) -> _Res {
@@ -10156,8 +10156,8 @@ namespace ranges
     }
 
     friend constexpr void
-    iter_swap(const iterator& __x, const iterator& __y)
-      requires swappable_with<iter_reference_t<iterator>, iter_reference_t<iterator>>
+    iter_swap(const _Iterator& __x, const _Iterator& __y)
+      requires swappable_with<iter_reference_t<_Iterator>, iter_reference_t<_Iterator>>
        && (... && indirectly_swappable<iterator_t<__maybe_const_t<_Const, _Vs>>>)
     {
       std::visit([&]<typename _Tp, typename _Up>(const _Tp& __it1, const _Up& __it2) {