[libc++] Further improve the contiguous-iterator story, and fix some bugs in D94807.

[• Quuxplusone]

Summary

• Quality-of-implementation: Avoid calling __unwrap_iter in constexpr contexts. The user might conceivably write a contiguous iterator where normal iterator arithmetic is constexpr-friendly but std::to_address(it) isn't.
• Bugfix: When you pass contiguous iterators to std::copy, you should get back your contiguous iterator type, not a raw pointer. That means that libc++ can't __unwrap_iter unless it also does __rewrap_iter. Fortunately, this is implementable.
• Improve test coverage of the new contiguous_iterator test iterator. This catches the bug described above.
• Tests: Stop testing that we can std::copy into an input_iterator. Our test iterators may currently support that, but it seems nonsensical to me.

[• Quuxplusone]

Rebase on main (after landing D93661).

[• Quuxplusone]

libcxx/include/algorithm

1649

It's been pointed out to me that this is fine; std::copy is required to have the constexpr keyword on the front, but it's never required to actually be constexpr. libc++ can say "std::copy is constexpr unless you give us a contiguous iterator with a non-constexpr to_address and/or operator->."

1653

I still lack any great way to work around this one, though. I think if we want to use __unwrap_iter(first) on arbitrary user-provided contiguous iterators in copy, then we'll have to separately compute the return value using something like

template<class _OrigIter, class _UnwrappedIter>
_Iter __rewrap_iter(_OrigIter __first, _UnwrappedIter __result)
{
    static_assert(__is_cpp17_contiguous_iterator<_OrigIter>, "");  // otherwise we won't get here
    return __first + (__result - _VSTD::__unwrap_iter(__first));
}

template<class _OrigIter>
_Iter __rewrap_iter(_OrigIter, _OrigIter __result)
{
    return __result;
}
[...]
return _VSTD::__rewrap_iter(__result,
     _VSTD::__copy(_VSTD::__unwrap_iter(__first),
                   _VSTD::__unwrap_iter(__last),
                   _VSTD::__unwrap_iter(__result)));

This mostly destroys our hopes of "reducing the number of template instantiations"; but it does permit us to keep using memmove for user-defined contiguous iterators.

[ldionne]

libcxx/include/algorithm

1656

I don't understand this change - didn't you work around the constexpr problem by *not* calling unwrap_iter on iterators when we're in a constexpr context?

Edit: Ah, I think you're trying to work around the *second* problem you pointed out, which is that you can't automatically re-create an arbitrary user-defined iterator from a raw pointer. Right? A solution for that could be to:

1. Introduce an indirection like __rewrap_iter_impl with a nested __apply that creates an iterator from a raw pointer. That can be specialized as needed.
2. Provide a default implementation for all iterators that are implicitly constructible from a pointer to their value_type.

That way, if the iterator isn't implicitly constructible from the pointer, a user like Chrome can still get the optimization by specializing the struct to tell libc++ how to get an iterator back from a pointer. And by default, it'll work for most iterators out of the box. Thoughts on that solution?

The only issue I can see is if implicit construction from a raw pointer is syntactically valid but doesn't do what we think it should do. I'm not sure how likely or dangerous that could be, but I would argue that if a contiguous iterator is constructible from a pointer but that constructor doesn't do the right thing, then you really voided your warranty with the Standard Library.

[ldionne]

Also, if we go down the road of adding a __rewrap_iter struct, can you add a test exercising that extension point under libcxx/?

Requesting changes for the review queue.

[• Quuxplusone]

libcxx/include/algorithm

1656

That way, if the iterator isn't implicitly constructible from the pointer, a user like Chrome can still get the optimization by specializing the struct to tell libc++ how to get an iterator back from a pointer.

I don't think we need __rewrap_iter to be a customization point at all. A contiguous iterator (even a user-defined one) is always a random-access iterator too, so we can use __first + (__result - _VSTD::__unwrap_iter(__first)) as I indicated in my Phab comment a few lines above this. (If __unwrap_iter is a no-op, meaning that _OrigIter wasn't a contiguous iterator, just return __result unmodified.)

I would argue that if a contiguous iterator is constructible from a pointer but that constructor doesn't do the right thing, then you really voided your warranty with the Standard Library.

