Create a new version of paste:

diff --git a/libcxx/include/compare b/libcxx/include/compare
index 4282a1e5fa80..c9d5e10db60e 100644
--- a/libcxx/include/compare
+++ b/libcxx/include/compare
@@ -1,143 +1,139 @@
 // -*- C++ -*-
 //===-------------------------- compare -----------------------------------===//
 //
 // 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_COMPARE
 #define _LIBCPP_COMPARE
 
 /*
     compare synopsis
 
 namespace std {
   // [cmp.categories], comparison category types
   class partial_ordering;
   class weak_ordering;
   class strong_ordering;
 
   // named comparison functions
-  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;
     static const partial_ordering unordered;
 
     // comparisons
     friend constexpr bool operator==(partial_ordering v, unspecified) noexcept;
     friend constexpr bool operator==(partial_ordering v, partial_ordering w) noexcept = default;
     friend constexpr bool operator< (partial_ordering v, unspecified) noexcept;
     friend constexpr bool operator> (partial_ordering v, unspecified) noexcept;
     friend constexpr bool operator<=(partial_ordering v, unspecified) noexcept;
     friend constexpr bool operator>=(partial_ordering v, unspecified) noexcept;
     friend constexpr bool operator< (unspecified, partial_ordering v) noexcept;
     friend constexpr bool operator> (unspecified, partial_ordering v) noexcept;
     friend constexpr bool operator<=(unspecified, partial_ordering v) noexcept;
     friend constexpr bool operator>=(unspecified, partial_ordering v) noexcept;
     friend constexpr partial_ordering operator<=>(partial_ordering v, unspecified) noexcept;
     friend constexpr partial_ordering operator<=>(unspecified, partial_ordering v) noexcept;
   };
 
   // [cmp.weakord], Class weak_ordering
   class weak_ordering {
   public:
     // valid values
     static const weak_ordering less;
     static const weak_ordering equivalent;
     static const weak_ordering greater;
 
     // conversions
     constexpr operator partial_ordering() const noexcept;
 
     // comparisons
     friend constexpr bool operator==(weak_ordering v, unspecified) noexcept;
     friend constexpr bool operator==(weak_ordering v, weak_ordering w) noexcept = default;
     friend constexpr bool operator< (weak_ordering v, unspecified) noexcept;
     friend constexpr bool operator> (weak_ordering v, unspecified) noexcept;
     friend constexpr bool operator<=(weak_ordering v, unspecified) noexcept;
     friend constexpr bool operator>=(weak_ordering v, unspecified) noexcept;
     friend constexpr bool operator< (unspecified, weak_ordering v) noexcept;
     friend constexpr bool operator> (unspecified, weak_ordering v) noexcept;
     friend constexpr bool operator<=(unspecified, weak_ordering v) noexcept;
     friend constexpr bool operator>=(unspecified, weak_ordering v) noexcept;
     friend constexpr weak_ordering operator<=>(weak_ordering v, unspecified) noexcept;
     friend constexpr weak_ordering operator<=>(unspecified, weak_ordering v) noexcept;
   };
 
   // [cmp.strongord], Class strong_ordering
   class strong_ordering {
   public:
     // valid values
     static const strong_ordering less;
     static const strong_ordering equal;
     static const strong_ordering equivalent;
     static const strong_ordering greater;
 
     // conversions
     constexpr operator partial_ordering() const noexcept;
     constexpr operator weak_ordering() const noexcept;
 
     // comparisons
     friend constexpr bool operator==(strong_ordering v, unspecified) noexcept;
     friend constexpr bool operator==(strong_ordering v, strong_ordering w) noexcept = default;
     friend constexpr bool operator< (strong_ordering v, unspecified) noexcept;
     friend constexpr bool operator> (strong_ordering v, unspecified) noexcept;
     friend constexpr bool operator<=(strong_ordering v, unspecified) noexcept;
     friend constexpr bool operator>=(strong_ordering v, unspecified) noexcept;
     friend constexpr bool operator< (unspecified, strong_ordering v) noexcept;
     friend constexpr bool operator> (unspecified, strong_ordering v) noexcept;
     friend constexpr bool operator<=(unspecified, strong_ordering v) noexcept;
     friend constexpr bool operator>=(unspecified, strong_ordering v) noexcept;
     friend constexpr strong_ordering operator<=>(strong_ordering v, unspecified) noexcept;
     friend constexpr strong_ordering operator<=>(unspecified, strong_ordering v) noexcept;
   };
 }
 */
 
 #include <__config>
 #include <type_traits>
 
 #ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
 // exposition only
 enum class _LIBCPP_ENUM_VIS _EqResult : unsigned char {
   __zero = 0,
   __equal = __zero,
   __equiv = __equal,
   __nonequal = 1,
   __nonequiv = __nonequal
 };
