[libc++] Implement `operator<=>` for `type_index`

[avogelsgesang]

Summary

Implements part of P1614R2 "The Mothership has Landed"

[avogelsgesang]

update review link

[avogelsgesang]

actually check results in test case

[Mordante]

LGTM modulo some nits. I think the CI failures are unrelated, but please update the review for a CI iteration.
I want to have a quick look after the update.

libcxx/include/typeindex

97

98

Please run clang-format on these changes.

libcxx/test/std/utilities/type.index/type.index.members/cmp.pass.cpp

49

We use snake-case in our tests.

[avogelsgesang]

libcxx/test/std/utilities/type.index/type.index.members/cmp.pass.cpp

49

only for variable names or also for function names?

[avogelsgesang]

address @Mordante's comments

[Mordante]

LGTM, thanks!

libcxx/test/std/utilities/type.index/type.index.members/cmp.pass.cpp

49

Both, but we're not always consistent ;-)

libcxx/docs/Status/SpaceshipProjects.csv

 | `[optional.nullops] <https://wg21.link/optional.nullops>`_
 | `[optional.comp.with.t] <https://wg21.link/optional.comp.with.t>`_","| optional
 | nullopt",None,Kent Ross,|In Progress|
 "| `[variant.relops] <https://wg21.link/variant.relops>`_
 | `[variant.monostate.relops] <https://wg21.link/variant.monostate.relops>`_","| `monostate <https://reviews.llvm.org/D131372>`_
 | `variant <https://reviews.llvm.org/D131372>`_",None,Kent Ross,|In Progress|
 | `[unique.ptr.special] <https://wg21.link/unique.ptr.special>`_,| `unique_ptr <https://reviews.llvm.org/D130838>`_,[comparisons.three.way],Adrian Vogelsgesang,|Complete|
 | `[util.smartptr.shared.cmp] <https://wg21.link/util.smartptr.shared.cmp>`_,| `shared_ptr <https://reviews.llvm.org/D130852>`_,[comparisons.three.way],Adrian Vogelsgesang,|Complete|
-| `[type.index.members] <https://wg21.link/type.index.members>`_,| `type_index <https://reviews.llvm.org/D131357>`_,None,Adrian Vogelsgesang,|In Progress|
+| `[type.index.members] <https://wg21.link/type.index.members>`_,| `type_index <https://reviews.llvm.org/D131357>`_,None,Adrian Vogelsgesang,|Complete|
 | `[charconv.syn] <https://wg21.link/charconv.syn>`_,| to_chars_result,None,Mark de Wever,|Complete|
 | `[charconv.syn] <https://wg21.link/charconv.syn>`_,| from_chars_result,None,Mark de Wever,|Complete|
 | `[stacktrace.entry.cmp] <https://wg21.link/stacktrace.entry.cmp>`_,| stacktrace_entry,None,Unassigned,|Not Started|
 | `[stacktrace.basic.cmp] <https://wg21.link/stacktrace.basic.cmp>`_,| basic_stacktrace,[alg.three.way],Unassigned,|Not Started|
 | `[string.cmp] <https://wg21.link/string.cmp>`_,| basic_string,None,Mark de Wever,|In Progress|
 | `[string.view.comparison] <https://wg21.link/string.view.comparison>`_,| `basic_string_view <https://reviews.llvm.org/D130295>`_,None,Mark de Wever,|Complete|
 | `[array.syn] <https://wg21.link/array.syn>`_ (`general <https://wg21.link/container.requirements.general#14>`_),| array,[expos.only.func],Unassigned,|Not Started|
 | `[deque.syn] <https://wg21.link/deque.syn>`_ (`general <https://wg21.link/container.requirements.general#14>`_),| deque,[expos.only.func],Unassigned,|Not Started|

