[libc++][regex] Removes operator!=.

[Mordante]

Summary

Implements part of:

• P1614R2 The Mothership has Landed

[H-G-Hristov]

LGTM (for the record)
Thank you!

[H-G-Hristov]

It looks like these operator== are not implemented but I cannot find when they were added to the standard:
bool operator==(default_sentinel_t) const { return *this == regex_iterator(); }
bool operator==(default_sentinel_t) const { return *this == regex_token_iterator(); }

[Mordante]

In D153222#4431276, @H-G-Hristov wrote:

It looks like these operator== are not implemented but I cannot find when they were added to the standard:
bool operator==(default_sentinel_t) const { return *this == regex_iterator(); }
bool operator==(default_sentinel_t) const { return *this == regex_token_iterator(); }

Git blame tells me this is the resolution of https://cplusplus.github.io/LWG/issue3719

libcxx/docs/Status/SpaceshipProjects.csv

 - `5.14 Clause 29: Input/output library <https://wg21.link/p1614r2#clause-29-inputoutput-library>`_,,,,
 | `[fs.filesystem.syn] <https://wg21.link/fs.filesystem.syn>`_,| `filesystem::space_info <https://reviews.llvm.org/D130861>`_,None,Adrian Vogelsgesang,|Complete|
 "| `[fs.class.path] <https://wg21.link/fs.class.path>`_
 | `[fs.path.nonmember] <https://wg21.link/fs.path.nonmember>`_",| `filesystem::path <https://reviews.llvm.org/D130859>`_,None,Adrian Vogelsgesang,|Complete|
 | `[fs.class.file.status] <https://wg21.link/fs.class.file.status>`_,| `file_status <https://reviews.llvm.org/D152647>`_,None,Hristo Hristov,|Complete|
 "| `[fs.class.directory.entry] <https://wg21.link/fs.class.directory.entry>`_
 | `[fs.dir.entry.obs] <https://wg21.link/fs.dir.entry.obs>`_",| `filesystem::directory_entry <https://reviews.llvm.org/D130860>`_,None,Adrian Vogelsgesang,|Complete|
 - `5.15 Clause 30: Regular expressions library <https://wg21.link/p1614r2#clause-30-regular-expressions-library>`_,,,,
-| `[re.syn] <https://wg21.link/re.syn>`_,|,None,Mark de Wever,|In Progress|
+| `[re.syn] <https://wg21.link/re.syn>`_,|,None,Mark de Wever,|Complete|
 | `[re.submatch.op] <https://wg21.link/re.submatch.op>`_,| `sub_match <https://reviews.llvm.org/D132310>`_,None,Mark de Wever,|Complete|
-| `[re.results.nonmember] <https://wg21.link/re.results.nonmember>`_,| remove ops `match_results`,None,Mark de Wever,|In Progress|
+| `[re.results.nonmember] <https://wg21.link/re.results.nonmember>`_,| remove ops `match_results`,None,Mark de Wever,|Complete|
 "| `[re.regiter] <https://wg21.link/re.regiter>`_,
-| `[re.regiter.comp] <https://wg21.link/re.regiter.comp>`_",| remove ops `regex_iterator`,None,Mark de Wever,|In Progress|
+| `[re.regiter.comp] <https://wg21.link/re.regiter.comp>`_",| remove ops `regex_iterator`,None,Mark de Wever,|Complete|
 "| `[re.tokiter] <https://wg21.link/re.tokiter>`_
-| `[re.tokiter.comp] <https://wg21.link/re.tokiter.comp>`_",| remove ops `regex_token_iterator`,None,Mark de Wever,|In Progress|
+| `[re.tokiter.comp] <https://wg21.link/re.tokiter.comp>`_",| remove ops `regex_token_iterator`,None,Mark de Wever,|Complete|
 - `5.16 Clause 31: Atomic operations library <https://wg21.link/p1614r2#clause-31-atomic-operations-library>`_,,,,
 - `5.17 Clause 32: Thread support library <https://wg21.link/p1614r2#clause-32-thread-support-library>`_,,,,
 | `[thread.thread.id] <https://wg21.link/thread.thread.id>`_,| `thread::id <https://reviews.llvm.org/D131362>`_,None,Adrian Vogelsgesang,|Complete|
 Misc (Not part of R1614),,,,
 | `[range.elements.iterator] <https://wg21.link/range.elements.iterator>`_,| `ranges::elements_view::iterator <https://reviews.llvm.org/D136268>`_,[concepts.cmp],Hui Xie,|Complete|
 | `[stacktrace.entry.cmp] <https://wg21.link/stacktrace.entry.cmp>`_,| `stacktrace_entry <https://reviews.llvm.org/D123228>`_,None,Nikolas Klauser,|In Progress|
 | `[stacktrace.basic.cmp] <https://wg21.link/stacktrace.basic.cmp>`_,| `basic_stacktrace <https://reviews.llvm.org/D123228>`_,[alg.three.way],Nikolas Klauser,|In Progress|

libcxx/include/regex

 typedef match_results<string::const_iterator>  smatch;
 typedef match_results<wstring::const_iterator> wsmatch;
 
 template <class BidirectionalIterator, class Allocator>
     bool
     operator==(const match_results<BidirectionalIterator, Allocator>& m1,
                const match_results<BidirectionalIterator, Allocator>& m2);
 
-template <class BidirectionalIterator, class Allocator>
+template <class BidirectionalIterator, class Allocator>                    // Removed in C++20
     bool
     operator!=(const match_results<BidirectionalIterator, Allocator>& m1,
                const match_results<BidirectionalIterator, Allocator>& m2);
 
 template <class BidirectionalIterator, class Allocator>
     void
     swap(match_results<BidirectionalIterator, Allocator>& m1,
          match_results<BidirectionalIterator, Allocator>& m2);