I strongly agree in fantasy-everything-as-it-should-be-land, but I'm less sure in actual-C++-land. Remember this is the language that invented std::pointer_traits<It>::to_address(it) and std::pointer_traits<It>::pointer_to(ptr) instead of just using static_cast<T*>(it) and static_cast<It>(ptr).

[• Quuxplusone]

Massive update and (happily) this is now less of a revert and more of a bugfix.

[ldionne]

libcxx/include/algorithm

1656

The issue with this approach is that it requires the unwrapped iterator to be reachable from the original iterator. That works for the algorithms we want to apply it to, but I could imagine other circumstances where that doesn't work, say if we're allocating a new range.

libcxx/include/algorithm

 _ForwardIterator
 search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value_)
 {
     typedef typename iterator_traits<_ForwardIterator>::value_type __v;
     return _VSTD::search_n(__first, __last, _VSTD::__convert_to_integral(__count),
                            __value_, __equal_to<__v, _Tp>());
 }
 
-// __unwrap_iter
+// __unwrap_iter, __rewrap_iter
 
-// The job of __unwrap_iter is to lower iterators-that-are-tantamount-to-pointers
-// (such as vector<T>::iterator) into pointers, to reduce the number of template
+// The job of __unwrap_iter is to lower contiguous iterators (such as
+// vector<T>::iterator) into pointers, to reduce the number of template
 // instantiations and to enable pointer-based optimizations e.g. in std::copy.
+// For iterators that are not contiguous, it must be a no-op.
 // In debug mode, we don't do this.
+//
+// __unwrap_iter is non-constexpr for user-defined iterators whose
+// `to_address` and/or `operator->` is non-constexpr. This is okay; but we
+// try to avoid doing __unwrap_iter in constant-evaluated contexts anyway.
+//
+// Some algorithms (e.g. std::copy, but not std::sort) need to convert an
+// "unwrapped" result back into a contiguous iterator. Since contiguous iterators
+// are random-access, we can do this portably using iterator arithmetic; this
+// is the job of __rewrap_iter.
 
 template <class _Iter, bool = __is_cpp17_contiguous_iterator<_Iter>::value>
 struct __unwrap_iter_impl {
     static _LIBCPP_CONSTEXPR _Iter
     __apply(_Iter __i) _NOEXCEPT {
         return __i;
     }
 };

 template<class _Iter, class _Impl = __unwrap_iter_impl<_Iter> >
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 decltype(_Impl::__apply(_VSTD::declval<_Iter>()))
 __unwrap_iter(_Iter __i) _NOEXCEPT
 {
     return _Impl::__apply(__i);
 }
 
+template<class _OrigIter>
+_OrigIter __rewrap_iter(_OrigIter, _OrigIter __result)
+{
+    return __result;
+}
+
+template<class _OrigIter, class _UnwrappedIter>
+_OrigIter __rewrap_iter(_OrigIter __first, _UnwrappedIter __result)
+{
+    // Precondition: __result is reachable from __first
+    // Precondition: _OrigIter is a contiguous iterator
+    return __first + (__result - _VSTD::__unwrap_iter(__first));
+}
+
 // copy
 
 template <class _InputIterator, class _OutputIterator>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _OutputIterator
 __copy_constexpr(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
 {
     for (; __first != __last; ++__first, (void) ++__result)

 }
 
 template <class _InputIterator, class _OutputIterator>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _OutputIterator
 copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
 {
     if (__libcpp_is_constant_evaluated()) {
-        return _VSTD::__copy_constexpr(
-            _VSTD::__unwrap_iter(__first), _VSTD::__unwrap_iter(__last), _VSTD::__unwrap_iter(__result));
+        return _VSTD::__copy_constexpr(__first, __last, __result);
     } else {
-        return _VSTD::__copy(
-            _VSTD::__unwrap_iter(__first), _VSTD::__unwrap_iter(__last), _VSTD::__unwrap_iter(__result));
+        return _VSTD::__rewrap_iter(__result,
+            _VSTD::__copy(_VSTD::__unwrap_iter(__first),
+                          _VSTD::__unwrap_iter(__last),
+                          _VSTD::__unwrap_iter(__result)));
     }
 }
 
 // copy_backward
 
 template <class _BidirectionalIterator, class _OutputIterator>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _OutputIterator

 
 template <class _BidirectionalIterator1, class _BidirectionalIterator2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _BidirectionalIterator2
 copy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
               _BidirectionalIterator2 __result)
 {
     if (__libcpp_is_constant_evaluated()) {
-        return _VSTD::__copy_backward_constexpr(_VSTD::__unwrap_iter(__first),
-                                                _VSTD::__unwrap_iter(__last),
-                                                _VSTD::__unwrap_iter(__result));
+        return _VSTD::__copy_backward_constexpr(__first, __last, __result);
     } else {
-        return _VSTD::__copy_backward(_VSTD::__unwrap_iter(__first),
-                                      _VSTD::__unwrap_iter(__last),
-                                      _VSTD::__unwrap_iter(__result));
+        return _VSTD::__rewrap_iter(__result,
+            _VSTD::__copy_backward(_VSTD::__unwrap_iter(__first),
+                                   _VSTD::__unwrap_iter(__result)));
     }
 }
 
 // copy_if
 
 template<class _InputIterator, class _OutputIterator, class _Predicate>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _OutputIterator

 {
     typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize;
     _IntegralSize __n = __orig_n;
     return _VSTD::copy(__first, __first + __n, __result);
 }
 
 // move
 
