[libc++] Fix signatures of counted_iterator::base(), transform_view::iterator::base().

[• Quuxplusone]

Summary

Drive-by stop calling .base() on test iterators in the test, and improve the transform_view::iterator/sentinel tests.

[ldionne]

LGTM, but I think we suffer from the same problem in other iterators, for example transform_view::iterator but probably others too. Any appetite for fixing all of them in this PR?

[• Quuxplusone]

Turns out that transform_view::iterator is the only other one, that we've already implemented, that doesn't require major other changes for C++20.

move_iterator and reverse_iterator are also affected but require major changes for C++20 that we haven't implemented yet.
filter_view::iterator is affected but we haven't implemented it yet.
lazy_split_view::iterator is affected but we haven't implemented it yet.
elements_view::iterator is affected but we haven't implemented it yet.

[• Quuxplusone]

Fix a test failure, and improve the transform_view::{iterator/sentinel} tests.

[• Quuxplusone]

Rebase to poke CI.

[• Quuxplusone]

Turns out this is LWG3533; so now we can mark that issue Complete.
CI is still green.

[Mordante]

In D117329#3263611, @Quuxplusone wrote:

Turns out this is LWG3533; so now we can mark that issue Complete.

Please add this to the commit message and mention [range.elements.iterator] has been omitted since we haven't implemented that yet.
(I expect the person implementing that to use the current wording in the Standard.)

LTGM!

libcxx/include/__iterator/counted_iterator.h

public:
   _LIBCPP_HIDE_FROM_ABI
   constexpr counted_iterator& operator=(const counted_iterator<_I2>& __other) {
     __current_ = __other.__current_;
     __count_ = __other.__count_;
     return *this;
   }
 
   _LIBCPP_HIDE_FROM_ABI
-  constexpr const _Iter& base() const& { return __current_; }
+  constexpr const _Iter& base() const& noexcept { return __current_; }
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr _Iter base() && { return _VSTD::move(__current_); }
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr iter_difference_t<_Iter> count() const noexcept { return __count_; }
 
   _LIBCPP_HIDE_FROM_ABI

libcxx/include/__ranges/transform_view.h

public:
   // `__iterator<false>` is ill-formed when `_Const` is false
   // (see http://wg21.link/class.copy.ctor#5).
   _LIBCPP_HIDE_FROM_ABI
   constexpr __iterator(__iterator<!_Const> __i)
     requires _Const && convertible_to<iterator_t<_View>, iterator_t<_Base>>
     : __parent_(__i.__parent_), __current_(_VSTD::move(__i.__current_)) {}
 
   _LIBCPP_HIDE_FROM_ABI
