[libc++] [compare] Rip out more vestiges of *_equality. NFCI.

[• Quuxplusone]

Summary

There's really no reason to even have two different enums here,
but *definitely* we shouldn't have *three*, and they don't need
so many synonymous enumerator values.

[• Quuxplusone]

Poke buildkite.

libcxx/include/__compare/ordering.h

 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
 
 // exposition only
-enum class _LIBCPP_ENUM_VIS _EqResult : unsigned char {
-  __zero = 0,
-  __equal = __zero,
-  __equiv = __equal,
-  __nonequal = 1,
-  __nonequiv = __nonequal
-};
-
 enum class _LIBCPP_ENUM_VIS _OrdResult : signed char {
   __less = -1,
+  __equiv = 0,
   __greater = 1
 };
 
 enum class _LIBCPP_ENUM_VIS _NCmpResult : signed char {
   __unordered = -127
 };
 
 class partial_ordering;
struct _CmpUnspecifiedParam {
   template<class _Tp, class = enable_if_t<!__one_of_v<_Tp, int, partial_ordering, weak_ordering, strong_ordering>>>
   _CmpUnspecifiedParam(_Tp) = delete;
 };
 
 class partial_ordering {
   using _ValueT = signed char;
 
   _LIBCPP_HIDE_FROM_ABI
-  explicit constexpr partial_ordering(_EqResult __v) noexcept
-      : __value_(_ValueT(__v)) {}
-
-  _LIBCPP_HIDE_FROM_ABI
   explicit constexpr partial_ordering(_OrdResult __v) noexcept
       : __value_(_ValueT(__v)) {}
 
   _LIBCPP_HIDE_FROM_ABI
   explicit constexpr partial_ordering(_NCmpResult __v) noexcept
       : __value_(_ValueT(__v)) {}
 
   _LIBCPP_HIDE_FROM_ABI
public:
   friend constexpr partial_ordering operator<=>(_CmpUnspecifiedParam, partial_ordering __v) noexcept  {
     return __v < 0 ? partial_ordering::greater : (__v > 0 ? partial_ordering::less : __v);
   }
 private:
   _ValueT __value_;
 };
 
 inline constexpr partial_ordering partial_ordering::less(_OrdResult::__less);
-inline constexpr partial_ordering partial_ordering::equivalent(_EqResult::__equiv);
+inline constexpr partial_ordering partial_ordering::equivalent(_OrdResult::__equiv);
 inline constexpr partial_ordering partial_ordering::greater(_OrdResult::__greater);
 inline constexpr partial_ordering partial_ordering::unordered(_NCmpResult ::__unordered);
 
 class weak_ordering {
   using _ValueT = signed char;
 
   _LIBCPP_HIDE_FROM_ABI
-  explicit constexpr weak_ordering(_EqResult __v) noexcept : __value_(_ValueT(__v)) {}
-  _LIBCPP_HIDE_FROM_ABI
   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;
 
   _LIBCPP_HIDE_FROM_ABI
friend constexpr weak_ordering operator<=>(_CmpUnspecifiedParam, weak_ordering __v) noexcept {
     return __v < 0 ? weak_ordering::greater : (__v > 0 ? weak_ordering::less : __v);
   }
 
 private:
   _ValueT __value_;
 };
 
 inline constexpr weak_ordering weak_ordering::less(_OrdResult::__less);
-inline constexpr weak_ordering weak_ordering::equivalent(_EqResult::__equiv);
+inline constexpr weak_ordering weak_ordering::equivalent(_OrdResult::__equiv);
 inline constexpr weak_ordering weak_ordering::greater(_OrdResult::__greater);
 
 class strong_ordering {
   using _ValueT = signed char;
 
   _LIBCPP_HIDE_FROM_ABI
-  explicit constexpr strong_ordering(_EqResult __v) noexcept : __value_(_ValueT(__v)) {}
-  _LIBCPP_HIDE_FROM_ABI
   explicit constexpr strong_ordering(_OrdResult __v) noexcept : __value_(_ValueT(__v)) {}
 
 public:
   static const strong_ordering less;
   static const strong_ordering equal;
   static const strong_ordering equivalent;
   static const strong_ordering greater;
 
friend constexpr strong_ordering operator<=>(_CmpUnspecifiedParam, strong_ordering __v) noexcept {
     return __v < 0 ? strong_ordering::greater : (__v > 0 ? strong_ordering::less : __v);
   }
 
 private:
   _ValueT __value_;
 };
 
 inline constexpr strong_ordering strong_ordering::less(_OrdResult::__less);
-inline constexpr strong_ordering strong_ordering::equal(_EqResult::__equal);
-inline constexpr strong_ordering strong_ordering::equivalent(_EqResult::__equiv);
+inline constexpr strong_ordering strong_ordering::equal(_OrdResult::__equiv);
+inline constexpr strong_ordering strong_ordering::equivalent(_OrdResult::__equiv);
 inline constexpr strong_ordering strong_ordering::greater(_OrdResult::__greater);
 
 // named comparison functions
 _LIBCPP_HIDE_FROM_ABI
 constexpr bool is_lt(partial_ordering __cmp) noexcept { return __cmp < 0; }
 
 _LIBCPP_HIDE_FROM_ABI
 constexpr bool is_lteq(partial_ordering __cmp) noexcept { return __cmp <= 0; }