-// __move_constexpr exists so that __move doesn't call itself when delegating to the constexpr
-// version of __move.
 template <class _InputIterator, class _OutputIterator>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 _OutputIterator
 __move_constexpr(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
 {
     for (; __first != __last; ++__first, (void) ++__result)
         *__result = _VSTD::move(*__first);
     return __result;

 typename enable_if
 <
     is_same<typename remove_const<_Tp>::type, _Up>::value &&
     is_trivially_move_assignable<_Up>::value,
     _Up*
 >::type
 __move(_Tp* __first, _Tp* __last, _Up* __result)
 {
-    if (__libcpp_is_constant_evaluated())
-        return _VSTD::__move_constexpr(__first, __last, __result);
     const size_t __n = static_cast<size_t>(__last - __first);
     if (__n > 0)
         _VSTD::memmove(__result, __first, __n * sizeof(_Up));
     return __result + __n;
 }
 
 template <class _InputIterator, class _OutputIterator>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _OutputIterator
 move(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
 {
-    return _VSTD::__move(_VSTD::__unwrap_iter(__first), _VSTD::__unwrap_iter(__last), _VSTD::__unwrap_iter(__result));
+    if (__libcpp_is_constant_evaluated()) {
+        return _VSTD::__move_constexpr(__first, __last, __result);
+    } else {
+        return _VSTD::__rewrap_iter(__result,
+            _VSTD::__move(_VSTD::__unwrap_iter(__first),
+                          _VSTD::__unwrap_iter(__last),
+                          _VSTD::__unwrap_iter(__result)));
+    }
 }
 
 // move_backward
 
-// __move_backward_constexpr exists so that __move_backward doesn't call itself when delegating to
-// the constexpr version of __move_backward.
 template <class _InputIterator, class _OutputIterator>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 _OutputIterator
 __move_backward_constexpr(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
 {
     while (__first != __last)
         *--__result = _VSTD::move(*--__last);
     return __result;

 typename enable_if
 <
     is_same<typename remove_const<_Tp>::type, _Up>::value &&
     is_trivially_move_assignable<_Up>::value,
     _Up*
 >::type
 __move_backward(_Tp* __first, _Tp* __last, _Up* __result)
 {
-    if (__libcpp_is_constant_evaluated())
-        return _VSTD::__move_backward_constexpr(__first, __last, __result);
     const size_t __n = static_cast<size_t>(__last - __first);
     if (__n > 0)
     {
         __result -= __n;
         _VSTD::memmove(__result, __first, __n * sizeof(_Up));
     }
     return __result;
 }
 
 template <class _BidirectionalIterator1, class _BidirectionalIterator2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _BidirectionalIterator2
 move_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
               _BidirectionalIterator2 __result)
 {
-    return _VSTD::__move_backward(_VSTD::__unwrap_iter(__first), _VSTD::__unwrap_iter(__last), _VSTD::__unwrap_iter(__result));
+    if (__libcpp_is_constant_evaluated()) {
+        return _VSTD::__move_backward_constexpr(__first, __last, __result);
+    } else {
+        return _VSTD::__rewrap_iter(__result,
+            _VSTD::__move_backward(_VSTD::__unwrap_iter(__first),
+                                   _VSTD::__unwrap_iter(__last),
+                                   _VSTD::__unwrap_iter(__result)));
+    }
 }
 
 // iter_swap
 
 // moved to <type_traits> for better swap / noexcept support
 
 // transform
 

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp

test_copy()
     for (unsigned i = 0; i < N; ++i)
         assert(ia[i] == ib[i]);
 }
 
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
     test_copy<input_iterator<const int*>, output_iterator<int*> >();
-    test_copy<input_iterator<const int*>, input_iterator<int*> >();
     test_copy<input_iterator<const int*>, forward_iterator<int*> >();
     test_copy<input_iterator<const int*>, bidirectional_iterator<int*> >();
     test_copy<input_iterator<const int*>, random_access_iterator<int*> >();
     test_copy<input_iterator<const int*>, int*>();
 
     test_copy<forward_iterator<const int*>, output_iterator<int*> >();
-    test_copy<forward_iterator<const int*>, input_iterator<int*> >();
     test_copy<forward_iterator<const int*>, forward_iterator<int*> >();
     test_copy<forward_iterator<const int*>, bidirectional_iterator<int*> >();
     test_copy<forward_iterator<const int*>, random_access_iterator<int*> >();
     test_copy<forward_iterator<const int*>, int*>();
 
     test_copy<bidirectional_iterator<const int*>, output_iterator<int*> >();
-    test_copy<bidirectional_iterator<const int*>, input_iterator<int*> >();
     test_copy<bidirectional_iterator<const int*>, forward_iterator<int*> >();
     test_copy<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
     test_copy<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
     test_copy<bidirectional_iterator<const int*>, int*>();
 
     test_copy<random_access_iterator<const int*>, output_iterator<int*> >();
-    test_copy<random_access_iterator<const int*>, input_iterator<int*> >();
     test_copy<random_access_iterator<const int*>, forward_iterator<int*> >();
     test_copy<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
     test_copy<random_access_iterator<const int*>, random_access_iterator<int*> >();
     test_copy<random_access_iterator<const int*>, int*>();
 
     test_copy<const int*, output_iterator<int*> >();
-    test_copy<const int*, input_iterator<int*> >();
     test_copy<const int*, forward_iterator<int*> >();
     test_copy<const int*, bidirectional_iterator<int*> >();
     test_copy<const int*, random_access_iterator<int*> >();
     test_copy<const int*, int*>();
 
+#if TEST_STD_VER > 17
+    test_copy<input_iterator<const int*>, contiguous_iterator<int*>>();
+    test_copy<forward_iterator<const int*>, contiguous_iterator<int*>>();
+    test_copy<bidirectional_iterator<const int*>, contiguous_iterator<int*>>();
+    test_copy<random_access_iterator<const int*>, contiguous_iterator<int*>>();
+    test_copy<const int*, contiguous_iterator<int*>>();
+
+    test_copy<contiguous_iterator<const int*>, output_iterator<int*>>();
+    test_copy<contiguous_iterator<const int*>, forward_iterator<int*>>();
+    test_copy<contiguous_iterator<const int*>, bidirectional_iterator<int*>>();
+    test_copy<contiguous_iterator<const int*>, random_access_iterator<int*>>();
+    test_copy<contiguous_iterator<const int*>, int*>();
+#endif
+
   return true;
 }
 
 int main(int, char**)
 {
     test();
 
 #if TEST_STD_VER > 17
     static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_backward.pass.cpp

test()
     test_copy_backward<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
     test_copy_backward<random_access_iterator<const int*>, random_access_iterator<int*> >();
     test_copy_backward<random_access_iterator<const int*>, int*>();
 
     test_copy_backward<const int*, bidirectional_iterator<int*> >();
     test_copy_backward<const int*, random_access_iterator<int*> >();
     test_copy_backward<const int*, int*>();
 
+#if TEST_STD_VER > 17
+    test_copy_backward<contiguous_iterator<const int*>, bidirectional_iterator<int*>>();
+    test_copy_backward<contiguous_iterator<const int*>, random_access_iterator<int*>>();
+    test_copy_backward<contiguous_iterator<const int*>, int*>();
+
+    test_copy_backward<bidirectional_iterator<const int*>, contiguous_iterator<int*>>();
+    test_copy_backward<random_access_iterator<const int*>, contiguous_iterator<int*>>();
+    test_copy_backward<contiguous_iterator<const int*>, contiguous_iterator<int*>>();
+    test_copy_backward<const int*, contiguous_iterator<int*>>();
+#endif
+
     return true;
 }
 
 int main(int, char**)
 {
     test();
 
 #if TEST_STD_VER > 17
     static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp

test1()
     for (unsigned i = 0; i < N; ++i)
         assert(*ib[i] == static_cast<int>(i));
 }
 #endif
 
 int main(int, char**)
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
-    test<input_iterator<const int*>, input_iterator<int*> >();
     test<input_iterator<const int*>, forward_iterator<int*> >();
     test<input_iterator<const int*>, bidirectional_iterator<int*> >();
     test<input_iterator<const int*>, random_access_iterator<int*> >();
     test<input_iterator<const int*>, int*>();
 
     test<forward_iterator<const int*>, output_iterator<int*> >();
-    test<forward_iterator<const int*>, input_iterator<int*> >();
     test<forward_iterator<const int*>, forward_iterator<int*> >();
     test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
     test<forward_iterator<const int*>, random_access_iterator<int*> >();
     test<forward_iterator<const int*>, int*>();
 
     test<bidirectional_iterator<const int*>, output_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, input_iterator<int*> >();
     test<bidirectional_iterator<const int*>, forward_iterator<int*> >();
     test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
     test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
     test<bidirectional_iterator<const int*>, int*>();
 
     test<random_access_iterator<const int*>, output_iterator<int*> >();
-    test<random_access_iterator<const int*>, input_iterator<int*> >();
     test<random_access_iterator<const int*>, forward_iterator<int*> >();
     test<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
     test<random_access_iterator<const int*>, random_access_iterator<int*> >();
     test<random_access_iterator<const int*>, int*>();
 
     test<const int*, output_iterator<int*> >();
-    test<const int*, input_iterator<int*> >();
     test<const int*, forward_iterator<int*> >();
     test<const int*, bidirectional_iterator<int*> >();
     test<const int*, random_access_iterator<int*> >();
     test<const int*, int*>();
 
 #if TEST_STD_VER >= 11
     test1<input_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*> >();
-    test1<input_iterator<std::unique_ptr<int>*>, input_iterator<std::unique_ptr<int>*> >();
     test1<input_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*> >();
     test1<input_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
     test1<input_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
     test1<input_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
 
     test1<forward_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*> >();
-    test1<forward_iterator<std::unique_ptr<int>*>, input_iterator<std::unique_ptr<int>*> >();
     test1<forward_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*> >();
     test1<forward_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
     test1<forward_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
     test1<forward_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
 
     test1<bidirectional_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*> >();
-    test1<bidirectional_iterator<std::unique_ptr<int>*>, input_iterator<std::unique_ptr<int>*> >();
     test1<bidirectional_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*> >();
     test1<bidirectional_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
     test1<bidirectional_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
     test1<bidirectional_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
 
     test1<random_access_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*> >();
-    test1<random_access_iterator<std::unique_ptr<int>*>, input_iterator<std::unique_ptr<int>*> >();
     test1<random_access_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*> >();
     test1<random_access_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
     test1<random_access_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
     test1<random_access_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
 
     test1<std::unique_ptr<int>*, output_iterator<std::unique_ptr<int>*> >();
-    test1<std::unique_ptr<int>*, input_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, forward_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, bidirectional_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, std::unique_ptr<int>*>();
 #endif // TEST_STD_VER >= 11
 
 #if TEST_STD_VER > 17
+    test<input_iterator<const int*>, contiguous_iterator<int*>>();
+    test<forward_iterator<const int*>, contiguous_iterator<int*>>();
+    test<bidirectional_iterator<const int*>, contiguous_iterator<int*>>();
+    test<random_access_iterator<const int*>, contiguous_iterator<int*>>();
+    test<const int*, contiguous_iterator<int*>>();
+    test<contiguous_iterator<const int*>, output_iterator<int*>>();
+    test<contiguous_iterator<const int*>, forward_iterator<int*>>();
+    test<contiguous_iterator<const int*>, bidirectional_iterator<int*>>();
+    test<contiguous_iterator<const int*>, random_access_iterator<int*>>();
+    test<contiguous_iterator<const int*>, int*>();
+    test<contiguous_iterator<const int*>, contiguous_iterator<int*>>();
+
+    test1<input_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
+    test1<forward_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
+    test1<bidirectional_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
+    test1<random_access_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
+    test1<std::unique_ptr<int>*, contiguous_iterator<std::unique_ptr<int>*>>();
+    test1<contiguous_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*>>();
+    test1<contiguous_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*>>();
+    test1<contiguous_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*>>();
+    test1<contiguous_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*>>();
+    test1<contiguous_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
+    test1<contiguous_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
+
     static_assert(test<input_iterator<const int*>, input_iterator<int*> >());
     static_assert(test<input_iterator<const int*>, forward_iterator<int*> >());
     static_assert(test<input_iterator<const int*>, bidirectional_iterator<int*> >());
     static_assert(test<input_iterator<const int*>, random_access_iterator<int*> >());
+    static_assert(test<input_iterator<const int*>, contiguous_iterator<int*> >());
     static_assert(test<input_iterator<const int*>, int*>());
 
     static_assert(test<forward_iterator<const int*>, input_iterator<int*> >());
     static_assert(test<forward_iterator<const int*>, forward_iterator<int*> >());
     static_assert(test<forward_iterator<const int*>, bidirectional_iterator<int*> >());
     static_assert(test<forward_iterator<const int*>, random_access_iterator<int*> >());
+    static_assert(test<forward_iterator<const int*>, contiguous_iterator<int*> >());
     static_assert(test<forward_iterator<const int*>, int*>());
 
     static_assert(test<bidirectional_iterator<const int*>, input_iterator<int*> >());
     static_assert(test<bidirectional_iterator<const int*>, forward_iterator<int*> >());
     static_assert(test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >());
     static_assert(test<bidirectional_iterator<const int*>, random_access_iterator<int*> >());
+    static_assert(test<bidirectional_iterator<const int*>, contiguous_iterator<int*> >());
     static_assert(test<bidirectional_iterator<const int*>, int*>());
 
     static_assert(test<random_access_iterator<const int*>, input_iterator<int*> >());
     static_assert(test<random_access_iterator<const int*>, forward_iterator<int*> >());
     static_assert(test<random_access_iterator<const int*>, bidirectional_iterator<int*> >());
     static_assert(test<random_access_iterator<const int*>, random_access_iterator<int*> >());
+    static_assert(test<random_access_iterator<const int*>, contiguous_iterator<int*> >());
     static_assert(test<random_access_iterator<const int*>, int*>());
 
+    static_assert(test<contiguous_iterator<const int*>, input_iterator<int*> >());
+    static_assert(test<contiguous_iterator<const int*>, forward_iterator<int*> >());
+    static_assert(test<contiguous_iterator<const int*>, bidirectional_iterator<int*> >());
+    static_assert(test<contiguous_iterator<const int*>, random_access_iterator<int*> >());
+    static_assert(test<contiguous_iterator<const int*>, contiguous_iterator<int*> >());
+    static_assert(test<contiguous_iterator<const int*>, int*>());
+
     static_assert(test<const int*, input_iterator<int*> >());
     static_assert(test<const int*, forward_iterator<int*> >());
     static_assert(test<const int*, bidirectional_iterator<int*> >());
     static_assert(test<const int*, random_access_iterator<int*> >());
+    static_assert(test<const int*, contiguous_iterator<int*> >());
     static_assert(test<const int*, int*>());
 #endif  // TEST_STD_VER > 17
 
   return 0;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp

#if TEST_STD_VER >= 11
     test1<random_access_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
 
     test1<std::unique_ptr<int>*, bidirectional_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, std::unique_ptr<int>*>();
 #endif // TEST_STD_VER >= 11
 
 #if TEST_STD_VER > 17
+    test<bidirectional_iterator<const int*>, contiguous_iterator<int*>>();
+    test<random_access_iterator<const int*>, contiguous_iterator<int*>>();
+    test<const int*, contiguous_iterator<int*>>();
+    test<contiguous_iterator<const int*>, bidirectional_iterator<int*>>();
+    test<contiguous_iterator<const int*>, random_access_iterator<int*>>();
+    test<contiguous_iterator<const int*>, int*>();
+    test<contiguous_iterator<const int*>, contiguous_iterator<int*>>();
+
+    test1<bidirectional_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
+    test1<random_access_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
+    test1<std::unique_ptr<int>*, contiguous_iterator<std::unique_ptr<int>*>>();
+    test1<contiguous_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*>>();
+    test1<contiguous_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*>>();
+    test1<contiguous_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
+    test1<contiguous_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
+
     static_assert(test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >());
     static_assert(test<bidirectional_iterator<const int*>, random_access_iterator<int*> >());
+    static_assert(test<bidirectional_iterator<const int*>, contiguous_iterator<int*> >());
     static_assert(test<bidirectional_iterator<const int*>, int*>());
 
     static_assert(test<random_access_iterator<const int*>, bidirectional_iterator<int*> >());
     static_assert(test<random_access_iterator<const int*>, random_access_iterator<int*> >());
+    static_assert(test<random_access_iterator<const int*>, contiguous_iterator<int*> >());
     static_assert(test<random_access_iterator<const int*>, int*>());
 
+    static_assert(test<contiguous_iterator<const int*>, bidirectional_iterator<int*> >());
+    static_assert(test<contiguous_iterator<const int*>, random_access_iterator<int*> >());
+    static_assert(test<contiguous_iterator<const int*>, contiguous_iterator<int*> >());
+    static_assert(test<contiguous_iterator<const int*>, int*>());
+
     static_assert(test<const int*, bidirectional_iterator<int*> >());
     static_assert(test<const int*, random_access_iterator<int*> >());
+    static_assert(test<const int*, contiguous_iterator<int*> >());
     static_assert(test<const int*, int*>());
 #endif  // TEST_STD_VER > 17
 
   return 0;
 }

libcxx/test/std/algorithms/alg.sorting/alg.sort/sort/sort_constexpr.pass.cpp

#endif
     test_pointers<17, char, char**>();
     test_pointers<17, char, random_access_iterator<char**> >();
     test_pointers<17, const char, const char**>();
     test_pointers<17, const char, random_access_iterator<const char**> >();
     test_pointers<17, int, int**>();
     test_pointers<17, int, random_access_iterator<int**> >();
 
 #if TEST_STD_VER >= 20
+    test<7, int, contiguous_iterator<int*>>();
+    test<257, int, contiguous_iterator<int*>>();
+    test<7, MoveOnly, contiguous_iterator<MoveOnly*>>();
+    test<257, MoveOnly, contiguous_iterator<MoveOnly*>>();
+    test_pointers<17, char, contiguous_iterator<char**>>();
+    test_pointers<17, const char, contiguous_iterator<const char**>>();
+    test_pointers<17, int, contiguous_iterator<int**>>();
+
     static_assert(test<7, int, int*>());
     static_assert(test<7, int, random_access_iterator<int*>>());
+    static_assert(test<7, int, contiguous_iterator<int*>>());
     static_assert(test<257, int, int*>());
     static_assert(test<257, int, random_access_iterator<int*>>());
+    static_assert(test<257, int, contiguous_iterator<int*>>());
 
     static_assert(test<7, MoveOnly, MoveOnly*>());
     static_assert(test<7, MoveOnly, random_access_iterator<MoveOnly*>>());
+    static_assert(test<7, MoveOnly, contiguous_iterator<MoveOnly*>>());
     static_assert(test<257, MoveOnly, MoveOnly*>());
     static_assert(test<257, MoveOnly, random_access_iterator<MoveOnly*>>());
+    static_assert(test<257, MoveOnly, contiguous_iterator<MoveOnly*>>());
 
     static_assert(test_pointers<17, char, char**>());
     static_assert(test_pointers<17, char, random_access_iterator<char**>>());
+    static_assert(test_pointers<17, char, contiguous_iterator<char**>>());
     static_assert(test_pointers<17, const char, const char**>());
     static_assert(test_pointers<17, const char, random_access_iterator<const char**>>());
+    static_assert(test_pointers<17, const char, contiguous_iterator<const char**>>());
     static_assert(test_pointers<17, int, int**>());
     static_assert(test_pointers<17, int, random_access_iterator<int**>>());
+    static_assert(test_pointers<17, int, contiguous_iterator<int**>>());
 #endif
 
     return 0;
 }

