Implement part of P0031; adding `constexpr` to `reverse_iterator`

[mclow.lists]

Summary

This just does the reverse_iterator bits of http://wg21.link/P0031 - not any of the other parts.
This duplicates some (but not all) of the work that was done in D20915 and D22584.

The win here (I think) is the extensive tests.

[EricWF]

LGTM modulo inline comments.

include/iterator

95

Missing an = here.

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp

53

This actually tests the copy assignment operator since std::make_reverse_iterator(p) returns reverse_iterator<const Derived *>.
Maybe:

using BaseIt = std::reverse_iterator<const Base *>;
BaseIt it2 = (BaseIt{nullptr} = it1);

It would also be nice if p was non-null so we could test that the actual assignment took place.

54

The static assert is missing a message and is poorly aligned.

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opref/op_arrow.pass.cpp

113

How about just:

constexpr const char *p = "123456789";
constexpr auto it = std::make_reverse_iterator(p+1);
static_assert(it.operator->() == p, "");

[mclow.lists]

Landed as revision 284602

include/iterator

     typedef typename iterator_traits<Iterator>::reference       reference;
     typedef typename iterator_traits<Iterator>::pointer         pointer;
 
-    reverse_iterator();
-    explicit reverse_iterator(Iterator x);
-    template <class U> reverse_iterator(const reverse_iterator<U>& u);
-    Iterator base() const;
-    reference operator*() const;
-    pointer   operator->() const;
-    reverse_iterator& operator++();
-    reverse_iterator  operator++(int);
-    reverse_iterator& operator--();
-    reverse_iterator  operator--(int);
-    reverse_iterator  operator+ (difference_type n) const;
-    reverse_iterator& operator+=(difference_type n);
-    reverse_iterator  operator- (difference_type n) const;
-    reverse_iterator& operator-=(difference_type n);
-    reference         operator[](difference_type n) const;
+    constexpr reverse_iterator();
+    constexpr explicit reverse_iterator(Iterator x);
+    template <class U> constexpr reverse_iterator(const reverse_iterator<U>& u);
+    template <class U> constexpr reverse_iterator& operator (const reverse_iterator<U>& u);
+    constexpr Iterator base() const;
+    constexpr reference operator*() const;
+    constexpr pointer   operator->() const;
+    constexpr reverse_iterator& operator++();
+    constexpr reverse_iterator  operator++(int);
+    constexpr reverse_iterator& operator--();
+    constexpr reverse_iterator  operator--(int);
+    constexpr reverse_iterator  operator+ (difference_type n) const;
+    constexpr reverse_iterator& operator+=(difference_type n);
+    constexpr reverse_iterator  operator- (difference_type n) const;
+    constexpr reverse_iterator& operator-=(difference_type n);
+    constexpr reference         operator[](difference_type n) const;
 };
 
 template <class Iterator1, class Iterator2>
