[libc++] Implement `operator<=> for `thread::id`

[avogelsgesang]

Summary

The new operator<=> is mapped onto the existing functions
__libcpp_thread_id_equal and __libcpp_thread_id_less. Introducing a
new __libcpp_thread_id_compare_three_way might lead to more efficient
code. Given that we can still introduce __libcpp_thread_id_compare_three_way
later, for this commit I opted to not break ABI. If requested, I will
add __libcpp_thread_id_compare_three_way in a follow-up commit.

Implements part of P1614R2 "The Mothership has Landed"

[avogelsgesang]

update review link

[avogelsgesang]

actually check the results in the test case

[avogelsgesang]

need to fix CI

[avogelsgesang]

correct synopsis

[avogelsgesang]

fix clang-tidy

[Mordante]

libcxx/include/__threading_support

614

Note when implementing this according to P1614 we don't need to expose this function.

626

I read your reasoning about why you did it, but I think we should fix it. There's already a bug report regarding this issue.
https://github.com/llvm/llvm-project/issues/56187

626

For new code please use _LIBCPP_HIDE_FROM_ABI instead, both do the same but this name is the new name.

629

Please use clang-format on the new code.

[avogelsgesang]

libcxx/include/__threading_support

626

Do you want me to turn the friends into non-friends as part of this commit or should I use a separate commit for this?

[Mordante]

libcxx/include/__threading_support

626

I prefer a separate commit for the unfriending, but I like to do the spaceship operator the proper way.
Feel free to assign the bug to yourself I haven't started it; I mainly self-assigned since I intended to work on the spaceship operators. But I have enough other things on my todo list.

[avogelsgesang]

I first need to fix https://github.com/llvm/llvm-project/issues/56187 and will come back to this patch afterwards

libcxx/include/__threading_support

626

ok, I will fix this bug in a separate commit, then, and come back to this change here after fixing it

[avogelsgesang]

rebase on D131430 and implement operator<=> as free function

[avogelsgesang]

one more _LIBCPP_HIDE_FROM_ABI

[avogelsgesang]

rebase on D131430

[Mordante]

LGTM!

libcxx/docs/Status/SpaceshipProjects.csv

 | `[time.zone.leap.nonmembers] <https://wg21.link/time.zone.leap.nonmembers>`_
 | `[time.zone.link.nonmembers] <https://wg21.link/time.zone.link.nonmembers>`_","| chrono::time_zone
 | chrono::leap_second
 | chrono::time_zone_link",A ``<chrono>`` implementation,Unassigned,|Not Started|
 | `[fs.filesystem.syn] <https://wg21.link/fs.filesystem.syn>`_,| `filesystem::space_info <https://reviews.llvm.org/D130861>`_,None,Adrian Vogelsgesang,|Complete|
 | `[fs.path.nonmember] <https://wg21.link/fs.path.nonmember>`_,| `filesystem::path <https://reviews.llvm.org/D130859>`_,None,Adrian Vogelsgesang,|In Progress|
 | `[fs.dir.entry.obs] <https://wg21.link/fs.dir.entry.obs>`_,| `filesystem::directory_entry <https://reviews.llvm.org/D130860>`_,None,Adrian Vogelsgesang,|In Progress|
 | `[re.submatch.op] <https://wg21.link/re.submatch.op>`_,| sub_match,None,Mark de Wever,|In Progress|
-| `[thread.thread.id] <https://wg21.link/thread.thread.id>`_,| `thread::id <https://reviews.llvm.org/D131362>`_,None,Adrian Vogelsgesang,|In Progress|
+| `[thread.thread.id] <https://wg21.link/thread.thread.id>`_,| `thread::id <https://reviews.llvm.org/D131362>`_,None,Adrian Vogelsgesang,|Complete|

libcxx/include/__threading_support

 // -*- 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___THREADING_SUPPORT
 #define _LIBCPP___THREADING_SUPPORT
 
 #include <__availability>
 #include <__chrono/convert_to_timespec.h>
 #include <__chrono/duration.h>
