[libc++][NFC] Remove TEST_HAS_NO_SPACESHIP_OPERATOR

[avogelsgesang]

Summary

The corresponding _LIBCPP_HAS_NO_SPACESHIP_OPERATOR macro was already
removed in commit c0f87e8382

[philnik]

LGTM in essence, but I don't know what our stance on compiler support in the tests is. @ldionne do we have any schedule how long we support MSVC in the tests?

[ldionne]

I think this should be fine -- MSVC definitely implements it nowadays and they use our test suite to run against their ToT compiler+stdlib (this is an assumption but it seems like a safe assumption to make).

@CaseyCarter Do you see a problem with this patch?

Please feel free to ship this if Casey's fine with it or if there's no answer by next Tuesday, I don't think this will cause any issues for them.

[avogelsgesang]

to my understanding, even before the removal of the TEST_HAS_NO_SPACESHIP_OPERATOR macro, the libc++ tests would not have worked on a compiler which doesn't support operator<=>.
We have other test cases (e.g. time/time.cal/time.cal.day/time.cal.day.nonmembers/comparisons.pass.cpp) which rely on the spaceship operator and are not guarded by this macro

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

void test_signatures() {
   ASSERT_NOEXCEPT(0 < Eq);
   ASSERT_NOEXCEPT(Eq < 0);
   ASSERT_NOEXCEPT(0 <= Eq);
   ASSERT_NOEXCEPT(Eq <= 0);
   ASSERT_NOEXCEPT(0 > Eq);
   ASSERT_NOEXCEPT(Eq > 0);
   ASSERT_NOEXCEPT(0 >= Eq);
   ASSERT_NOEXCEPT(Eq >= 0);
-#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 void test_equality() {
-#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
   auto& PartialEq = std::partial_ordering::equivalent;
   auto& WeakEq = std::weak_ordering::equivalent;
   assert(PartialEq == WeakEq);
 
   auto& StrongEq = std::strong_ordering::equal;
   assert(PartialEq == StrongEq);
-#endif
 }
 
 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 {
for (auto TC : TestCases) {
     assert((V <= 0) == (TC.ExpectLess || TC.ExpectEq));
     assert((V >= 0) == (TC.ExpectGreater || TC.ExpectEq));
 
     assert((0 < V) == TC.ExpectGreater);
     assert((0 > V) == TC.ExpectLess);
     assert((0 <= V) == (TC.ExpectGreater || TC.ExpectEq));
     assert((0 >= V) == (TC.ExpectLess || TC.ExpectEq));
   }
-#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
   {
     std::partial_ordering res = (Eq <=> 0);
     ((void)res);
     res = (0 <=> Eq);
     ((void)res);
   }
   enum ExpectRes {
     ER_Greater,
static_assert(std::partial_ordering::unordered !=
                   std::partial_ordering::equivalent);
     static_assert(std::partial_ordering::unordered !=
                   std::partial_ordering::greater);
     static_assert(std::partial_ordering::unordered ==
                   std::partial_ordering::unordered);
   }
 
   test_equality();
-#endif
 
   return true;
 }
 
 int main(int, char**) {
   test_static_members();
   test_signatures();
   test_equality();
   static_assert(test_constexpr(), "constexpr test failed");
 
   return 0;
 }

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

void test_signatures() {
   ASSERT_NOEXCEPT(0 < Eq);
   ASSERT_NOEXCEPT(Eq < 0);
   ASSERT_NOEXCEPT(0 <= Eq);
   ASSERT_NOEXCEPT(Eq <= 0);
   ASSERT_NOEXCEPT(0 > Eq);
   ASSERT_NOEXCEPT(Eq > 0);
   ASSERT_NOEXCEPT(0 >= Eq);
   ASSERT_NOEXCEPT(Eq >= 0);
-#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
   ASSERT_NOEXCEPT(0 <=> Eq);
   ASSERT_NOEXCEPT(Eq <=> 0);
   ASSERT_SAME_TYPE(decltype(Eq <=> 0), std::strong_ordering);
   ASSERT_SAME_TYPE(decltype(0 <=> Eq), std::strong_ordering);
-#endif
 }
 
 constexpr void test_equality() {
-#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
   auto& StrongEq = std::strong_ordering::equal;
   auto& PartialEq = std::partial_ordering::equivalent;
   assert(StrongEq == PartialEq);
 
   auto& WeakEq = std::weak_ordering::equivalent;
   assert(StrongEq == WeakEq);
-#endif
 }
 
 constexpr bool test_conversion() {
   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;
for (auto TC : TestCases) {
     assert((V <= 0) == (TC.ExpectLess || TC.ExpectEq));
     assert((V >= 0) == (TC.ExpectGreater || TC.ExpectEq));
 
     assert((0 < V) == TC.ExpectGreater);
     assert((0 > V) == TC.ExpectLess);
     assert((0 <= V) == (TC.ExpectGreater || TC.ExpectEq));
     assert((0 >= V) == (TC.ExpectLess || TC.ExpectEq));
   }
-#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
   {
     std::strong_ordering res = (Eq <=> 0);
     ((void)res);
     res = (0 <=> Eq);
     ((void)res);
   }
   enum ExpectRes {
     ER_Greater,
for (auto TC : SpaceshipTestCases)
 
     static_assert(std::strong_ordering::greater != std::strong_ordering::less);
     static_assert(std::strong_ordering::greater != std::strong_ordering::equal);
     static_assert(std::strong_ordering::greater ==
                   std::strong_ordering::greater);
   }
 
   test_equality();
-#endif
 
   return true;
 }
 
 int main(int, char**) {
   test_static_members();
   test_signatures();
   test_equality();
   static_assert(test_conversion(), "conversion test failed");
   static_assert(test_constexpr(), "constexpr test failed");
 
   return 0;
 }

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