libcxx/test/std/algorithms/alg.sorting/alg.sort/sort/sort_constexpr_comp.pass.cpp

#endif
     test_pointers<17, char, char**>();
     test_pointers<17, char, random_access_iterator<char**> >();
     test_pointers<17, const char, const char**>();
     test_pointers<17, const char, random_access_iterator<const char**> >();
     test_pointers<17, int, int**>();
     test_pointers<17, int, random_access_iterator<int**> >();
 
 #if TEST_STD_VER >= 20
+    test<7, int, contiguous_iterator<int*>>();
+    test<257, int, contiguous_iterator<int*>>();
+    test<7, MoveOnly, contiguous_iterator<MoveOnly*>>();
+    test<257, MoveOnly, contiguous_iterator<MoveOnly*>>();
+    test_pointers<17, char, contiguous_iterator<char**>>();
+    test_pointers<17, const char, contiguous_iterator<const char**>>();
+    test_pointers<17, int, contiguous_iterator<int**>>();
+
     static_assert(test<7, int, int*>());
     static_assert(test<7, int, random_access_iterator<int*>>());
+    static_assert(test<7, int, contiguous_iterator<int*>>());
     static_assert(test<257, int, int*>());
     static_assert(test<257, int, random_access_iterator<int*>>());
+    static_assert(test<257, int, contiguous_iterator<int*>>());
 
     static_assert(test<7, MoveOnly, MoveOnly*>());
     static_assert(test<7, MoveOnly, random_access_iterator<MoveOnly*>>());