+#include <__compare/ordering.h>
 #include <__config>
 #include <__thread/poll_with_backoff.h>
 #include <errno.h>
 #include <iosfwd>
 #include <limits>
 
 #ifdef __MVS__
 # include <__support/ibm/nanosleep.h>

 
 class _LIBCPP_TEMPLATE_VIS __thread_id
 {
     // FIXME: pthread_t is a pointer on Darwin but a long on Linux.
     // NULL is the no-thread value on Darwin.  Someone needs to check
     // on other platforms.  We assume 0 works everywhere for now.
     __libcpp_thread_id __id_;
 
+    static _LIBCPP_HIDE_FROM_ABI
+        bool __lt_impl(__thread_id __x, __thread_id __y) _NOEXCEPT
+        { // id==0 is always less than any other thread_id
+        if (__x.__id_ == 0) return __y.__id_ != 0;
+        if (__y.__id_ == 0) return false;
+        return  __libcpp_thread_id_less(__x.__id_, __y.__id_);
+        }
+
 public:
     _LIBCPP_INLINE_VISIBILITY
     __thread_id() _NOEXCEPT : __id_(0) {}
 
     _LIBCPP_INLINE_VISIBILITY
     void __reset() { __id_ = 0; }
 
     friend _LIBCPP_HIDE_FROM_ABI bool operator==(__thread_id __x, __thread_id __y) _NOEXCEPT;
-    friend _LIBCPP_HIDE_FROM_ABI bool operator< (__thread_id __x, __thread_id __y) _NOEXCEPT;
+#if _LIBCPP_STD_VER <= 17
+    friend _LIBCPP_HIDE_FROM_ABI bool operator<(__thread_id __x, __thread_id __y) _NOEXCEPT;
+#else // _LIBCPP_STD_VER <= 17
+    friend _LIBCPP_HIDE_FROM_ABI strong_ordering operator<=>(__thread_id __x, __thread_id __y) noexcept;
+#endif // _LIBCPP_STD_VER <= 17
 
     template<class _CharT, class _Traits>
     friend
     _LIBCPP_INLINE_VISIBILITY
     basic_ostream<_CharT, _Traits>&
     operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id);
 
 private:
bool operator==(__thread_id __x, __thread_id __y) _NOEXCEPT {
   // Don't pass id==0 to underlying routines
   if (__x.__id_ == 0)
     return __y.__id_ == 0;
   if (__y.__id_ == 0)
     return false;
   return __libcpp_thread_id_equal(__x.__id_, __y.__id_);
 }
 
+#if _LIBCPP_STD_VER <= 17
+
 inline _LIBCPP_HIDE_FROM_ABI
 bool operator!=(__thread_id __x, __thread_id __y) _NOEXCEPT {
-    return !(__x == __y);
 }
 
 inline _LIBCPP_HIDE_FROM_ABI
 bool operator<(__thread_id __x, __thread_id __y) _NOEXCEPT {
-  // id==0 is always less than any other thread_id
-  if (__x.__id_ == 0)
-    return __y.__id_ != 0;
-  if (__y.__id_ == 0)
-    return false;
-  return __libcpp_thread_id_less(__x.__id_, __y.__id_);
+  return __thread_id::__lt_impl(__x.__id_, __y.__id_);
 }
 
 inline _LIBCPP_HIDE_FROM_ABI bool operator<=(__thread_id __x, __thread_id __y) _NOEXCEPT { return !(__y < __x); }
 inline _LIBCPP_HIDE_FROM_ABI bool operator>(__thread_id __x, __thread_id __y) _NOEXCEPT { return __y < __x; }
 inline _LIBCPP_HIDE_FROM_ABI bool operator>=(__thread_id __x, __thread_id __y) _NOEXCEPT { return !(__x < __y); }
 
