[libcxx][ranges] Add `contiguous_iterator`.

[• Quuxplusone]

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.random.access/contiguous_iterator.compile.pass.cpp

28–32

Most importantly, please check the test iterators from test_iterators.h — e.g.

static_assert(std::contiguous_iterator<contiguous_iterator<int*>>);

Any test iterators that don't match the concepts will want to be fixed.

[zoecarver]

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.random.access/contiguous_iterator.compile.pass.cpp

28–32

I have those a few lines above:

static_assert(!std::contiguous_iterator<input_iterator<int*> >);
static_assert(!std::contiguous_iterator<forward_iterator<int*> >);
static_assert(!std::contiguous_iterator<bidirectional_iterator<int*> >);
static_assert(!std::contiguous_iterator<random_access_iterator<int*> >);
static_assert(std::contiguous_iterator<contiguous_iterator<int*> >);

[cjdb]

Missing conformance tests:

• deque (negative test)
• vector
• span
• string
• reverse_iterator

LGTM, pending CI and added conformance tests.

[zoecarver]

• Add conformance tests.
• Fix review comments.
• Detatch from contiguous_range.

[zoecarver]

libcxx/include/__memory/pointer_traits.h

201

I'm going to make this into a separate PR with test.

[zoecarver]

• Grep/fix the last few conformance tests.

[zoecarver]

• Remove final remaining range test.

(Sorry for all the churn/emails!)

[zoecarver]

• Rebase on main to get the to_address fix.

[zoecarver]

• Reset changes in pointer_traits to fix the diff.

[zoecarver]

Fixing the build failures now. @Quuxplusone friendly ping :)

[zoecarver]

Fix the two failing tests.

libcxx/test/std/containers/sequences/vector.bool/iterator_concept_conformance.compile.pass.cpp

26

Just want to confirm this is correct: vector<bool> is not a contiguous container (while normal vector is).

[cjdb]

libcxx/test/std/containers/sequences/vector.bool/iterator_concept_conformance.compile.pass.cpp

26

Correct.

[• Quuxplusone]

LGTM % comments

libcxx/include/__iterator/concepts.h

16

At some point: Alphabetize.

libcxx/test/std/containers/sequences/vector.bool/iterator_concept_conformance.compile.pass.cpp

26

Please keep static_assert(std::random_access_iterator<reverse_iterator>); (just add the new negative asserts).

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.random.access/contiguous_iterator.compile.pass.cpp

15

concept contiguous_iterator;

46–50

(A) this could be operator<=>?
(B) pass-by-const-value alert! I think you wanted pass-by-const-reference.
Ditto throughout.

libcxx/test/std/iterators/predef.iterators/reverse.iterators/iterator_concept_conformance.compile.pass.cpp

42

Please keep the assert for

static_assert(std::random_access_iterator<reverse_contiguous_iterator>);

(just add the new negative assert). This also applies anywhere else in this PR that you removed a positive assert without replacing it with a stronger positive assert (if any such places exist).

[zoecarver]

Apply Arthur's comments.

[zoecarver]

Remove extra requires that's no longer needed now that to_address is SFINAE friendly.

[zoecarver]

Add back SFINAE fix.

libcxx/include/__iterator/concepts.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ITERATOR_CONCEPTS_H
 #define _LIBCPP___ITERATOR_CONCEPTS_H
 
 #include <__config>
 #include <concepts>
 #include <__iterator/iter_move.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/readable_traits.h>
+#include <__memory/pointer_traits.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
requires(_Ip __i, const _Ip __j, const iter_difference_t<_Ip> __n) {
     { __i += __n } -> same_as<_Ip&>;
     { __j +  __n } -> same_as<_Ip>;
     { __n +  __j } -> same_as<_Ip>;
     { __i -= __n } -> same_as<_Ip&>;
     { __j -  __n } -> same_as<_Ip>;
     {  __j[__n]  } -> same_as<iter_reference_t<_Ip>>;
   };
 
+template<class _Ip>
+concept contiguous_iterator =
+  random_access_iterator<_Ip> &&
+  derived_from<_ITER_CONCEPT<_Ip>, contiguous_iterator_tag> &&
+  is_lvalue_reference_v<iter_reference_t<_Ip>> &&
+  same_as<iter_value_t<_Ip>, remove_cvref_t<iter_reference_t<_Ip>>> &&
+  // This condition isn't required, but allows `contiguous_iterator` to be SFINAE friendly
+  // which improves the QoI.
+  (is_pointer_v<_Ip> || requires { sizeof(__pointer_traits_element_type<_Ip>); }) &&
+  requires(const _Ip& __i) {
+    { _VSTD::to_address(__i) } -> same_as<add_pointer_t<iter_reference_t<_Ip>>>;
+  };
+
 // clang-format on
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___ITERATOR_CONCEPTS_H