+    static_assert(test<7, MoveOnly, contiguous_iterator<MoveOnly*>>());
     static_assert(test<257, MoveOnly, MoveOnly*>());
     static_assert(test<257, MoveOnly, random_access_iterator<MoveOnly*>>());
+    static_assert(test<257, MoveOnly, contiguous_iterator<MoveOnly*>>());
 
     static_assert(test_pointers<17, char, char**>());
     static_assert(test_pointers<17, char, random_access_iterator<char**>>());
+    static_assert(test_pointers<17, char, contiguous_iterator<char**>>());
     static_assert(test_pointers<17, const char, const char**>());
     static_assert(test_pointers<17, const char, random_access_iterator<const char**>>());
+    static_assert(test_pointers<17, const char, contiguous_iterator<const char**>>());
     static_assert(test_pointers<17, int, int**>());
     static_assert(test_pointers<17, int, random_access_iterator<int**>>());
+    static_assert(test_pointers<17, int, contiguous_iterator<int**>>());
 #endif
 
     return 0;
 }

libcxx/test/support/test_iterators.h

 {
     return x.base() - y.base();
 }
 
 #if TEST_STD_VER >= 20
 template <class It>
 class contiguous_iterator
 {
+    static_assert(std::is_pointer_v<It>, "Things probably break in this case");
+
     It it_;
 
     template <class U> friend class contiguous_iterator;
 public:
     typedef          std::contiguous_iterator_tag              iterator_category;
     typedef typename std::iterator_traits<It>::value_type      value_type;
     typedef typename std::iterator_traits<It>::difference_type difference_type;
     typedef It                                                 pointer;
     typedef typename std::iterator_traits<It>::reference       reference;
-    typedef typename std::iterator_traits<It>::value_type      element_type;
+    typedef typename std::remove_pointer<It>::type             element_type;
 
     TEST_CONSTEXPR_CXX14 It base() const {return it_;}
 
     TEST_CONSTEXPR_CXX14 contiguous_iterator() : it_() {}
     explicit TEST_CONSTEXPR_CXX14 contiguous_iterator(It it) : it_(it) {}
     template <class U>
-        TEST_CONSTEXPR_CXX14 contiguous_iterator(const contiguous_iterator<U>& u) :it_(u.it_) {}
+        TEST_CONSTEXPR_CXX14 contiguous_iterator(const contiguous_iterator<U>& u) : it_(u.it_) {}
 
     TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
     TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;}
 
     TEST_CONSTEXPR_CXX14 contiguous_iterator& operator++() {++it_; return *this;}
     TEST_CONSTEXPR_CXX14 contiguous_iterator operator++(int)
         {contiguous_iterator tmp(*this); ++(*this); return tmp;}