@@ -192,407 +188,403 @@ public:
   _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;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(_CmpUnspecifiedParam, partial_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator< (_CmpUnspecifiedParam, partial_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator<=(_CmpUnspecifiedParam, partial_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator> (_CmpUnspecifiedParam, partial_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator>=(_CmpUnspecifiedParam, partial_ordering __v) noexcept;
 
 #ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(partial_ordering, partial_ordering) noexcept = default;
 
   _LIBCPP_INLINE_VISIBILITY friend constexpr partial_ordering operator<=>(partial_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr partial_ordering operator<=>(_CmpUnspecifiedParam, partial_ordering __v) noexcept;
 #endif
 
 private:
   _ValueT __value_;
 };
 
 _LIBCPP_INLINE_VAR constexpr partial_ordering partial_ordering::less(_OrdResult::__less);
 _LIBCPP_INLINE_VAR constexpr partial_ordering partial_ordering::equivalent(_EqResult::__equiv);
 _LIBCPP_INLINE_VAR constexpr partial_ordering partial_ordering::greater(_OrdResult::__greater);
 _LIBCPP_INLINE_VAR constexpr partial_ordering partial_ordering::unordered(_NCmpResult ::__unordered);
 
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator==(partial_ordering __v, _CmpUnspecifiedParam) noexcept {
   return __v.__is_ordered() && __v.__value_ == 0;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator< (partial_ordering __v, _CmpUnspecifiedParam) noexcept {
   return __v.__is_ordered() && __v.__value_ < 0;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator<=(partial_ordering __v, _CmpUnspecifiedParam) noexcept {
   return __v.__is_ordered() && __v.__value_ <= 0;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator> (partial_ordering __v, _CmpUnspecifiedParam) noexcept {
   return __v.__is_ordered() && __v.__value_ > 0;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator>=(partial_ordering __v, _CmpUnspecifiedParam) noexcept {
   return __v.__is_ordered() && __v.__value_ >= 0;
 }
 
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator==(_CmpUnspecifiedParam, partial_ordering __v) noexcept {
   return __v.__is_ordered() && 0 == __v.__value_;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator< (_CmpUnspecifiedParam, partial_ordering __v) noexcept {
   return __v.__is_ordered() && 0 < __v.__value_;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator<=(_CmpUnspecifiedParam, partial_ordering __v) noexcept {
   return __v.__is_ordered() && 0 <= __v.__value_;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator> (_CmpUnspecifiedParam, partial_ordering __v) noexcept {
   return __v.__is_ordered() && 0 > __v.__value_;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator>=(_CmpUnspecifiedParam, partial_ordering __v) noexcept {
   return __v.__is_ordered() && 0 >= __v.__value_;
 }
 
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator!=(partial_ordering __v, _CmpUnspecifiedParam) noexcept {
   return !__v.__is_ordered() || __v.__value_ != 0;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator!=(_CmpUnspecifiedParam, partial_ordering __v) noexcept {
   return !__v.__is_ordered() || __v.__value_ != 0;
 }
 
 #ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
 _LIBCPP_INLINE_VISIBILITY
 constexpr partial_ordering operator<=>(partial_ordering __v, _CmpUnspecifiedParam) noexcept {
   return __v;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr partial_ordering operator<=>(_CmpUnspecifiedParam, partial_ordering __v) noexcept {
   return __v < 0 ? partial_ordering::greater : (__v > 0 ? partial_ordering::less : __v);
 }
 #endif // _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
 
 class weak_ordering {
   using _ValueT = signed char;
 
   _LIBCPP_INLINE_VISIBILITY
   explicit constexpr weak_ordering(_EqResult __v) noexcept : __value_(_ValueT(__v)) {}
   _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 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;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(weak_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator< (weak_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator<=(weak_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator> (weak_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator>=(weak_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(_CmpUnspecifiedParam, weak_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(_CmpUnspecifiedParam, weak_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator< (_CmpUnspecifiedParam, weak_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator<=(_CmpUnspecifiedParam, weak_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator> (_CmpUnspecifiedParam, weak_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator>=(_CmpUnspecifiedParam, weak_ordering __v) noexcept;
 
 #ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(weak_ordering, weak_ordering) noexcept = default;
 
   _LIBCPP_INLINE_VISIBILITY friend constexpr weak_ordering operator<=>(weak_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr weak_ordering operator<=>(_CmpUnspecifiedParam, weak_ordering __v) noexcept;
 #endif
 
 private:
   _ValueT __value_;
 };
 
 _LIBCPP_INLINE_VAR constexpr weak_ordering weak_ordering::less(_OrdResult::__less);
 _LIBCPP_INLINE_VAR constexpr weak_ordering weak_ordering::equivalent(_EqResult::__equiv);
 _LIBCPP_INLINE_VAR constexpr weak_ordering weak_ordering::greater(_OrdResult::__greater);
 
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator==(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
   return __v.__value_ == 0;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator!=(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
   return __v.__value_ != 0;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator< (weak_ordering __v, _CmpUnspecifiedParam) noexcept {
   return __v.__value_ < 0;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator<=(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
   return __v.__value_ <= 0;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator> (weak_ordering __v, _CmpUnspecifiedParam) noexcept {
   return __v.__value_ > 0;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator>=(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
   return __v.__value_ >= 0;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator==(_CmpUnspecifiedParam, weak_ordering __v) noexcept {
   return 0 == __v.__value_;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator!=(_CmpUnspecifiedParam, weak_ordering __v) noexcept {
   return 0 != __v.__value_;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator< (_CmpUnspecifiedParam, weak_ordering __v) noexcept {
   return 0 < __v.__value_;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator<=(_CmpUnspecifiedParam, weak_ordering __v) noexcept {
   return 0 <= __v.__value_;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator> (_CmpUnspecifiedParam, weak_ordering __v) noexcept {
   return 0 > __v.__value_;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator>=(_CmpUnspecifiedParam, weak_ordering __v) noexcept {
   return 0 >= __v.__value_;
 }
 
 #ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
 _LIBCPP_INLINE_VISIBILITY
 constexpr weak_ordering operator<=>(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
   return __v;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr weak_ordering operator<=>(_CmpUnspecifiedParam, weak_ordering __v) noexcept {
   return __v < 0 ? weak_ordering::greater : (__v > 0 ? weak_ordering::less : __v);
 }
 #endif // _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
 
 class strong_ordering {
   using _ValueT = signed char;
 
   _LIBCPP_INLINE_VISIBILITY
   explicit constexpr strong_ordering(_EqResult __v) noexcept : __value_(_ValueT(__v)) {}
   _LIBCPP_INLINE_VISIBILITY
   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;
 
-  // conversions
   _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
         : (__value_ < 0 ? weak_ordering::less : weak_ordering::greater);
   }
 
   // comparisons
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(strong_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(strong_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator< (strong_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator<=(strong_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator> (strong_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator>=(strong_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(_CmpUnspecifiedParam, strong_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(_CmpUnspecifiedParam, strong_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator< (_CmpUnspecifiedParam, strong_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator<=(_CmpUnspecifiedParam, strong_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator> (_CmpUnspecifiedParam, strong_ordering __v) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator>=(_CmpUnspecifiedParam, strong_ordering __v) noexcept;
 
 #ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
   _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(strong_ordering, strong_ordering) noexcept = default;
 
   _LIBCPP_INLINE_VISIBILITY friend constexpr strong_ordering operator<=>(strong_ordering __v, _CmpUnspecifiedParam) noexcept;
   _LIBCPP_INLINE_VISIBILITY friend constexpr strong_ordering operator<=>(_CmpUnspecifiedParam, strong_ordering __v) noexcept;
 #endif
 
 private:
   _ValueT __value_;
 };
 
 _LIBCPP_INLINE_VAR constexpr strong_ordering strong_ordering::less(_OrdResult::__less);
 _LIBCPP_INLINE_VAR constexpr strong_ordering strong_ordering::equal(_EqResult::__equal);
 _LIBCPP_INLINE_VAR constexpr strong_ordering strong_ordering::equivalent(_EqResult::__equiv);
 _LIBCPP_INLINE_VAR constexpr strong_ordering strong_ordering::greater(_OrdResult::__greater);
 
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator==(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
   return __v.__value_ == 0;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator!=(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
   return __v.__value_ != 0;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator< (strong_ordering __v, _CmpUnspecifiedParam) noexcept {
   return __v.__value_ < 0;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator<=(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
   return __v.__value_ <= 0;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator> (strong_ordering __v, _CmpUnspecifiedParam) noexcept {
   return __v.__value_ > 0;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator>=(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
   return __v.__value_ >= 0;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator==(_CmpUnspecifiedParam, strong_ordering __v) noexcept {
   return 0 == __v.__value_;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator!=(_CmpUnspecifiedParam, strong_ordering __v) noexcept {
   return 0 != __v.__value_;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator< (_CmpUnspecifiedParam, strong_ordering __v) noexcept {
   return 0 < __v.__value_;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator<=(_CmpUnspecifiedParam, strong_ordering __v) noexcept {
   return 0 <= __v.__value_;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator> (_CmpUnspecifiedParam, strong_ordering __v) noexcept {
   return 0 > __v.__value_;
 }
 _LIBCPP_INLINE_VISIBILITY
 constexpr bool operator>=(_CmpUnspecifiedParam, strong_ordering __v) noexcept {
   return 0 >= __v.__value_;
 }
 
 #ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
 _LIBCPP_INLINE_VISIBILITY
 constexpr strong_ordering operator<=>(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
   return __v;
 }
 _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(partial_ordering __cmp) noexcept    { return __cmp == 0; }
-
-_LIBCPP_INLINE_VISIBILITY
-constexpr bool is_neq(partial_ordering __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, 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 == _PartialOrd)
+  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");
+    return strong_ordering::equivalent;
 }
 } // 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);
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_COMPARE
diff --git a/libcxx/test/std/language.support/cmp/cmp.common/common_comparison_category.pass.cpp b/libcxx/test/std/language.support/cmp/cmp.common/common_comparison_category.pass.cpp
index 70ee429685b7..3e1f43a069a6 100644
--- a/libcxx/test/std/language.support/cmp/cmp.common/common_comparison_category.pass.cpp
+++ b/libcxx/test/std/language.support/cmp/cmp.common/common_comparison_category.pass.cpp
@@ -1,75 +1,65 @@
 //===----------------------------------------------------------------------===//
 //
 // 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>
 
 // template <class ...Ts> struct common_comparison_category
 // template <class ...Ts> using common_comparison_category_t
 
 
 #include <compare>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 const volatile void* volatile sink;
 
 template <class Expect, class ...Args>
 void test_cat() {
   using Cat = std::common_comparison_category<Args...>;
   using CatT = typename Cat::type;
   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 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.
-  {
-    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 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.3: 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.4: Otherwise, U is std::strong_ordering. [Note: in
+  // [class.spaceship]p4.3: Otherwise, U is std::strong_ordering. [Note: in
   // particular this is the result when n is 0. -- end note]
   {
     test_cat<SO>(); // empty type list
     test_cat<SO, SO>();
     test_cat<SO, SO, SO>();
   }
 
   return 0;
 }
diff --git a/libcxx/test/std/language.support/cmp/cmp.strongeq/cmp.strongeq.pass.cpp b/libcxx/test/std/language.support/cmp/cmp.strongeq/cmp.strongeq.pass.cpp
deleted file mode 100644
index 368a1a436936..000000000000
--- a/libcxx/test/std/language.support/cmp/cmp.strongeq/cmp.strongeq.pass.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// 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;
-}
diff --git a/libcxx/test/std/language.support/cmp/cmp.weakeq/cmp.weakeq.pass.cpp b/libcxx/test/std/language.support/cmp/cmp.weakeq/cmp.weakeq.pass.cpp
deleted file mode 100644
index 0d947ec53212..000000000000
--- a/libcxx/test/std/language.support/cmp/cmp.weakeq/cmp.weakeq.pass.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// 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;
-}