Removing *_equality.

[BRevzin]

Summary

This removes weak_equality and strong_equality (per P1959R0).

[ldionne]

libcxx/include/compare

72

Why is this changed to 2, and why was it -127 before? Sorry, I'm missing context on the history of this header (which was originally implemented by @EricWF)

[BRevzin]

libcxx/include/compare

72

It was -127 because that's the exposition-only specification in [cmp].

I changed it to 2 to make it easier to do the comparisons.

[EricWF]

I would rather see a patch that only removes the removed interfaces, and doesn't do all the additional cleanup you've done.

[ldionne]

I'll let @EricWF take it on since he wrote that code.

[BRevzin]

Splitting the diff to JUST remove weak/strong_equality.

[BRevzin]

In D74186#1906326, @EricWF wrote:

I would rather see a patch that only removes the removed interfaces, and doesn't do all the additional cleanup you've done.

Done. I'll do the second bit after this one is accepted (though my main motivation for opening this review was the "cleanup" - optimizing the comparisons).

[• Quuxplusone]

I think this is great.
Please update docs/Cxx2aStatusPaperStatus.csv, and rebase; then (assuming there are no surprises in the rebase) it LGTM.
(ping! @EricWF)

[BRevzin]

Abandoning in favor of cjdb's more active contributions.

libcxx/include/compare

 
 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; }

   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);
 }
 */
 

 struct _CmpUnspecifiedType;
 using _CmpUnspecifiedParam = void (_CmpUnspecifiedType::*)();
 
-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;
 

   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;

   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

   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

 
 // named comparison functions
 _LIBCPP_INLINE_VISIBILITY
-constexpr bool is_eq(weak_equality __cmp) noexcept    { return __cmp == 0; }
+constexpr bool is_eq(partial_ordering __cmp) noexcept    { return __cmp == 0; }
 
 _LIBCPP_INLINE_VISIBILITY
-constexpr bool is_neq(weak_equality __cmp) noexcept    { return __cmp != 0; }
+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; }

 
 enum _ClassifyCompCategory : unsigned{
   _None,
-  _WeakEq,
-  _StrongEq,
   _PartialOrd,
   _WeakOrd,
   _StrongOrd,

 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>)

     ++__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])

       : __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)

 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
 

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

 // [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;

     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,
+  // [class.spaceship]p4.2: Otherwise, if at least one Ti is std::partial_ordering,
   // U is std::partial_ordering
   {
     test_cat<PO, PO>();

     test_cat<PO, WO, PO, SO>();
   }
 
-  // [class.spaceship]p4.5: Otherwise, if at least one Ti is std::weak_ordering,
+  // [class.spaceship]p4.3: 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
+  // [class.spaceship]p4.4: 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

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

 #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;

 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++98, 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

 }
 
 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

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++98, 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

 }
 
 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