void test_signatures() {
   ASSERT_NOEXCEPT(0 < Eq);
   ASSERT_NOEXCEPT(Eq < 0);
   ASSERT_NOEXCEPT(0 <= Eq);
   ASSERT_NOEXCEPT(Eq <= 0);
   ASSERT_NOEXCEPT(0 > Eq);
   ASSERT_NOEXCEPT(Eq > 0);
   ASSERT_NOEXCEPT(0 >= Eq);
   ASSERT_NOEXCEPT(Eq >= 0);
-#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
   ASSERT_NOEXCEPT(0 <=> Eq);
   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::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;
     std::partial_ordering WV = V;
     assert(WV < 0);
   }
   { // value > 0
     auto V = std::weak_ordering::greater;
     std::partial_ordering WV = V;
     assert(WV > 0);
   }
   return true;
 }
 
 constexpr void test_equality() {
-#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
   auto& WeakEq = std::weak_ordering::equivalent;
   auto& PartialEq = std::partial_ordering::equivalent;
   assert(WeakEq == PartialEq);
 
   auto& StrongEq = std::strong_ordering::equal;
   assert(WeakEq == StrongEq);
-#endif
 }
 
 constexpr bool test_constexpr() {
   auto& Eq = std::weak_ordering::equivalent;
   auto& Less = std::weak_ordering::less;
   auto& Greater = std::weak_ordering::greater;
   struct {
     std::weak_ordering Value;
for (auto TC : TestCases) {
     assert((V <= 0) == (TC.ExpectLess || TC.ExpectEq));
     assert((V >= 0) == (TC.ExpectGreater || TC.ExpectEq));
 
     assert((0 < V) == TC.ExpectGreater);
     assert((0 > V) == TC.ExpectLess);
     assert((0 <= V) == (TC.ExpectGreater || TC.ExpectEq));
     assert((0 >= V) == (TC.ExpectLess || TC.ExpectEq));
   }
-#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
   {
     std::weak_ordering res = (Eq <=> 0);
     ((void)res);
     res = (0 <=> Eq);
     ((void)res);
   }
   enum ExpectRes {
     ER_Greater,
for (auto TC : SpaceshipTestCases)
 
     static_assert(std::weak_ordering::greater != std::weak_ordering::less);
     static_assert(std::weak_ordering::greater !=
                   std::weak_ordering::equivalent);
     static_assert(std::weak_ordering::greater == std::weak_ordering::greater);
   }
 
   test_equality();
-#endif
 
   return true;
 }
 
 int main(int, char**) {
   test_static_members();
   test_signatures();
   test_equality();
   static_assert(test_conversion(), "conversion test failed");
   static_assert(test_constexpr(), "constexpr test failed");
 
   return 0;
 }

libcxx/test/support/test_macros.h

 #if TEST_STD_VER > 17
 #define TEST_CONSTINIT constinit
 #elif defined(_LIBCPP_CONSTINIT)
 #define TEST_CONSTINIT _LIBCPP_CONSTINIT
 #else
 #define TEST_CONSTINIT
 #endif
 
-#if !defined(__cpp_impl_three_way_comparison) \
-    && (!defined(_MSC_VER) || defined(__clang__) || _MSC_VER < 1920 || _MSVC_LANG <= 201703L)
-#define TEST_HAS_NO_SPACESHIP_OPERATOR
-#endif
-
 #if TEST_STD_VER < 11
 #define ASSERT_NOEXCEPT(...)
 #define ASSERT_NOT_NOEXCEPT(...)
 #else
 #define ASSERT_NOEXCEPT(...) \
     static_assert(noexcept(__VA_ARGS__), "Operation must be noexcept")
 
 #define ASSERT_NOT_NOEXCEPT(...) \