libcxx/include/__memory/pointer_traits.h

 typename __choose_to_address<_Pointer>::template __return_type<_Pointer>
 __to_address(const _Pointer& __p) _NOEXCEPT
 {
     return __choose_to_address<_Pointer>::__do_it(__p);
 }
 
 template <> struct __to_address_helper<false> {
     template <class _Pointer>
-    using __return_type = typename pointer_traits<_Pointer>::element_type*;
+    using __return_type = decltype( _VSTD::__to_address(declval<const _Pointer&>().operator->()));
 
     template <class _Pointer>
     _LIBCPP_CONSTEXPR
     static __return_type<_Pointer>
     __do_it(const _Pointer &__p) _NOEXCEPT { return _VSTD::__to_address(__p.operator->()); }
 };
 
 

libcxx/test/std/containers/sequences/array/iterator_concept_conformance.compile.pass.cpp

 
 #include <iterator>
 
 using iterator = std::array<int, 10>::iterator;
 using const_iterator = std::array<int, 10>::const_iterator;
 using reverse_iterator = std::array<int, 10>::reverse_iterator;
 using const_reverse_iterator = std::array<int, 10>::const_reverse_iterator;
 
-static_assert(std::random_access_iterator<iterator>);
+static_assert(std::contiguous_iterator<iterator>);
 static_assert(std::indirectly_writable<iterator, int>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<iterator, const_reverse_iterator>);
 static_assert(std::sized_sentinel_for<iterator, iterator>);
 static_assert(std::sized_sentinel_for<iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, const_reverse_iterator>);
 
-static_assert(std::random_access_iterator<const_iterator>);
+static_assert(std::contiguous_iterator<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, int>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert(std::sized_sentinel_for<const_iterator, iterator>);
 static_assert(std::sized_sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_reverse_iterator>);

libcxx/test/std/containers/sequences/array/range_concept_conformance.compile.pass.cpp

 
 using range = std::array<int, 10>;
 namespace stdr = std::ranges;
 
 static_assert(!stdr::view<range>);
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::random_access_range<range>);
+static_assert(stdr::contiguous_range<range>);
 
 
 static_assert(!stdr::view<range const>);
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::random_access_range<range const>);
+static_assert(stdr::contiguous_range<range const>);

libcxx/test/std/containers/sequences/deque/iterator_concept_conformance.compile.pass.cpp

 
 using iterator = std::deque<int>::iterator;
 using const_iterator = std::deque<int>::const_iterator;
 using reverse_iterator = std::deque<int>::reverse_iterator;
 using const_reverse_iterator = std::deque<int>::const_reverse_iterator;
 using value_type = int;
 
 static_assert(std::random_access_iterator<iterator>);
+static_assert(!std::contiguous_iterator<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<iterator, const_reverse_iterator>);
 static_assert(std::sized_sentinel_for<iterator, iterator>);
 static_assert(std::sized_sentinel_for<iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, const_reverse_iterator>);
 
 static_assert(std::random_access_iterator<const_iterator>);