-  constexpr iterator_t<_Base> base() const&
-    requires copyable<iterator_t<_Base>>
-  {
+  constexpr const iterator_t<_Base>& base() const& noexcept {
     return __current_;
   }
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr iterator_t<_Base> base() && {
     return _VSTD::move(__current_);
   }
 

libcxx/test/std/iterators/predef.iterators/counted.iterator/base.pass.cpp

struct InputOrOutputArchetype {
   InputOrOutputArchetype& operator++() { ++ptr; return *this; }
 };
 
 constexpr bool test() {
   int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
 
   {
     std::counted_iterator iter(cpp20_input_iterator<int*>{buffer}, 8);
-    assert(iter.base().base() == buffer);
-    assert(std::move(iter).base().base() == buffer);
+    assert(base(iter.base()) == buffer);
+    assert(base(std::move(iter).base()) == buffer);
 
+    ASSERT_NOEXCEPT(iter.base());
     ASSERT_SAME_TYPE(decltype(iter.base()), const cpp20_input_iterator<int*>&);
     ASSERT_SAME_TYPE(decltype(std::move(iter).base()), cpp20_input_iterator<int*>);
   }
 
   {
     std::counted_iterator iter(forward_iterator<int*>{buffer}, 8);
-    assert(iter.base() == forward_iterator<int*>{buffer});
-    assert(std::move(iter).base() == forward_iterator<int*>{buffer});
+    assert(base(iter.base()) == buffer);
+    assert(base(std::move(iter).base()) == buffer);
 
     ASSERT_SAME_TYPE(decltype(iter.base()), const forward_iterator<int*>&);
     ASSERT_SAME_TYPE(decltype(std::move(iter).base()), forward_iterator<int*>);
   }
 
   {
     std::counted_iterator iter(contiguous_iterator<int*>{buffer}, 8);
-    assert(iter.base() == contiguous_iterator<int*>{buffer});
-    assert(std::move(iter).base() == contiguous_iterator<int*>{buffer});
+    assert(base(iter.base()) == buffer);
+    assert(base(std::move(iter).base()) == buffer);
 
     ASSERT_SAME_TYPE(decltype(iter.base()), const contiguous_iterator<int*>&);
     ASSERT_SAME_TYPE(decltype(std::move(iter).base()), contiguous_iterator<int*>);
   }
 
   {
     std::counted_iterator iter(InputOrOutputArchetype{buffer}, 6);
     assert(iter.base().ptr == buffer);
     assert(std::move(iter).base().ptr == buffer);
 
     ASSERT_SAME_TYPE(decltype(iter.base()), const InputOrOutputArchetype&);
     ASSERT_SAME_TYPE(decltype(std::move(iter).base()), InputOrOutputArchetype);
   }
 
   {
     const std::counted_iterator iter(cpp20_input_iterator<int*>{buffer}, 8);
-    assert(iter.base().base() == buffer);
-    assert(std::move(iter).base().base() == buffer);
+    assert(base(iter.base()) == buffer);
+    assert(base(std::move(iter).base()) == buffer);
 
     ASSERT_SAME_TYPE(decltype(iter.base()), const cpp20_input_iterator<int*>&);
     ASSERT_SAME_TYPE(decltype(std::move(iter).base()), const cpp20_input_iterator<int*>&);
   }
 
   {
     const std::counted_iterator iter(forward_iterator<int*>{buffer}, 7);
-    assert(iter.base() == forward_iterator<int*>{buffer});
-    assert(std::move(iter).base() == forward_iterator<int*>{buffer});
+    assert(base(iter.base()) == buffer);
+    assert(base(std::move(iter).base()) == buffer);
 
     ASSERT_SAME_TYPE(decltype(iter.base()), const forward_iterator<int*>&);
     ASSERT_SAME_TYPE(decltype(std::move(iter).base()), const forward_iterator<int*>&);
   }
 
   {
     const std::counted_iterator iter(contiguous_iterator<int*>{buffer}, 6);
-    assert(iter.base() == contiguous_iterator<int*>{buffer});
-    assert(std::move(iter).base() == contiguous_iterator<int*>{buffer});
+    assert(base(iter.base()) == buffer);
+    assert(base(std::move(iter).base()) == buffer);
 
     ASSERT_SAME_TYPE(decltype(iter.base()), const contiguous_iterator<int*>&);
     ASSERT_SAME_TYPE(decltype(std::move(iter).base()), const contiguous_iterator<int*>&);
   }
 
   {
     const std::counted_iterator iter(InputOrOutputArchetype{buffer}, 6);
     assert(iter.base().ptr == buffer);

libcxx/test/std/ranges/range.adaptors/range.transform/iterator/base.pass.cpp

 };
 
 constexpr bool test() {
   {
     using TransformView = std::ranges::transform_view<MoveOnlyView, PlusOneMutable>;
     TransformView tv;
     auto begin = tv.begin();
     ASSERT_SAME_TYPE(decltype(begin.base()), int*);
+    ASSERT_NOEXCEPT(begin.base());
     assert(begin.base() == globalBuff);
     ASSERT_SAME_TYPE(decltype(std::move(begin).base()), int*);
     assert(std::move(begin).base() == globalBuff);
   }
   {
     using TransformView = std::ranges::transform_view<InputView, PlusOneMutable>;
     TransformView tv;
     auto begin = tv.begin();