-bool
+constexpr bool                          // constexpr in C++17
 operator==(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
 
 template <class Iterator1, class Iterator2>
-bool
+constexpr bool                          // constexpr in C++17
 operator<(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
 
 template <class Iterator1, class Iterator2>
-bool
+constexpr bool                          // constexpr in C++17
 operator!=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
 
 template <class Iterator1, class Iterator2>
-bool
+constexpr bool                          // constexpr in C++17
 operator>(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
 
 template <class Iterator1, class Iterator2>
-bool
+constexpr bool                          // constexpr in C++17
 operator>=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
 
 template <class Iterator1, class Iterator2>
-bool
+constexpr bool                          // constexpr in C++17
 operator<=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
 
 template <class Iterator1, class Iterator2>
-auto
+constexpr auto
 operator-(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y)
--> decltype(__y.base() - __x.base());
+-> decltype(__y.base() - __x.base());   // constexpr in C++17
 
 template <class Iterator>
-reverse_iterator<Iterator>
-operator+(typename reverse_iterator<Iterator>::difference_type n, const reverse_iterator<Iterator>& x);
+constexpr reverse_iterator<Iterator>
+operator+(typename reverse_iterator<Iterator>::difference_type n, 
+          const reverse_iterator<Iterator>& x);   // constexpr in C++17
 
-template <class Iterator> reverse_iterator<Iterator> make_reverse_iterator(Iterator i); // C++14
+template <class Iterator>
+constexpr reverse_iterator<Iterator> make_reverse_iterator(Iterator i); // C++14, constexpr in C++17
 
 template <class Container>
 class back_insert_iterator

                       typename iterator_traits<_Iter>::reference>
 {
 private:
-    mutable _Iter __t;  // no longer used as of LWG #2360, not removed due to ABI break
+    /*mutable*/ _Iter __t;  // no longer used as of LWG #2360, not removed due to ABI break
 protected:
     _Iter current;
 public:

     typedef typename iterator_traits<_Iter>::reference       reference;
     typedef typename iterator_traits<_Iter>::pointer         pointer;
 
-    _LIBCPP_INLINE_VISIBILITY reverse_iterator() : current() {}
-    _LIBCPP_INLINE_VISIBILITY explicit reverse_iterator(_Iter __x) : __t(__x), current(__x) {}
-    template <class _Up> _LIBCPP_INLINE_VISIBILITY reverse_iterator(const reverse_iterator<_Up>& __u)
-        : __t(__u.base()), current(__u.base()) {}
-    _LIBCPP_INLINE_VISIBILITY _Iter base() const {return current;}
-    _LIBCPP_INLINE_VISIBILITY reference operator*() const {_Iter __tmp = current; return *--__tmp;}
-    _LIBCPP_INLINE_VISIBILITY pointer  operator->() const {return _VSTD::addressof(operator*());}
-    _LIBCPP_INLINE_VISIBILITY reverse_iterator& operator++() {--current; return *this;}
-    _LIBCPP_INLINE_VISIBILITY reverse_iterator  operator++(int)
-        {reverse_iterator __tmp(*this); --current; return __tmp;}
-    _LIBCPP_INLINE_VISIBILITY reverse_iterator& operator--() {++current; return *this;}
-    _LIBCPP_INLINE_VISIBILITY reverse_iterator  operator--(int)
-        {reverse_iterator __tmp(*this); ++current; return __tmp;}
-    _LIBCPP_INLINE_VISIBILITY reverse_iterator  operator+ (difference_type __n) const
-        {return reverse_iterator(current - __n);}
-    _LIBCPP_INLINE_VISIBILITY reverse_iterator& operator+=(difference_type __n)
-        {current -= __n; return *this;}
-    _LIBCPP_INLINE_VISIBILITY reverse_iterator  operator- (difference_type __n) const
-        {return reverse_iterator(current + __n);}
-    _LIBCPP_INLINE_VISIBILITY reverse_iterator& operator-=(difference_type __n)
-        {current += __n; return *this;}
-    _LIBCPP_INLINE_VISIBILITY reference         operator[](difference_type __n) const
-        {return *(*this + __n);}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    reverse_iterator() : __t(), current() {}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    explicit reverse_iterator(_Iter __x) : __t(__x), current(__x) {}
+    template <class _Up>
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+        reverse_iterator(const reverse_iterator<_Up>& __u) : __t(__u.base()), current(__u.base()) {}
+    template <class _Up>
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+        reverse_iterator& operator=(const reverse_iterator<_Up>& __u)
+            { __t = current = __u.base(); return *this; }
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    _Iter base() const {return current;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    reference operator*() const {_Iter __tmp = current; return *--__tmp;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    pointer  operator->() const {return _VSTD::addressof(operator*());}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    reverse_iterator& operator++() {--current; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    reverse_iterator  operator++(int) {reverse_iterator __tmp(*this); --current; return __tmp;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    reverse_iterator& operator--() {++current; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    reverse_iterator  operator--(int) {reverse_iterator __tmp(*this); ++current; return __tmp;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    reverse_iterator  operator+ (difference_type __n) const {return reverse_iterator(current - __n);}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    reverse_iterator& operator+=(difference_type __n) {current -= __n; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    reverse_iterator  operator- (difference_type __n) const {return reverse_iterator(current + __n);}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    reverse_iterator& operator-=(difference_type __n) {current += __n; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    reference         operator[](difference_type __n) const {return *(*this + __n);}
 };
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 bool
 operator==(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 {

 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 bool
 operator<(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 {

 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 bool
 operator!=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 {

 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 bool
 operator>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 {

 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 bool
 operator>=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 {

 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 bool
 operator<=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 {

 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 auto
 operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 -> decltype(__y.base() - __x.base())

 #endif
 
 template <class _Iter>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 reverse_iterator<_Iter>
 operator+(typename reverse_iterator<_Iter>::difference_type __n, const reverse_iterator<_Iter>& __x)
 {

 
 #if _LIBCPP_STD_VER > 11
 template <class _Iter>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 reverse_iterator<_Iter> make_reverse_iterator(_Iter __i)
 {
     return reverse_iterator<_Iter>(__i);

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp

 
 // reverse_iterator
 
-// reverse_iterator();
+// constexpr reverse_iterator();
+//
+// constexpr in c++17
 
 #include <iterator>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     test<random_access_iterator<char*> >();
     test<char*>();
     test<const char*>();
+
+#if TEST_STD_VER > 14
+  {
+    constexpr std::reverse_iterator<const char *> it;
+  }
+#endif
 }

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp

 
 // reverse_iterator
 
-// explicit reverse_iterator(Iter x);
+// explicit constexpr reverse_iterator(Iter x);
+//
+// constexpr in c++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     test(bidirectional_iterator<const char*>(s));
     test(random_access_iterator<const char*>(s));
     test(s);
+
+#if TEST_STD_VER > 14
+  {
+    constexpr const char *p = "123456789";
+    constexpr std::reverse_iterator<const char *> it(p);
+        static_assert(it.base() == p);
+  }
+#endif
 }

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp

 
 // template <class U>
 //   requires HasConstructor<Iter, const U&>
-//   reverse_iterator(const reverse_iterator<U> &u);
+//   constexpr reverse_iterator(const reverse_iterator<U> &u);
+//
+// constexpr in c++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It, class U>

     test<bidirectional_iterator<Base*> >(bidirectional_iterator<Derived*>(&d));
     test<random_access_iterator<const Base*> >(random_access_iterator<Derived*>(&d));
     test<Base*>(&d);
+
+#if TEST_STD_VER > 14
+  {
+    constexpr const Derived *p = nullptr;
+    constexpr std::reverse_iterator<const Derived *>     it1 = std::make_reverse_iterator(p);
+    constexpr std::reverse_iterator<const Base *>        it2(it1);
+        static_assert(it2.base() == p);
+  }
+#endif
 }

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp

 
 // reverse_iterator
 
-// template <class Iterator> reverse_iterator<Iterator>
+// template <class Iterator>
+//   constexpr reverse_iterator<Iterator>
 //     make_reverse_iterator(Iterator i);
+//
+//   constexpr in c++17
 
 #include <iterator>
 #include <cassert>
 
 #include "test_iterators.h"
+#include "test_macros.h"
 
 template <class It>
 void

     random_access_iterator<const char*>e(s+10);
     while ( b != e )
         test ( b++ );
+
+#if TEST_STD_VER > 14
+  {
+    constexpr const char *p = "123456789";
+    constexpr auto it1 = std::make_reverse_iterator(p);
+    static_assert(it1.base() == p, "");
+  }
+#endif
 }
 

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op!=/test.pass.cpp

 
 // template <BidirectionalIterator Iter1, BidirectionalIterator Iter2>
 //   requires HasEqualTo<Iter1, Iter2>
-//   bool
+//   constexpr bool
 //   operator!=(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);
+//
+//   constexpr in c++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s+1), true);
     test(s, s, false);
     test(s, s+1, true);
+
+#if TEST_STD_VER > 14
+  {
+    constexpr const char *p = "123456789";
+    typedef std::reverse_iterator<const char *> RI;
+    constexpr RI it1 = std::make_reverse_iterator(p);
+    constexpr RI it2 = std::make_reverse_iterator(p);
+    constexpr RI it3 = std::make_reverse_iterator(p+1);
+    static_assert(!(it1 != it2), "");
+    static_assert( (it1 != it3), "");
+  }
+#endif
 }

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp

 
 // reverse_iterator
 
-// reverse_iterator operator++(int);
+// constexpr reverse_iterator operator++(int);
+//
+//   constexpr in c++17
 
 #include <iterator>
 #include <cassert>

     test(bidirectional_iterator<const char*>(s+1), bidirectional_iterator<const char*>(s));
     test(random_access_iterator<const char*>(s+1), random_access_iterator<const char*>(s));
     test(s+1, s);
+
+#if TEST_STD_VER > 14
+  {
+    constexpr const char *p = "123456789";
+    typedef std::reverse_iterator<const char *> RI;
+    constexpr RI it1 = std::make_reverse_iterator(p);
+    constexpr RI it2 = std::make_reverse_iterator(p+1);
+    static_assert(it1 != it2, "");
+    constexpr RI it3 = std::make_reverse_iterator(p+1) ++;
+    static_assert(it1 != it3, "");
+    static_assert(it2 == it3, "");
+  }
+#endif
 }

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp

 
 // reverse_iterator
 
-// reverse_iterator& operator++();
+// constexpr reverse_iterator& operator++();
+//
+// constexpr in c++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     test(bidirectional_iterator<const char*>(s+1), bidirectional_iterator<const char*>(s));
     test(random_access_iterator<const char*>(s+1), random_access_iterator<const char*>(s));
     test(s+1, s);
+
+#if TEST_STD_VER > 14
+  {
+    constexpr const char *p = "123456789";
+    typedef std::reverse_iterator<const char *> RI;
+    constexpr RI it1 = std::make_reverse_iterator(p);
+    constexpr RI it2 = std::make_reverse_iterator(p+1);
+    static_assert(it1 != it2, "");
+    constexpr RI it3 = ++ std::make_reverse_iterator(p+1);
+    static_assert(it1 == it3, "");
+    static_assert(it2 != it3, "");
+    static_assert(*(++std::make_reverse_iterator(p+2)) == '1', "");
+  }
+#endif
 }

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp

 // reverse_iterator
 
 // requires RandomAccessIterator<Iter>
-//   reverse_iterator operator+(difference_type n) const;
+//   constexpr reverse_iterator operator+(difference_type n) const;
+//
+// constexpr in c++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s));
     test(s+5, 5, s);
+
+#if TEST_STD_VER > 14
+  {
+    constexpr const char *p = "123456789";
+    typedef std::reverse_iterator<const char *> RI;
+    constexpr RI it1 = std::make_reverse_iterator(p);
+    constexpr RI it2 = std::make_reverse_iterator(p + 5);
+    constexpr RI it3 = it2 + 5;
+    static_assert(it1 != it2, "");
+    static_assert(it1 == it3, "");
+    static_assert(it2 != it3, "");
+  }
+#endif
 }

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+=/difference_type.pass.cpp

 // reverse_iterator
 
 // requires RandomAccessIterator<Iter>
-//   reverse_iterator& operator+=(difference_type n);
+//   constexpr reverse_iterator& operator+=(difference_type n);
+//
+// constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s));
     test(s+5, 5, s);
+
+#if TEST_STD_VER > 14
+  {
+    constexpr const char *p = "123456789";
+    constexpr auto it1 = std::make_reverse_iterator(p);
+    constexpr auto it2 = std::make_reverse_iterator(p+5) += 5;
+    static_assert(it1 == it2, "");
+  }
+#endif
 }

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/post.pass.cpp

 
 // reverse_iterator
 
-// reverse_iterator operator--(int);
+// constexpr reverse_iterator operator--(int);
+//
+// constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     test(bidirectional_iterator<const char*>(s+1), bidirectional_iterator<const char*>(s+2));
     test(random_access_iterator<const char*>(s+1), random_access_iterator<const char*>(s+2));
     test(s+1, s+2);
+
+#if TEST_STD_VER > 14
+  {
+    constexpr const char *p = "123456789";
+    typedef std::reverse_iterator<const char *> RI;
+    constexpr RI it1 = std::make_reverse_iterator(p);
+    constexpr RI it2 = std::make_reverse_iterator(p+1);
+    static_assert(it1 != it2, "");
+    constexpr RI it3 = std::make_reverse_iterator(p) --;
+    static_assert(it1 == it3, "");
+    static_assert(it2 != it3, "");
+  }
+#endif
 }

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/pre.pass.cpp

 
 // reverse_iterator
 
-// reverse_iterator& operator--();
+// constexpr reverse_iterator& operator--();
+//
+// constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     test(bidirectional_iterator<const char*>(s+1), bidirectional_iterator<const char*>(s+2));
     test(random_access_iterator<const char*>(s+1), random_access_iterator<const char*>(s+2));
     test(s+1, s+2);
+
+#if TEST_STD_VER > 14
+  {
+    constexpr const char *p = "123456789";
+    typedef std::reverse_iterator<const char *> RI;
+    constexpr RI it1 = std::make_reverse_iterator(p);
+    constexpr RI it2 = std::make_reverse_iterator(p+1);
+    static_assert(it1 != it2, "");
+    constexpr RI it3 = -- std::make_reverse_iterator(p);
+    static_assert(it1 != it3, "");
+    static_assert(it2 == it3, "");
+    static_assert(*(--std::make_reverse_iterator(p)) == '1', "");
+  }
+#endif
 }

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp

 // reverse_iterator
 
 // requires RandomAccessIterator<Iter>
-//   reverse_iterator operator-(difference_type n) const;
+//   constexpr reverse_iterator operator-(difference_type n) const;
+//
+// constexpr in c++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s+10));
     test(s+5, 5, s+10);
+
+#if TEST_STD_VER > 14
+  {
+    constexpr const char *p = "123456789";
+    typedef std::reverse_iterator<const char *> RI;
+    constexpr RI it1 = std::make_reverse_iterator(p);
+    constexpr RI it2 = std::make_reverse_iterator(p + 5);
+    constexpr RI it3 = it1 - 5;
+    static_assert(it1 != it2, "");
+    static_assert(it1 != it3, "");
+    static_assert(it2 == it3, "");
+  }
+#endif
 }

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-=/difference_type.pass.cpp

 // reverse_iterator
 
 // requires RandomAccessIterator<Iter>
-//   reverse_iterator& operator-=(difference_type n);
+//   constexpr reverse_iterator& operator-=(difference_type n);
+//
+// constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s+10));
     test(s+5, 5, s+10);
+
+#if TEST_STD_VER > 14
+  {
+    constexpr const char *p = "123456789";
+    constexpr auto it1 = std::make_reverse_iterator(p+5);
+    constexpr auto it2 = std::make_reverse_iterator(p) -= 5;
+    static_assert(it1 == it2, "");
+  }
+#endif
 }

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op.star/op_star.pass.cpp

 
 // reverse_iterator
 
-// reference operator*() const;
+// constexpr reference operator*() const;
+//
+// constexpr in c++17
 
 // Be sure to respect LWG 198:
 //    http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#198

 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
+
 class A
 {
     int data_;

 {
     A a;
     test(&a+1, A());
+
+#if TEST_STD_VER > 14
+  {
+    constexpr const char *p = "123456789";
+    typedef std::reverse_iterator<const char *> RI;
+    constexpr RI it1 = std::make_reverse_iterator(p+1);
+    constexpr RI it2 = std::make_reverse_iterator(p+2);
+    static_assert(*it1 == p[0], "");
+    static_assert(*it2 == p[1], "");
+  }
+#endif
 }

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp

 
 // template <class U>
 //   requires HasAssign<Iter, const U&>
-//   reverse_iterator&
+//   constexpr reverse_iterator&
 //   operator=(const reverse_iterator<U>& u);
+//
+//   constexpr in c++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It, class U>

     test<bidirectional_iterator<Base*> >(bidirectional_iterator<Derived*>(&d));
     test<random_access_iterator<const Base*> >(random_access_iterator<Derived*>(&d));
     test<Base*>(&d);
+
+#if TEST_STD_VER > 14
+  {
+    constexpr const Derived *p = nullptr;
+    constexpr std::reverse_iterator<const Derived *>     it1 = std::make_reverse_iterator(p);
+    constexpr std::reverse_iterator<const Base *>        it2 = (std::make_reverse_iterator(p) = it1);
+        static_assert(it2.base() == p);
+  }
+#endif
 }

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp

 
 // template <BidirectionalIterator Iter1, BidirectionalIterator Iter2>
 //   requires HasEqualTo<Iter1, Iter2>
-//   bool
+//   constexpr bool
 //   operator==(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);
+//
+//   constexpr in c++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s+1), false);
     test(s, s, true);
     test(s, s+1, false);
+    
+#if TEST_STD_VER > 14
+  {
+    constexpr const char *p = "123456789";
+    typedef std::reverse_iterator<const char *> RI;
+    constexpr RI it1 = std::make_reverse_iterator(p);
+    constexpr RI it2 = std::make_reverse_iterator(p);
+    constexpr RI it3 = std::make_reverse_iterator(p+1);
+    static_assert( (it1 == it2), "");
+    static_assert(!(it1 == it3), "");
+  }
+#endif
+
 }

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp

 
 // template <RandomAccessIterator Iter1, RandomAccessIterator Iter2>
 //   requires HasMinus<Iter2, Iter1>
-//   auto operator-(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y)
+//   constexpr auto operator-(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y)
 //   -> decltype(y.base() - x.base());
+//
+// constexpr in c++17
 
 #include <iterator>
 #include <cstddef>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It1, class It2>

     test(s, s, 0);
     test(s, s+1, 1);
     test(s+1, s, -1);
+
+#if TEST_STD_VER > 14
+  {
+    constexpr const char *p = "123456789";
+    typedef std::reverse_iterator<const char *> RI;
+    constexpr RI it1 = std::make_reverse_iterator(p);
+    constexpr RI it2 = std::make_reverse_iterator(p+1);
+    static_assert( it1 - it2 ==  1, "");
+    static_assert( it2 - it1 == -1, "");
+  }
+#endif
 }

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp

 
 // template <RandomAccessIterator Iter1, RandomAccessIterator Iter2>
 //   requires HasGreater<Iter1, Iter2>
-//   bool
+//   constexpr bool
 //   operator>(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);
+//
+//   constexpr in c++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     test(s, s, false);
     test(s, s+1, true);
     test(s+1, s, false);
+
+#if TEST_STD_VER > 14
+  {
+    constexpr const char *p = "123456789";
+    typedef std::reverse_iterator<const char *> RI;
+    constexpr RI it1 = std::make_reverse_iterator(p);
+    constexpr RI it2 = std::make_reverse_iterator(p);
+    constexpr RI it3 = std::make_reverse_iterator(p+1);
+    static_assert(!(it1 > it2), "");
+    static_assert( (it1 > it3), "");
+  }
+#endif
 }

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp

 
 // template <RandomAccessIterator Iter1, RandomAccessIterator Iter2>
 //   requires HasGreater<Iter1, Iter2>
-//   bool
+//   constexpr bool
 //   operator>=(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);
+//
+//   constexpr in c++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     test(s, s, true);
     test(s, s+1, true);
     test(s+1, s, false);
+
+#if TEST_STD_VER > 14
+  {
+    constexpr const char *p = "123456789";
+    typedef std::reverse_iterator<const char *> RI;
+    constexpr RI it1 = std::make_reverse_iterator(p);
+    constexpr RI it2 = std::make_reverse_iterator(p);
+    constexpr RI it3 = std::make_reverse_iterator(p+1);
+    static_assert( (it1 >= it2), "");
+    static_assert( (it1 >= it3), "");
+  }
+#endif
 }

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp

 
 // template <RandomAccessIterator Iter1, RandomAccessIterator Iter2>
 //   requires HasGreater<Iter1, Iter2>
-//   bool
+//   constexpr bool
 //   operator<(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);
+//
+//   constexpr in c++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     test(s, s, false);
     test(s, s+1, false);
     test(s+1, s, true);
+
+#if TEST_STD_VER > 14
+  {
+    constexpr const char *p = "123456789";
+    typedef std::reverse_iterator<const char *> RI;
+    constexpr RI it1 = std::make_reverse_iterator(p);
+    constexpr RI it2 = std::make_reverse_iterator(p);
+    constexpr RI it3 = std::make_reverse_iterator(p+1);
+    static_assert(!(it1 < it2), "");
+    static_assert(!(it1 < it3), "");
+  }
+#endif
 }

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp

 
 // template <RandomAccessIterator Iter1, RandomAccessIterator Iter2>
 //   requires HasGreater<Iter1, Iter2>
-//   bool
+//   constexpr bool
 //   operator<=(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);
+//
+//   constexpr in c++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     test(s, s, true);
     test(s, s+1, false);
     test(s+1, s, true);
+
+#if TEST_STD_VER > 14
+  {
+    constexpr const char *p = "123456789";
+    typedef std::reverse_iterator<const char *> RI;
+    constexpr RI it1 = std::make_reverse_iterator(p);
+    constexpr RI it2 = std::make_reverse_iterator(p);
+    constexpr RI it3 = std::make_reverse_iterator(p+1);
+    static_assert( (it1 <= it2), "");
+    static_assert(!(it1 <= it3), "");
+  }
+#endif
 }

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opref/op_arrow.pass.cpp

 
 // reverse_iterator
 
-// pointer operator->() const;
+// constexpr pointer operator->() const;
+//
+// constexpr in C++17
 
 // Be sure to respect LWG 198:
 //    http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#198

 #include <list>
 #include <cassert>
 
+#include "test_macros.h"
+
 class A
 {
     int data_;

     B       *operator&()       { return nullptr; }
 };
 
+class C
+{
+    int data_;
+public:
+    TEST_CONSTEXPR C() : data_(1) {}
+
+    TEST_CONSTEXPR int get() const {return data_;}
+
+    friend TEST_CONSTEXPR bool operator==(const C& x, const C& y)
+        {return x.data_ == y.data_;}
+};
+
+TEST_CONSTEXPR  C gC;
+
 int main()
 {
     A a;

     assert ( ri == l.rend ());
     }
     }
+
+#if TEST_STD_VER > 14
+  {
+    typedef std::reverse_iterator<const C *> RI;
+    constexpr RI it1 = std::make_reverse_iterator(&gC+1);
+
+    static_assert(it1->get() == gC.get(), "");
+  }
+#endif
 }

test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opsum/difference_type.pass.cpp

 // reverse_iterator
 
 // template <RandomAccessIterator Iterator>
-//   reverse_iterator<Iter>
+//   constexpr reverse_iterator<Iter>
 //   operator+(Iter::difference_type n, const reverse_iterator<Iter>& x);
+//
+// constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s));
     test(s+5, 5, s);
+
+#if TEST_STD_VER > 14
+  {
+    constexpr const char *p = "123456789";
+    typedef std::reverse_iterator<const char *> RI;
+    constexpr RI it1 = std::make_reverse_iterator(p);
+    constexpr RI it2 = std::make_reverse_iterator(p + 5);
+    constexpr RI it3 = 5 + it2;
+    static_assert(it1 != it2, "");
+    static_assert(it1 == it3, "");
+    static_assert(it2 != it3, "");
+  }
+#endif
 }