+static_assert(!std::contiguous_iterator<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert(std::sized_sentinel_for<const_iterator, iterator>);
 static_assert(std::sized_sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_reverse_iterator>);

libcxx/test/std/containers/sequences/vector.bool/iterator_concept_conformance.compile.pass.cpp

 #include <iterator>
 
 using iterator = std::vector<bool>::iterator;
 using const_iterator = std::vector<bool>::const_iterator;
 using reverse_iterator = std::vector<bool>::reverse_iterator;
 using const_reverse_iterator = std::vector<bool>::const_reverse_iterator;
 using value_type = bool;
 
-static_assert(std::random_access_iterator<iterator>);
-static_assert(std::random_access_iterator<reverse_iterator>);
+static_assert(std::contiguous_iterator<iterator>);
+static_assert(!std::contiguous_iterator<reverse_iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<iterator, const_reverse_iterator>);
 static_assert(std::sized_sentinel_for<iterator, iterator>);
 static_assert(std::sized_sentinel_for<iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, const_reverse_iterator>);
 
-static_assert(std::random_access_iterator<const_iterator>);
-static_assert(std::random_access_iterator<const_reverse_iterator>);
+static_assert(std::contiguous_iterator<const_iterator>);
+static_assert(!std::contiguous_iterator<const_reverse_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert(std::sized_sentinel_for<const_iterator, iterator>);
 static_assert(std::sized_sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_reverse_iterator>);

libcxx/test/std/containers/sequences/vector/iterator_concept_conformance.compile.pass.cpp

 #include <iterator>
 
 using iterator = std::vector<int>::iterator;
 using const_iterator = std::vector<int>::const_iterator;
 using reverse_iterator = std::vector<int>::reverse_iterator;
 using const_reverse_iterator = std::vector<int>::const_reverse_iterator;
 using value_type = int;
 
-static_assert(std::random_access_iterator<iterator>);
-static_assert(std::random_access_iterator<reverse_iterator>);
+static_assert(std::contiguous_iterator<iterator>);
+static_assert(!std::contiguous_iterator<reverse_iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<iterator, const_reverse_iterator>);
 static_assert(std::sized_sentinel_for<iterator, iterator>);
 static_assert(std::sized_sentinel_for<iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, const_reverse_iterator>);
 
-static_assert(std::random_access_iterator<const_iterator>);
-static_assert(std::random_access_iterator<const_reverse_iterator>);
+static_assert(std::contiguous_iterator<const_iterator>);
+static_assert(!std::contiguous_iterator<const_reverse_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert(std::sized_sentinel_for<const_iterator, iterator>);
 static_assert(std::sized_sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_reverse_iterator>);

libcxx/test/std/containers/views/span.iterators/iterator_concept_conformance.compile.pass.cpp

 #include <span>
 
 #include <iterator>
 
 using iterator = std::span<int>::iterator;
 using reverse_iterator = std::span<int>::reverse_iterator;
 using value_type = int;
 
-static_assert(std::random_access_iterator<iterator>);
+static_assert(std::contiguous_iterator<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(std::sized_sentinel_for<iterator, iterator>);
 static_assert(!std::sized_sentinel_for<iterator, reverse_iterator>);

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.random.access/contiguous_iterator.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<class T>
+// concept random_access_iterator;
+
+#include <iterator>
+
+#include "test_iterators.h"
+
+static_assert(!std::contiguous_iterator<input_iterator<int*> >);
+static_assert(!std::contiguous_iterator<forward_iterator<int*> >);
+static_assert(!std::contiguous_iterator<bidirectional_iterator<int*> >);
+static_assert(!std::contiguous_iterator<random_access_iterator<int*> >);
+static_assert(std::contiguous_iterator<contiguous_iterator<int*> >);
+
+static_assert(std::contiguous_iterator<int*>);
+static_assert(std::contiguous_iterator<int const*>);
+static_assert(std::contiguous_iterator<int volatile*>);
+static_assert(std::contiguous_iterator<int const volatile*>);
+
+struct simple_contiguous_iterator {
+    typedef std::contiguous_iterator_tag    iterator_category;
+    typedef int                             value_type;
+    typedef int                             element_type;
+    typedef std::ptrdiff_t                  difference_type;
+    typedef int*                            pointer;
+    typedef int&                            reference;
+    typedef simple_contiguous_iterator      self;
+
+    simple_contiguous_iterator();
+
+    reference operator*() const;
+    pointer operator->() const;
+    friend bool operator==(const self, const self y);
+    friend bool operator< (const self, const self y);
+    friend bool operator<=(const self, const self y);
+    friend bool operator> (const self, const self y);
+    friend bool operator>=(const self, const self y);
+
+    self& operator++();
+    self operator++(int);
+
+    self& operator--();
+    self operator--(int);
+
+    self& operator+=(difference_type n);
+    self operator+(difference_type n) const;
+    friend self operator+(difference_type n, self x);
+
+    self& operator-=(difference_type n);
+    self operator-(difference_type n) const;
+    difference_type operator-(const self n) const;
+
+    reference operator[](difference_type n) const;
+};
+
+static_assert(std::random_access_iterator<simple_contiguous_iterator>);
+static_assert(std::contiguous_iterator<simple_contiguous_iterator>);
+
+struct missmatch_value_iter_ref_t {
+    typedef std::contiguous_iterator_tag    iterator_category;
+    typedef short                           value_type;
+    typedef std::ptrdiff_t                  difference_type;
+    typedef int*                            pointer;
+    typedef int&                            reference;
+    typedef missmatch_value_iter_ref_t      self;
+
+    missmatch_value_iter_ref_t();
+
+    reference operator*() const;
+    pointer operator->() const;
+    friend bool operator==(const self, const self y);
+    friend bool operator< (const self, const self y);
+    friend bool operator<=(const self, const self y);
+    friend bool operator> (const self, const self y);
+    friend bool operator>=(const self, const self y);
+
+    self& operator++();
+    self operator++(int);
+
+    self& operator--();
+    self operator--(int);
+
+    self& operator+=(difference_type n);
+    self operator+(difference_type n) const;
+    friend self operator+(difference_type n, self x);
+
+    self& operator-=(difference_type n);
+    self operator-(difference_type n) const;
+    difference_type operator-(const self n) const;
+
+    reference operator[](difference_type n) const;
+};
+
+static_assert(std::random_access_iterator<missmatch_value_iter_ref_t>);
+static_assert(!std::contiguous_iterator<missmatch_value_iter_ref_t>);
+
+struct wrong_iter_reference_t {
+    typedef std::contiguous_iterator_tag    iterator_category;
+    typedef short                           value_type;
+    typedef std::ptrdiff_t                  difference_type;
+    typedef int*                            pointer;
+    typedef short&                          reference;
+    typedef wrong_iter_reference_t          self;
+
+    wrong_iter_reference_t();
+
+    reference operator*() const;
+    pointer operator->() const;
+    friend bool operator==(const self, const self y);
+    friend bool operator< (const self, const self y);
+    friend bool operator<=(const self, const self y);
+    friend bool operator> (const self, const self y);
+    friend bool operator>=(const self, const self y);
+
+    self& operator++();
+    self operator++(int);
+
+    self& operator--();
+    self operator--(int);
+
+    self& operator+=(difference_type n);
+    self operator+(difference_type n) const;
+    friend self operator+(difference_type n, self x);
+
+    self& operator-=(difference_type n);
+    self operator-(difference_type n) const;
+    difference_type operator-(const self n) const;
+
+    reference operator[](difference_type n) const;
+};
+
+static_assert(std::random_access_iterator<wrong_iter_reference_t>);
+static_assert(!std::contiguous_iterator<wrong_iter_reference_t>);
+
+struct no_element_type {
+    typedef std::contiguous_iterator_tag    iterator_category;
+    typedef int                             value_type;
+    typedef std::ptrdiff_t                  difference_type;
+    typedef int*                            pointer;
+    typedef int&                            reference;
+    typedef no_element_type                 self;
+
+    no_element_type();
+
+    reference operator*() const;
+    pointer operator->() const;
+    friend bool operator==(const self, const self y);
+    friend bool operator< (const self, const self y);
+    friend bool operator<=(const self, const self y);
+    friend bool operator> (const self, const self y);
+    friend bool operator>=(const self, const self y);
+
+    self& operator++();
+    self operator++(int);
+
+    self& operator--();
+    self operator--(int);
+
+    self& operator+=(difference_type n);
+    self operator+(difference_type n) const;
+    friend self operator+(difference_type n, self x);
+
+    self& operator-=(difference_type n);
+    self operator-(difference_type n) const;
+    difference_type operator-(const self n) const;
+
+    reference operator[](difference_type n) const;
+};
+
+static_assert(std::random_access_iterator<no_element_type>);
+static_assert(!std::contiguous_iterator<no_element_type>);
+
+struct to_address_wrong_return_type {
+    typedef std::contiguous_iterator_tag    iterator_category;
+    typedef int                             value_type;
+    typedef int                             element_type;
+    typedef std::ptrdiff_t                  difference_type;
+    typedef int*                            pointer;
+    typedef int&                            reference;
+    typedef to_address_wrong_return_type    self;
+
+    to_address_wrong_return_type();
+
+    reference operator*() const;
+    pointer operator->() const;
+    friend bool operator==(const self, const self y);
+    friend bool operator< (const self, const self y);
+    friend bool operator<=(const self, const self y);
+    friend bool operator> (const self, const self y);
+    friend bool operator>=(const self, const self y);
+
+    self& operator++();
+    self operator++(int);
+
+    self& operator--();
+    self operator--(int);
+
+    self& operator+=(difference_type n);
+    self operator+(difference_type n) const;
+    friend self operator+(difference_type n, self x);
+
+    self& operator-=(difference_type n);
+    self operator-(difference_type n) const;
+    difference_type operator-(const self n) const;
+
+    reference operator[](difference_type n) const;
+};
+
+template<>
+struct std::pointer_traits<to_address_wrong_return_type> {
+  typedef void element_type;
+  void *to_address(to_address_wrong_return_type const&);
+};
+
+static_assert(std::random_access_iterator<to_address_wrong_return_type>);
+static_assert(!std::contiguous_iterator<to_address_wrong_return_type>);
+
+template<class>
+struct template_and_no_element_type {
+    typedef std::contiguous_iterator_tag    iterator_category;
+    typedef int                             value_type;
+    typedef std::ptrdiff_t                  difference_type;
+    typedef int*                            pointer;
+    typedef int&                            reference;
+    typedef template_and_no_element_type    self;
+
+    template_and_no_element_type();
+
+    reference operator*() const;
+    pointer operator->() const;
+    friend bool operator==(const self, const self y);
+    friend bool operator< (const self, const self y);
+    friend bool operator<=(const self, const self y);
+    friend bool operator> (const self, const self y);
+    friend bool operator>=(const self, const self y);
+
+    self& operator++();
+    self operator++(int);
+
+    self& operator--();
+    self operator--(int);
+
+    self& operator+=(difference_type n);
+    self operator+(difference_type n) const;
+    friend self operator+(difference_type n, self x);
+
+    self& operator-=(difference_type n);
+    self operator-(difference_type n) const;
+    difference_type operator-(const self n) const;
+
+    reference operator[](difference_type n) const;
+};
+
+// Template param is used instead of element_type.
+static_assert(std::random_access_iterator<template_and_no_element_type<int>>);
+static_assert(std::contiguous_iterator<template_and_no_element_type<int>>);

libcxx/test/std/iterators/predef.iterators/reverse.iterators/iterator_concept_conformance.compile.pass.cpp

 static_assert(common_reverse_iterator_checks<reverse_bidirectional_iterator>());
 static_assert(std::bidirectional_iterator<reverse_bidirectional_iterator>);
 static_assert(!std::random_access_iterator<reverse_bidirectional_iterator>);
 static_assert(!std::sized_sentinel_for<reverse_bidirectional_iterator, reverse_bidirectional_iterator>);
 
 using reverse_random_access_iterator = std::reverse_iterator<random_access_iterator<int*>>;
 static_assert(common_reverse_iterator_checks<reverse_random_access_iterator>());
 static_assert(std::random_access_iterator<reverse_random_access_iterator>);
+static_assert(!std::contiguous_iterator<reverse_random_access_iterator>);
 static_assert(std::sized_sentinel_for<reverse_random_access_iterator, reverse_random_access_iterator>);
 
 using reverse_contiguous_iterator = std::reverse_iterator<contiguous_iterator<int*>>;
 static_assert(common_reverse_iterator_checks<reverse_contiguous_iterator>());
-static_assert(std::random_access_iterator<reverse_contiguous_iterator>);
+static_assert(!std::contiguous_iterator<reverse_contiguous_iterator>);
 static_assert(std::sized_sentinel_for<reverse_contiguous_iterator, reverse_contiguous_iterator>);

libcxx/test/std/strings/basic.string/string.iterators/iterator_concept_conformance.compile.pass.cpp

 #include <iterator>
 
 using iterator = std::string::iterator;
 using const_iterator = std::string::const_iterator;
 using reverse_iterator = std::string::reverse_iterator;
 using const_reverse_iterator = std::string::const_reverse_iterator;
 using value_type = char;
 
-static_assert(std::random_access_iterator<iterator>);
+static_assert(std::contiguous_iterator<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<iterator, const_reverse_iterator>);
 static_assert(std::sized_sentinel_for<iterator, iterator>);
 static_assert(std::sized_sentinel_for<iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, const_reverse_iterator>);
 
-static_assert(std::random_access_iterator<const_iterator>);
+static_assert(std::contiguous_iterator<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert(std::sized_sentinel_for<const_iterator, iterator>);
 static_assert(std::sized_sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_reverse_iterator>);

libcxx/test/std/strings/string.view/string.view.iterators/iterator_concept_conformance.compile.pass.cpp

 
 #include <iterator>
 
 using iterator = std::string_view::iterator;
 using const_iterator = std::string_view::const_iterator;
 using reverse_iterator = std::string_view::reverse_iterator;
 using const_reverse_iterator = std::string_view::const_reverse_iterator;
 
-static_assert(std::random_access_iterator<iterator>);
+static_assert(std::contiguous_iterator<iterator>);
 static_assert(!std::indirectly_writable<iterator, char>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<iterator, const_reverse_iterator>);
 static_assert(std::sized_sentinel_for<iterator, iterator>);
 static_assert(std::sized_sentinel_for<iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, const_reverse_iterator>);
 
-static_assert(std::random_access_iterator<const_iterator>);
+static_assert(std::contiguous_iterator<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, char>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert(std::sized_sentinel_for<const_iterator, iterator>);
 static_assert(std::sized_sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_reverse_iterator>);