[libcxx] removes `weak_equality` and `strong_equality` from <compare>

[cjdb]

Summary

weak_equality and strong_equality were removed before being
standardised, and need to be removed.

Also adjusts common_comparison_category since its test needed
adjusting due to the equality deletions.

[• Quuxplusone]

Please compare to D74186. (@BRevzin @EricWF maybe D74186 should have landed by now?)
If this diff is byte-for-byte identical to D74186, then ship it! 😛

[cjdb]

rebases to activate CI

[• Quuxplusone]

I downloaded the raw diffs for D74186 and D100283, applied them in separate git branches, and then did git diff barry chris to find the places they differed.
The diff is here, if you want to check my work and see if I missed anything: https://pastebin.com/XcAS19dU

libcxx/include/compare

25–26

Instead of deleting these lines, change weak_equality to partial_ordering.
I think this was probably a cut-and-paste error in the original? Anyway, is_eq(partial_ordering) still exists and should be synopsized here.

423

Please leave this comment line here.

518–519

Remove _WeakEq and _StrongEq.

544–545

Remove _WeakEq and _StrongEq.

559

You still need the (_Cat == _None) case here: if any of the elements are noncomparable then the result of this function must be void(), not strong_ordering::equivalent.
(At first I was worried that we had no tests for this; but I see below we do have tests. Don't remove those tests.)
https://eel.is/c++draft/cmp.common#2

libcxx/test/std/language.support/cmp/cmp.common/common_comparison_category.pass.cpp

43–51

You cannot remove these tests. They need to keep passing in C++20.
https://eel.is/c++draft/cmp.common#2

[cjdb]

applies @Quuxplusone's feedback

[cjdb]

removes zero-width code points

[cjdb]

removes another 0WCP

[cjdb]

In D100283#2732476, @Quuxplusone wrote:

I downloaded the raw diffs for D74186 and D100283, applied them in separate git branches, and then did git diff barry chris to find the places they differed.
The diff is here, if you want to check my work and see if I missed anything: https://pastebin.com/XcAS19dU

Thanks! I assumed D74186 would take priority (but needed this to be open since D74186 is old and downstream patches depend on this one).

[cjdb]

rebases to activate CI

libcxx/include/compare

 #ifndef _LIBCPP_COMPARE
 #define _LIBCPP_COMPARE
 
 /*
     compare synopsis
 
 namespace std {
   // [cmp.categories], comparison category types
-  class weak_equality;
-  class strong_equality;
   class partial_ordering;
   class weak_ordering;
   class strong_ordering;
 
   // named comparison functions
-  constexpr bool is_eq  (weak_equality cmp) noexcept    { return cmp == 0; }
-  constexpr bool is_neq (weak_equality cmp) noexcept    { return cmp != 0; }
+  constexpr bool is_eq  (partial_ordering cmp) noexcept    { return cmp == 0; }
+  constexpr bool is_neq (partial_ordering cmp) noexcept    { return cmp != 0; }
   constexpr bool is_lt  (partial_ordering cmp) noexcept { return cmp < 0; }
   constexpr bool is_lteq(partial_ordering cmp) noexcept { return cmp <= 0; }
   constexpr bool is_gt  (partial_ordering cmp) noexcept { return cmp > 0; }
   constexpr bool is_gteq(partial_ordering cmp) noexcept { return cmp >= 0; }
 
   // [cmp.common], common comparison category type
   template<class... Ts>
   struct common_comparison_category {
     using type = see below;
   };
   template<class... Ts>
     using common_comparison_category_t = typename common_comparison_category<Ts...>::type;
 
   // [cmp.alg], comparison algorithms
   template<class T> constexpr strong_ordering strong_order(const T& a, const T& b);
   template<class T> constexpr weak_ordering weak_order(const T& a, const T& b);
   template<class T> constexpr partial_ordering partial_order(const T& a, const T& b);
-  template<class T> constexpr strong_equality strong_equal(const T& a, const T& b);
-  template<class T> constexpr weak_equality weak_equal(const T& a, const T& b);
 
   // [cmp.partialord], Class partial_ordering
   class partial_ordering {
   public:
     // valid values
     static const partial_ordering less;
     static const partial_ordering equivalent;
     static const partial_ordering greater;

 struct _CmpUnspecifiedParam {
   _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEVAL
   _CmpUnspecifiedParam(int _CmpUnspecifiedParam::*) noexcept {}
 
   template<typename _Tp, typename = _VSTD::enable_if_t<!_VSTD::is_same_v<_Tp, int>>>
   _CmpUnspecifiedParam(_Tp) = delete;
 };
 
-class  weak_equality {
-  _LIBCPP_INLINE_VISIBILITY
-  constexpr explicit weak_equality(_EqResult __val) noexcept : __value_(__val) {}
-
-public:
-  static const weak_equality equivalent;
-  static const weak_equality nonequivalent;
-
-  _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(weak_equality __v, _CmpUnspecifiedParam) noexcept;
-  _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(_CmpUnspecifiedParam, weak_equality __v) noexcept;
-  _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(weak_equality __v, _CmpUnspecifiedParam) noexcept;
-  _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(_CmpUnspecifiedParam, weak_equality __v) noexcept;
-
-#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
-  _LIBCPP_INLINE_VISIBILITY friend constexpr weak_equality operator<=>(weak_equality __v, _CmpUnspecifiedParam) noexcept;
-  _LIBCPP_INLINE_VISIBILITY friend constexpr weak_equality operator<=>(_CmpUnspecifiedParam, weak_equality __v) noexcept;
-#endif
-
-private:
-  _EqResult __value_;
-};
-
-_LIBCPP_INLINE_VAR constexpr weak_equality weak_equality::equivalent(_EqResult::__equiv);
-_LIBCPP_INLINE_VAR constexpr weak_equality weak_equality::nonequivalent(_EqResult::__nonequiv);
-
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr bool operator==(weak_equality __v, _CmpUnspecifiedParam) noexcept {
-  return __v.__value_ == _EqResult::__zero;
-}
-
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr bool operator==(_CmpUnspecifiedParam, weak_equality __v) noexcept {
-  return __v.__value_ == _EqResult::__zero;
-}
-
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr bool operator!=(weak_equality __v, _CmpUnspecifiedParam) noexcept {
-  return __v.__value_ != _EqResult::__zero;
-}
-
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr bool operator!=(_CmpUnspecifiedParam, weak_equality __v) noexcept {
-  return __v.__value_ != _EqResult::__zero;
-}
-
-#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr weak_equality operator<=>(weak_equality __v, _CmpUnspecifiedParam) noexcept {
-  return __v;
-}
-
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr weak_equality operator<=>(_CmpUnspecifiedParam, weak_equality __v) noexcept {
-  return __v;
-}
-#endif
-
-class strong_equality {
-  _LIBCPP_INLINE_VISIBILITY
-  explicit constexpr strong_equality(_EqResult __val) noexcept : __value_(__val) {}
-
-public:
-  static const strong_equality equal;
-  static const strong_equality nonequal;
-  static const strong_equality equivalent;
-  static const strong_equality nonequivalent;
-
-  // conversion
-  _LIBCPP_INLINE_VISIBILITY constexpr operator weak_equality() const noexcept {
-    return __value_ == _EqResult::__zero ? weak_equality::equivalent
-          : weak_equality::nonequivalent;
-  }
-
-  // comparisons
-  _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(strong_equality __v, _CmpUnspecifiedParam) noexcept;
-  _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(strong_equality __v, _CmpUnspecifiedParam) noexcept;
-  _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(_CmpUnspecifiedParam, strong_equality __v) noexcept;
-  _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(_CmpUnspecifiedParam, strong_equality __v) noexcept;
-
-#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
-  _LIBCPP_INLINE_VISIBILITY friend constexpr strong_equality operator<=>(strong_equality __v, _CmpUnspecifiedParam) noexcept;
-  _LIBCPP_INLINE_VISIBILITY friend constexpr strong_equality operator<=>(_CmpUnspecifiedParam, strong_equality __v) noexcept;
-#endif
-private:
-  _EqResult __value_;
-};
-
-_LIBCPP_INLINE_VAR constexpr strong_equality strong_equality::equal(_EqResult::__equal);
-_LIBCPP_INLINE_VAR constexpr strong_equality strong_equality::nonequal(_EqResult::__nonequal);
-_LIBCPP_INLINE_VAR constexpr strong_equality strong_equality::equivalent(_EqResult::__equiv);
-_LIBCPP_INLINE_VAR constexpr strong_equality strong_equality::nonequivalent(_EqResult::__nonequiv);
-
-_LIBCPP_INLINE_VISIBILITY
-constexpr bool operator==(strong_equality __v, _CmpUnspecifiedParam) noexcept {
-  return __v.__value_ == _EqResult::__zero;
-}
-
-_LIBCPP_INLINE_VISIBILITY
-constexpr bool operator==(_CmpUnspecifiedParam, strong_equality __v) noexcept {
-  return __v.__value_ == _EqResult::__zero;
-}
-
-_LIBCPP_INLINE_VISIBILITY
-constexpr bool operator!=(strong_equality __v, _CmpUnspecifiedParam) noexcept {
-  return __v.__value_ != _EqResult::__zero;
-}
-
-_LIBCPP_INLINE_VISIBILITY
-constexpr bool operator!=(_CmpUnspecifiedParam, strong_equality __v) noexcept {
-  return __v.__value_ != _EqResult::__zero;
-}
-
-#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
-_LIBCPP_INLINE_VISIBILITY
-constexpr strong_equality operator<=>(strong_equality __v, _CmpUnspecifiedParam) noexcept {
-  return __v;
-}
-
-_LIBCPP_INLINE_VISIBILITY
-constexpr strong_equality operator<=>(_CmpUnspecifiedParam, strong_equality __v) noexcept {
-  return __v;
-}
-#endif // _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
-
 class partial_ordering {
   using _ValueT = signed char;
 
   _LIBCPP_INLINE_VISIBILITY
   explicit constexpr partial_ordering(_EqResult __v) noexcept
       : __value_(_ValueT(__v)) {}
 
   _LIBCPP_INLINE_VISIBILITY
class partial_ordering {
   }
 public:
   // valid values
   static const partial_ordering less;
   static const partial_ordering equivalent;
   static const partial_ordering greater;
   static const partial_ordering unordered;
 
-  // conversion
-  constexpr operator weak_equality() const noexcept {
-    return __value_ == 0 ? weak_equality::equivalent : weak_equality::nonequivalent;
-  }
-
   // comparisons
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(partial_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(partial_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator< (partial_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator<=(partial_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator> (partial_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator>=(partial_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(_CmpUnspecifiedParam, partial_ordering __v) noexcept;
class weak_ordering {
   _LIBCPP_INLINE_VISIBILITY
   explicit constexpr weak_ordering(_OrdResult __v) noexcept : __value_(_ValueT(__v)) {}
 
 public:
   static const weak_ordering less;
   static const weak_ordering equivalent;
   static const weak_ordering greater;
 
-  // conversions
-  _LIBCPP_INLINE_VISIBILITY
-  constexpr operator weak_equality() const noexcept {
-    return __value_ == 0 ? weak_equality::equivalent
-                         : weak_equality::nonequivalent;
-  }
-
   _LIBCPP_INLINE_VISIBILITY
   constexpr operator partial_ordering() const noexcept {
     return __value_ == 0 ? partial_ordering::equivalent
         : (__value_ < 0 ? partial_ordering::less : partial_ordering::greater);
   }
 
   // comparisons
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(weak_ordering __v, _CmpUnspecifiedParam) noexcept;

 public:
   static const strong_ordering less;
   static const strong_ordering equal;
   static const strong_ordering equivalent;
   static const strong_ordering greater;
 
   // conversions
   _LIBCPP_INLINE_VISIBILITY
-  constexpr operator weak_equality() const noexcept {
-    return __value_ == 0 ? weak_equality::equivalent
-                         : weak_equality::nonequivalent;
-  }
-
-  _LIBCPP_INLINE_VISIBILITY
-  constexpr operator strong_equality() const noexcept {
-    return __value_ == 0 ? strong_equality::equal
-                         : strong_equality::nonequal;
-  }
-
-  _LIBCPP_INLINE_VISIBILITY
   constexpr operator partial_ordering() const noexcept {
     return __value_ == 0 ? partial_ordering::equivalent
         : (__value_ < 0 ? partial_ordering::less : partial_ordering::greater);
   }
 
   _LIBCPP_INLINE_VISIBILITY
   constexpr operator weak_ordering() const noexcept {
     return __value_ == 0 ? weak_ordering::equivalent

 _LIBCPP_INLINE_VISIBILITY
 constexpr strong_ordering operator<=>(_CmpUnspecifiedParam, strong_ordering __v) noexcept {
   return __v < 0 ? strong_ordering::greater : (__v > 0 ? strong_ordering::less : __v);
 }
 #endif // _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
 
 // named comparison functions
 _LIBCPP_INLINE_VISIBILITY
-constexpr bool is_eq(weak_equality __cmp) noexcept    { return __cmp == 0; }
-
-_LIBCPP_INLINE_VISIBILITY
-constexpr bool is_neq(weak_equality __cmp) noexcept    { return __cmp != 0; }
-
-_LIBCPP_INLINE_VISIBILITY
 constexpr bool is_lt(partial_ordering __cmp) noexcept { return __cmp < 0; }
 
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool is_lteq(partial_ordering __cmp) noexcept { return __cmp <= 0; }
 
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool is_gt(partial_ordering __cmp) noexcept { return __cmp > 0; }
 
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool is_gteq(partial_ordering __cmp) noexcept { return __cmp >= 0; }
 
 namespace __comp_detail {
 
 enum _ClassifyCompCategory : unsigned{
   _None,
-  _WeakEq,
-  _StrongEq,
   _PartialOrd,
   _WeakOrd,
   _StrongOrd,
   _CCC_Size
 };
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY
 constexpr _ClassifyCompCategory __type_to_enum() noexcept {
-  if (is_same_v<_Tp, weak_equality>)
-    return _WeakEq;
-  if (is_same_v<_Tp, strong_equality>)
-    return _StrongEq;
   if (is_same_v<_Tp, partial_ordering>)
     return _PartialOrd;
   if (is_same_v<_Tp, weak_ordering>)
     return _WeakOrd;
   if (is_same_v<_Tp, strong_ordering>)
     return _StrongOrd;
   return _None;
 }
 
 template <size_t _Size>
 constexpr _ClassifyCompCategory
 __compute_comp_type(const _ClassifyCompCategory (&__types)[_Size]) {
   int __seen[_CCC_Size] = {};
   for (auto __type : __types)
     ++__seen[__type];
   if (__seen[_None])
     return _None;
-  if (__seen[_WeakEq])
-    return _WeakEq;
-  if (__seen[_StrongEq] && (__seen[_PartialOrd] || __seen[_WeakOrd]))
-    return _WeakEq;
-  if (__seen[_StrongEq])
-    return _StrongEq;
   if (__seen[_PartialOrd])
     return _PartialOrd;
   if (__seen[_WeakOrd])
     return _WeakOrd;
   return _StrongOrd;
 }
 
 template <class ..._Ts>
 constexpr auto __get_comp_type() {
   using _CCC = _ClassifyCompCategory;
   constexpr _CCC __type_kinds[] = {_StrongOrd, __type_to_enum<_Ts>()...};
   constexpr _CCC _Cat = __compute_comp_type(__type_kinds);
   if constexpr (_Cat == _None)
     return void();
-  else if constexpr (_Cat == _WeakEq)
-    return weak_equality::equivalent;
-  else if constexpr (_Cat == _StrongEq)
-    return strong_equality::equivalent;
   else if constexpr (_Cat == _PartialOrd)
     return partial_ordering::equivalent;
   else if constexpr (_Cat == _WeakOrd)
     return weak_ordering::equivalent;
   else if constexpr (_Cat == _StrongOrd)
     return strong_ordering::equivalent;
   else
     static_assert(_Cat != _Cat, "unhandled case");
 }
 } // namespace __comp_detail
 
 // [cmp.common], common comparison category type
 template<class... _Ts>
 struct _LIBCPP_TEMPLATE_VIS common_comparison_category {
   using type = decltype(__comp_detail::__get_comp_type<_Ts...>());
 };
 
 template<class... _Ts>
 using common_comparison_category_t = typename common_comparison_category<_Ts...>::type;
 
 // [cmp.alg], comparison algorithms
 // TODO: unimplemented
 template<class _Tp> constexpr strong_ordering strong_order(const _Tp& __lhs, const _Tp& __rhs);
 template<class _Tp> constexpr weak_ordering weak_order(const _Tp& __lhs, const _Tp& __rhs);
 template<class _Tp> constexpr partial_ordering partial_order(const _Tp& __lhs, const _Tp& __rhs);
-template<class _Tp> constexpr strong_equality strong_equal(const _Tp& __lhs, const _Tp& __rhs);
-template<class _Tp> constexpr weak_equality weak_equal(const _Tp& __lhs, const _Tp& __rhs);
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_COMPARE

libcxx/test/std/language.support/cmp/cmp.common/common_comparison_category.pass.cpp

void test_cat() {
   static_assert(std::is_same<CatT, std::common_comparison_category_t<Args...>>::value, "");
   static_assert(std::is_same<CatT, Expect>::value, "expected different category");
 };
 
 
 // [class.spaceship]p4: The 'common comparison type' U of a possibly-empty list
 //   of 'n' types T0, T1, ..., TN, is defined as follows:
 int main(int, char**) {
-  using WE = std::weak_equality;
-  using SE = std::strong_equality;
   using PO = std::partial_ordering;
   using WO = std::weak_ordering;
   using SO = std::strong_ordering;
 
-  // [class.spaceship]p4.1: If any Ti is not a comparison category tpe, U is void.
+  // [cmp.common]p2: The member typedef-name type denotes the common comparison
+  /// type ([class.spaceship]) of Ts..., the expanded parameter pack, or void if
+  // any element of Ts is not a comparison category type.
   {
     test_cat<void, void>();
     test_cat<void, int*>();
     test_cat<void, SO&>();
     test_cat<void, SO const>();
     test_cat<void, SO*>();
     test_cat<void, SO, void, SO>();
   }
 
-  // [class.spaceship]p4.2: Otherwise, if at least on Ti is
-  // std::weak_equality, or at least one Ti is std::strong_equality and at least
-  // one Tj is std::partial_ordering or std::weak_ordering, U is std::weak_equality
-  {
-    test_cat<WE, WE>();
-    test_cat<WE, SO, WE, SO>();
-    test_cat<WE, SE, SO, PO>();
-    test_cat<WE, WO, SO, SE>();
-  }
-
-  // [class.spaceship]p4.3: Otherwise, if at least one Ti is std::strong_equality,
-  // U is std::strong_equality
-  {
-    test_cat<SE, SE>();
-    test_cat<SE, SO, SE, SO>();
-  }
-
-  // [class.spaceship]p4.4: Otherwise, if at least one Ti is std::partial_ordering,
-  // U is std::partial_ordering
+  // [class.spaceship]p4.1: If at least one Ti is std::partial_ordering, U is
+  // std::partial_ordering ([cmp.partialord]).
   {
     test_cat<PO, PO>();
     test_cat<PO, SO, PO, SO>();
     test_cat<PO, WO, PO, SO>();
   }
 
-  // [class.spaceship]p4.5: Otherwise, if at least one Ti is std::weak_ordering,
+  // [class.spaceship]p4.2: Otherwise, if at least one Ti is std::weak_ordering,
   // U is std::weak_ordering
   {
     test_cat<WO, WO>();
     test_cat<WO, SO, WO, SO>();
   }
 
-  // [class.spaceship]p4.6: Otherwise, U is std::strong_ordering. [Note: in
-  // particular this is the result when n is 0. -- end note]
+  // [class.spaceship]p4.3: Otherwise, U is std::strong_ordering.
   {
-    test_cat<SO>(); // empty type list
     test_cat<SO, SO>();
     test_cat<SO, SO, SO>();
   }
 
+  // [cmp.common]p2, note 2: This is std::!strong_ordering if the expansion is empty.
+  // [class.spaceship]p4.3, note 2: In particular this is the result when n is 0.
+  {
+    test_cat<SO>(); // empty type list
+  }
+
   return 0;
 }

libcxx/test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp

 #ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
   ASSERT_NOEXCEPT(0 <=> Eq);
   ASSERT_NOEXCEPT(Eq <=> 0);
   ASSERT_SAME_TYPE(decltype(Eq <=> 0), std::partial_ordering);
   ASSERT_SAME_TYPE(decltype(0 <=> Eq), std::partial_ordering);
 #endif
 }
 
-constexpr bool test_conversion() {
-  static_assert(std::is_convertible<const std::partial_ordering, std::weak_equality>::value, "");
-  { // value == 0
-    auto V = std::partial_ordering::equivalent;
-    std::weak_equality WV = V;
-    assert(WV == 0);
-  }
-  std::partial_ordering TestCases[] = {
-      std::partial_ordering::less,
-      std::partial_ordering::greater,
-      std::partial_ordering::unordered
-  };
-  for (auto V : TestCases)
-  { // value != 0
-    std::weak_equality WV = V;
-    assert(WV != 0);
-  }
-  return true;
-}
-
 constexpr bool test_constexpr() {
   auto& Eq = std::partial_ordering::equivalent;
   auto& Less = std::partial_ordering::less;
   auto& Greater = std::partial_ordering::greater;
   auto& Unord = std::partial_ordering::unordered;
   struct {
     std::partial_ordering Value;
     bool ExpectEq;

 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test_static_members();
   test_signatures();
-  static_assert(test_conversion(), "conversion test failed");
   static_assert(test_constexpr(), "constexpr test failed");
 
   return 0;
 }

libcxx/test/std/language.support/cmp/cmp.strongeq/cmp.strongeq.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
-
-// <compare>
-
-// class strong_equality
-
-
-#include <compare>
-#include <type_traits>
-#include <cassert>
-
-#include "test_macros.h"
-
-const volatile void* volatile sink;
-
-void test_static_members() {
-  DoNotOptimize(&std::strong_equality::equal);
-  DoNotOptimize(&std::strong_equality::nonequal);
-  DoNotOptimize(&std::strong_equality::equivalent);
-  DoNotOptimize(&std::strong_equality::nonequivalent);
-}
-
-void test_signatures() {
-  auto& Eq = std::strong_equality::equivalent;
-
-  ASSERT_NOEXCEPT(Eq == 0);
-  ASSERT_NOEXCEPT(0 == Eq);
-  ASSERT_NOEXCEPT(Eq != 0);
-  ASSERT_NOEXCEPT(0 != Eq);
-#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
-  ASSERT_NOEXCEPT(0 <=> Eq);
-  ASSERT_NOEXCEPT(Eq <=> 0);
-  ASSERT_SAME_TYPE(decltype(Eq <=> 0), std::strong_equality);
-  ASSERT_SAME_TYPE(decltype(0 <=> Eq), std::strong_equality);
-#endif
-}
-
-void test_conversion() {
-  constexpr std::weak_equality res = std::strong_equality::equivalent;
-  static_assert(res == 0, "");
-  static_assert(std::is_convertible<const std::strong_equality&,
-      std::weak_equality>::value, "");
-  static_assert(res == 0, "expected equal");
-
-  constexpr std::weak_equality neq_res = std::strong_equality::nonequivalent;
-  static_assert(neq_res != 0, "expected not equal");
-}
-
-constexpr bool test_constexpr() {
-  auto& Eq = std::strong_equality::equal;
-  auto& NEq = std::strong_equality::nonequal;
-  auto& Equiv = std::strong_equality::equivalent;
-  auto& NEquiv = std::strong_equality::nonequivalent;
-  assert((Eq == 0) == true);
-  assert((0 == Eq) == true);
-  assert((Equiv == 0) == true);
-  assert((0 == Equiv) == true);
-  assert((NEq == 0) == false);
-  assert((0 == NEq) == false);
-  assert((NEquiv == 0) == false);
-  assert((0 == NEquiv) == false);
-
-  assert((Eq != 0) == false);
-  assert((0 != Eq) == false);
-  assert((Equiv != 0) == false);
-  assert((0 != Equiv) == false);
-  assert((NEq != 0) == true);
-  assert((0 != NEq) == true);
-  assert((NEquiv != 0) == true);
-  assert((0 != NEquiv) == true);
-
-#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
-  std::strong_equality res = (Eq <=> 0);
-  ((void)res);
-  res = (0 <=> Eq);
-  ((void)res);
-#endif
-
-  return true;
-}
-
-int main(int, char**) {
-  test_static_members();
-  test_signatures();
-  test_conversion();
-  static_assert(test_constexpr(), "constexpr test failed");
-
-  return 0;
-}

libcxx/test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp

#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
   ASSERT_NOEXCEPT(Eq <=> 0);
   ASSERT_SAME_TYPE(decltype(Eq <=> 0), std::strong_ordering);
   ASSERT_SAME_TYPE(decltype(0 <=> Eq), std::strong_ordering);
 #endif
 }
 
 constexpr bool test_conversion() {
   static_assert(std::is_convertible<const std::strong_ordering&,
-      std::weak_equality>::value, "");
-  { // value == 0
-    auto V = std::strong_ordering::equivalent;
-    std::weak_equality WV = V;
-    assert(WV == 0);
-  }
-  std::strong_ordering WeakTestCases[] = {
-      std::strong_ordering::less,
-      std::strong_ordering::greater,
-  };
-  for (auto V : WeakTestCases)
-  { // value != 0
-    std::weak_equality WV = V;
-    assert(WV != 0);
-  }
-  static_assert(std::is_convertible<const std::strong_ordering&,
-      std::strong_equality>::value, "");
-  { // value == 0
-    auto V = std::strong_ordering::equivalent;
-    std::strong_equality WV = V;
-    assert(WV == 0);
-  }
-  { // value == 0
-    auto V = std::strong_ordering::equal;
-    std::strong_equality WV = V;
-    assert(WV == 0);
-  }
-  std::strong_ordering StrongTestCases[] = {
-      std::strong_ordering::less,
-      std::strong_ordering::greater,
-  };
-  for (auto V : StrongTestCases)
-  { // value != 0
-    std::strong_equality WV = V;
-    assert(WV != 0);
-  }
-
-  static_assert(std::is_convertible<const std::strong_ordering&,
       std::partial_ordering>::value, "");
   { // value == 0
     auto V = std::strong_ordering::equivalent;
     std::partial_ordering WV = V;
     assert(WV == 0);
   }
   { // value < 0
     auto V = std::strong_ordering::less;

libcxx/test/std/language.support/cmp/cmp.weakeq/cmp.weakeq.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
-
-// <compare>
-
-// class weak_equality
-
-
-#include <compare>
-#include <cassert>
-#include "test_macros.h"
-
-const volatile void* volatile sink;
-
-void test_static_members() {
-  DoNotOptimize(&std::weak_equality::equivalent);
-  DoNotOptimize(&std::weak_equality::nonequivalent);
-}
-
-void test_signatures() {
-  auto& Eq = std::weak_equality::equivalent;
-
-  ASSERT_NOEXCEPT(Eq == 0);
-  ASSERT_NOEXCEPT(0 == Eq);
-  ASSERT_NOEXCEPT(Eq != 0);
-  ASSERT_NOEXCEPT(0 != Eq);
-#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
-  ASSERT_NOEXCEPT(0 <=> Eq);
-  ASSERT_NOEXCEPT(Eq <=> 0);
-  ASSERT_SAME_TYPE(decltype(Eq <=> 0), std::weak_equality);
-  ASSERT_SAME_TYPE(decltype(0 <=> Eq), std::weak_equality);
-#endif
-}
-
-constexpr bool test_constexpr() {
-  auto& Eq = std::weak_equality::equivalent;
-  auto& NEq = std::weak_equality::nonequivalent;
-  assert((Eq == 0) == true);
-  assert((0 == Eq) == true);
-  assert((NEq == 0) == false);
-  assert((0 == NEq) == false);
-
-  assert((Eq != 0) == false);
-  assert((0 != Eq) == false);
-  assert((NEq != 0) == true);
-  assert((0 != NEq) == true);
-
-#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
-  std::weak_equality res = (Eq <=> 0);
-  ((void)res);
-  res = (0 <=> Eq);
-  ((void)res);
-#endif
-
-  return true;
-}
-
-int main(int, char**) {
-  test_static_members();
-  test_signatures();
-  static_assert(test_constexpr(), "constexpr test failed");
-
-  return 0;
-}

libcxx/test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp

#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
   ASSERT_NOEXCEPT(Eq <=> 0);
   ASSERT_SAME_TYPE(decltype(Eq <=> 0), std::weak_ordering);
   ASSERT_SAME_TYPE(decltype(0 <=> Eq), std::weak_ordering);
 #endif
 }
 
 constexpr bool test_conversion() {
   static_assert(std::is_convertible<const std::weak_ordering&,
-      std::weak_equality>::value, "");
-  { // value == 0
-    auto V = std::weak_ordering::equivalent;
-    std::weak_equality WV = V;
-    assert(WV == 0);
-  }
-  std::weak_ordering WeakTestCases[] = {
-      std::weak_ordering::less,
-      std::weak_ordering::greater,
-  };
-  for (auto V : WeakTestCases)
-  { // value != 0
-    std::weak_equality WV = V;
-    assert(WV != 0);
-  }
-  static_assert(std::is_convertible<const std::weak_ordering&,
       std::partial_ordering>::value, "");
   { // value == 0
     auto V = std::weak_ordering::equivalent;
     std::partial_ordering WV = V;
     assert(WV == 0);
   }
   { // value < 0
     auto V = std::weak_ordering::less;