+#else // _LIBCPP_STD_VER <= 17
+
+inline _LIBCPP_HIDE_FROM_ABI
+strong_ordering operator<=>(__thread_id __x, __thread_id __y) noexcept {
+  if (__x == __y)
+    return strong_ordering::equal;
+  if (__thread_id::__lt_impl(__x, __y))
+    return strong_ordering::less;
+  return strong_ordering::greater;
+}
+
+#endif // _LIBCPP_STD_VER <= 17
+
 namespace this_thread
 {
 
 inline _LIBCPP_INLINE_VISIBILITY
 __thread_id
 get_id() _NOEXCEPT
 {
     return __libcpp_thread_get_current_id();

libcxx/include/thread

 
 class thread::id
 {
 public:
     id() noexcept;
 };
 
 bool operator==(thread::id x, thread::id y) noexcept;
-bool operator!=(thread::id x, thread::id y) noexcept;
-bool operator< (thread::id x, thread::id y) noexcept;
-bool operator<=(thread::id x, thread::id y) noexcept;
-bool operator> (thread::id x, thread::id y) noexcept;
-bool operator>=(thread::id x, thread::id y) noexcept;
+bool operator!=(thread::id x, thread::id y) noexcept;             // removed in C++20
+bool operator< (thread::id x, thread::id y) noexcept;             // removed in C++20
+bool operator<=(thread::id x, thread::id y) noexcept;             // removed in C++20
+bool operator> (thread::id x, thread::id y) noexcept;             // removed in C++20
+bool operator>=(thread::id x, thread::id y) noexcept;             // removed in C++20
+strong_ordering operator<=>(thread::id x, thread::id y) noexcept; // C++20
 
 template<class charT, class traits>
 basic_ostream<charT, traits>&
 operator<<(basic_ostream<charT, traits>& out, thread::id id);
 
 namespace this_thread
 {
 

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/cmp.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: no-threads
+
+// <thread>
+
+// class thread::id
+
+// bool operator==(thread::id x, thread::id y) noexcept;
+// bool operator!=(thread::id x, thread::id y) noexcept;
+// bool operator< (thread::id x, thread::id y) noexcept;
+// bool operator<=(thread::id x, thread::id y) noexcept;
+// bool operator> (thread::id x, thread::id y) noexcept;
+// bool operator>=(thread::id x, thread::id y) noexcept;
+// strong_ordering operator<=>(thread::id x, thread::id y) noexcept;
+
+#include <thread>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_comparisons.h"
+
+int main(int, char**) {
+  AssertComparisonsAreNoexcept<std::thread::id>();
+  AssertComparisonsReturnBool<std::thread::id>();
+#if TEST_STD_VER > 17
+  AssertOrderAreNoexcept<std::thread::id>();
+  AssertOrderReturn<std::strong_ordering, std::thread::id>();
+#endif
+
+  std::thread::id id1;
+  std::thread::id id2;
+  std::thread::id id3 = std::this_thread::get_id();
+
+  // `id1` and `id2` should compare equal
+  assert(testComparisons(id1, id2, /*isEqual*/ true, /*isLess*/ false));
+#if TEST_STD_VER > 17
+  assert(testOrder(id1, id2, std::strong_ordering::equal));
+#endif
+
+  // Test `t1` and `t3` which are not equal
+  bool isLess = id1 < id3;
+  assert(testComparisons(id1, id3, /*isEqual*/ false, isLess));
+#if TEST_STD_VER > 17
+  assert(testOrder(id1, id3, isLess ? std::strong_ordering::less : std::strong_ordering::greater));
+#endif
+
+  // Regression tests for https://github.com/llvm/llvm-project/issues/56187
+  // libc++ previously declared the comparison operators as hidden friends
+  // which was non-conforming.
+  assert(std::operator==(id1, id2));
+#if TEST_STD_VER <= 17
+  assert(!std::operator!=(id1, id2));
+  assert(!std::operator<(id1, id2));
+  assert(std::operator<=(id1, id2));
+  assert(!std::operator>(id1, id2));
+  assert(std::operator>=(id1, id2));
+#else
+  assert(std::operator<=>(id1, id2) == std::strong_ordering::equal);
+#endif
+
+  return 0;
+}

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/eq.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: no-threads
-
-// <thread>
-
-// class thread::id
-
-// bool operator==(thread::id x, thread::id y);
-// bool operator!=(thread::id x, thread::id y);
-
-#include <thread>
-#include <cassert>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    std::thread::id id0;
-    std::thread::id id1;
-    id1 = id0;
-    assert( (id1 == id0));
-    assert(!(id1 != id0));
-    id1 = std::this_thread::get_id();
-    assert(!(id1 == id0));
-    assert( (id1 != id0));
-
-    // Regression tests for https://github.com/llvm/llvm-project/issues/56187
-    // libc++ previously declared the comparison operators as hidden friends
-    // which was non-conforming.
-    assert(!std::operator==(id1, id0));
-    assert(std::operator!=(id1, id0));
-
-    return 0;
-}

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/lt.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: no-threads
-
-// <thread>
-
-// class thread::id
-
-// bool operator< (thread::id x, thread::id y);
-// bool operator<=(thread::id x, thread::id y);
-// bool operator> (thread::id x, thread::id y);
-// bool operator>=(thread::id x, thread::id y);
-
-#include <thread>
-#include <cassert>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    std::thread::id id0;
-    std::thread::id id1;
-    std::thread::id id2 = std::this_thread::get_id();
-    assert(!(id0 <  id1));
-    assert( (id0 <= id1));
-    assert(!(id0 >  id1));
-    assert( (id0 >= id1));
-    assert(!(id0 == id2));
-    if (id0 < id2) {
-      assert( (id0 <= id2));
-      assert(!(id0 >  id2));
-      assert(!(id0 >= id2));
-    } else {
-      assert(!(id0 <= id2));
-      assert( (id0 >  id2));
-      assert( (id0 >= id2));
-    }
-
-    // Regression tests for https://github.com/llvm/llvm-project/issues/56187
-    // libc++ previously declared the comparison operators as hidden friends
-    // which was non-conforming.
-    assert(!std::operator<(id0, id1));
-    assert(std::operator<=(id0, id1));
-    assert(!std::operator>(id0, id1));
-    assert(std::operator>=(id0, id1));
-
-    return 0;
-}