public:
     regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
                    const regex_type&& re,
                    regex_constants::match_flag_type m
                                      = regex_constants::match_default) = delete; // C++14
     regex_iterator(const regex_iterator&);
     regex_iterator& operator=(const regex_iterator&);
 
     bool operator==(const regex_iterator&) const;
-    bool operator!=(const regex_iterator&) const;
+    bool operator!=(const regex_iterator&) const;                                // Removed in C++20
 
     const value_type& operator*() const;
     const value_type* operator->() const;
 
     regex_iterator& operator++();
     regex_iterator operator++(int);
 };
 
public:
     template <size_t N>
         regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
                              const regex_type&& re, const int (&submatches)[N],
                              regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14
     regex_token_iterator(const regex_token_iterator&);
     regex_token_iterator& operator=(const regex_token_iterator&);
 
     bool operator==(const regex_token_iterator&) const;
-    bool operator!=(const regex_token_iterator&) const;
+    bool operator!=(const regex_token_iterator&) const;                  // Removed in C++20
 
     const value_type& operator*() const;
     const value_type* operator->() const;
 
     regex_token_iterator& operator++();
     regex_token_iterator operator++(int);
 };
 
if (__x.__ready_ != __y.__ready_)
         return false;
     if (!__x.__ready_)
         return true;
     return __x.__matches_ == __y.__matches_ &&
            __x.__prefix_ == __y.__prefix_ &&
            __x.__suffix_ == __y.__suffix_;
 }
 
+#if _LIBCPP_STD_VER < 20
 template <class _BidirectionalIterator, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const match_results<_BidirectionalIterator, _Allocator>& __x,
            const match_results<_BidirectionalIterator, _Allocator>& __y)
 {
     return !(__x == __y);
 }
+#endif
 
 template <class _BidirectionalIterator, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(match_results<_BidirectionalIterator, _Allocator>& __x,
      match_results<_BidirectionalIterator, _Allocator>& __y)
 {
     __x.swap(__y);

 #if _LIBCPP_STD_VER >= 14
     regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
                    const regex_type&& __re,
                    regex_constants::match_flag_type __m
                                      = regex_constants::match_default) = delete;
 #endif
 
     bool operator==(const regex_iterator& __x) const;
+#if _LIBCPP_STD_VER < 20
     _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const regex_iterator& __x) const {return !(*this == __x);}
+#endif
 
     _LIBCPP_INLINE_VISIBILITY
     reference operator*() const {return  __match_;}
     _LIBCPP_INLINE_VISIBILITY
     pointer operator->() const  {return _VSTD::addressof(__match_);}
 
     regex_iterator& operator++();
     _LIBCPP_INLINE_VISIBILITY
template <size_t _Np>
                                       regex_constants::match_default) = delete;
 #endif
 
     regex_token_iterator(const regex_token_iterator&);
     regex_token_iterator& operator=(const regex_token_iterator&);
 
     bool operator==(const regex_token_iterator& __x) const;
     _LIBCPP_INLINE_VISIBILITY
+#if _LIBCPP_STD_VER < 20
     bool operator!=(const regex_token_iterator& __x) const {return !(*this == __x);}
+#endif
 
     _LIBCPP_INLINE_VISIBILITY
     const value_type& operator*() const {return *__result_;}
     _LIBCPP_INLINE_VISIBILITY
     const value_type* operator->() const {return __result_;}
 
     regex_token_iterator& operator++();
     _LIBCPP_INLINE_VISIBILITY

libcxx/modules/std/regex.cppm

 #  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
   using std::wcsub_match;
   using std::wssub_match;
 #  endif
 
   // [re.submatch.op], sub_match non-member operators
   using std::operator==;
   using std::operator<=>;
-#  if 1 // P1614
-  using std::operator!=;
-#  endif
 
   using std::operator<<;
 
   // [re.results], class template match_results
   using std::match_results;
 
   using std::cmatch;
   using std::smatch;

libcxx/test/std/re/re.iter/re.regiter/re.regiter.comp/tested_elsewhere.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
 //
 //===----------------------------------------------------------------------===//
 
 // <regex>
 
 // class regex_iterator<BidirectionalIterator, charT, traits>
 
 // bool operator==(const regex_iterator& right) const;
-// bool operator!=(const regex_iterator& right) const;
+// bool operator!=(const regex_iterator& right) const; // generated by the compiler in C++20
 
 int main(int, char**)
 {
 
   return 0;
 }

libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.comp/equal.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
 //
 //===----------------------------------------------------------------------===//
 
 // <regex>
 
 // class regex_token_iterator<BidirectionalIterator, charT, traits>
 
 // bool operator==(const regex_token_iterator& right) const;
-// bool operator!=(const regex_token_iterator& right) const;
+// bool operator!=(const regex_token_iterator& right) const; // generated by the compiler in C++20
 
 #include <regex>
 #include <cassert>
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {

libcxx/test/std/re/re.results/re.results.nonmember/equal.pass.cpp

 
 // class match_results<BidirectionalIterator, Allocator>
 
 // template <class BidirectionalIterator, class Allocator>
 //    bool
 //    operator==(const match_results<BidirectionalIterator, Allocator>& m1,
 //               const match_results<BidirectionalIterator, Allocator>& m2);
 
-// template <class BidirectionalIterator, class Allocator>
+// template <class BidirectionalIterator, class Allocator> // generated by the compiler in C++20
 //    bool
 //    operator!=(const match_results<BidirectionalIterator, Allocator>& m1,
 //               const match_results<BidirectionalIterator, Allocator>& m2);
 
 #include <regex>
 #include <cassert>
 #include "test_macros.h"