libcxx/include/typeindex

 {
 
 class type_index
 {
 public:
     type_index(const type_info& rhs) noexcept;
 
     bool operator==(const type_index& rhs) const noexcept;
-    bool operator!=(const type_index& rhs) const noexcept;
+    bool operator!=(const type_index& rhs) const noexcept; // removed in C++20
     bool operator< (const type_index& rhs) const noexcept;
     bool operator<=(const type_index& rhs) const noexcept;
     bool operator> (const type_index& rhs) const noexcept;
     bool operator>=(const type_index& rhs) const noexcept;
+    strong_ordering operator<=>(const type_index& rhs) const noexcept; // C++20
 
     size_t hash_code() const noexcept;
     const char* name() const noexcept;
 };
 
 template <>
 struct hash<type_index>
     : public unary_function<type_index, size_t>

 public:
     _LIBCPP_INLINE_VISIBILITY
     type_index(const type_info& __y) _NOEXCEPT : __t_(&__y) {}
 
     _LIBCPP_INLINE_VISIBILITY
     bool operator==(const type_index& __y) const _NOEXCEPT
         {return *__t_ == *__y.__t_;}
     _LIBCPP_INLINE_VISIBILITY
+#if _LIBCPP_STD_VER <= 17
     bool operator!=(const type_index& __y) const _NOEXCEPT
         {return *__t_ != *__y.__t_;}
+#endif
     _LIBCPP_INLINE_VISIBILITY
     bool operator< (const type_index& __y) const _NOEXCEPT
         {return  __t_->before(*__y.__t_);}
     _LIBCPP_INLINE_VISIBILITY
     bool operator<=(const type_index& __y) const _NOEXCEPT
         {return !__y.__t_->before(*__t_);}
     _LIBCPP_INLINE_VISIBILITY
     bool operator> (const type_index& __y) const _NOEXCEPT
         {return  __y.__t_->before(*__t_);}
     _LIBCPP_INLINE_VISIBILITY
     bool operator>=(const type_index& __y) const _NOEXCEPT
         {return !__t_->before(*__y.__t_);}
+#if _LIBCPP_STD_VER > 17
+    _LIBCPP_HIDE_FROM_ABI
+    strong_ordering operator<=>(const type_index& __y) const noexcept {
+      if (*__t_ == *__y.__t_)
+        return strong_ordering::equal;
+      if (__t_->before(*__y.__t_))
+        return strong_ordering::less;
+      return strong_ordering::greater;
+    }
+#endif
 
     _LIBCPP_INLINE_VISIBILITY
     size_t hash_code() const _NOEXCEPT {return __t_->hash_code();}
     _LIBCPP_INLINE_VISIBILITY
     const char* name() const _NOEXCEPT {return __t_->name();}
 };
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS hash;

libcxx/test/std/utilities/type.index/type.index.members/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
+//
+//===----------------------------------------------------------------------===//
+
+// <typeindex>
+
+// class type_index
+
+// bool operator==(const type_index& rhs) const noexcept;
+// bool operator!=(const type_index& rhs) const noexcept;
+// bool operator< (const type_index& rhs) const noexcept;
+// bool operator<=(const type_index& rhs) const noexcept;
+// bool operator> (const type_index& rhs) const noexcept;
+// bool operator>=(const type_index& rhs) const noexcept;
+// strong_ordering operator<=>(const type_index& rhs) const noexcept;
+
+// UNSUPPORTED: no-rtti
+
+#include <typeindex>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_comparisons.h"
+
+int main(int, char**) {
+  AssertComparisonsAreNoexcept<std::type_index>();
+  AssertComparisonsReturnBool<std::type_index>();
+#if TEST_STD_VER > 17
+  AssertOrderAreNoexcept<std::type_index>();
+  AssertOrderReturn<std::strong_ordering, std::type_index>();
+#endif
+
+  std::type_index t1 = typeid(int);
+  std::type_index t2 = typeid(int);
+  std::type_index t3 = typeid(long);
+
+  // Test `t1` and `t2` which should compare equal
+  assert(testComparisons(t1, t2, /*isEqual*/ true, /*isLess*/ false));
+#if TEST_STD_VER > 17
+  assert(testOrder(t1, t2, std::strong_ordering::equal));
+#endif
+
+  // Test `t1` and `t3` which are not equal
+  bool is_less = t1 < t3;
+  assert(testComparisons(t1, t3, /*isEqual*/ false, is_less));
+#if TEST_STD_VER > 17
+  assert(testOrder(t1, t3, is_less ? std::strong_ordering::less : std::strong_ordering::greater));
+#endif
+
+  return 0;
+}

libcxx/test/std/utilities/type.index/type.index.members/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
-//
-//===----------------------------------------------------------------------===//
-
-// <typeindex>
-
-// class type_index
-
-// bool operator==(const type_index& rhs) const;
-// bool operator!=(const type_index& rhs) const;
-
-// UNSUPPORTED: no-rtti
-
-#include <typeindex>
-#include <cassert>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    std::type_index t1 = typeid(int);
-    std::type_index t2 = typeid(int);
-    std::type_index t3 = typeid(long);
-    assert(t1 == t2);
-    assert(t1 != t3);
-
-  return 0;
-}

libcxx/test/std/utilities/type.index/type.index.members/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
-//
-//===----------------------------------------------------------------------===//
-
-// <typeindex>
-
-// class type_index
-
-// bool operator< (const type_index& rhs) const;
-// bool operator<=(const type_index& rhs) const;
-// bool operator> (const type_index& rhs) const;
-// bool operator>=(const type_index& rhs) const;
-
-// UNSUPPORTED: no-rtti
-
-#include <typeindex>
-#include <cassert>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    std::type_index t1 = typeid(int);
-    std::type_index t2 = typeid(int);
-    std::type_index t3 = typeid(long);
-    assert(!(t1 <  t2));
-    assert( (t1 <= t2));
-    assert(!(t1 >  t2));
-    assert( (t1 >= t2));
-    if (t1 < t3)
-    {
-        assert( (t1 <  t3));
-        assert( (t1 <= t3));
-        assert(!(t1 >  t3));
-        assert(!(t1 >= t3));
-    }
-    else
-    {
-        assert(!(t1 <  t3));
-        assert(!(t1 <= t3));
-        assert( (t1 >  t3));
-        assert( (t1 >= t3));
-    }
-
-  return 0;
-}