[libc++] Fix missing requires clause on variant operator<=>

[jloser]

Summary

std::variant::operator<=> is missing a requires clause ensuring that
operator<=> only exists when all of the types in the variant are
three_way_comparable.

Add the missing requires clause and adjust the existing test which was
incorrect.

Fixes https://github.com/llvm/llvm-project/issues/58192.

[jloser]

Another test fix

[Mordante]

LGTM modulo some minor nits.

libcxx/include/variant

168

Please add the requires here too.

libcxx/test/std/utilities/variant/variant.relops/three_way.pass.cpp

15

Please add the requires here too.

[jloser]

Add requires clause to synopsis in both <variant> and the three_way_pass.cpp.

[jloser]

libcxx/include/variant

168

Added here and in the test file. Thanks!

[mumbleskates]

thanks! LGTM. i must have been looking at a reference that's missing that requires...

[jloser]

In D136050#3863592, @mumbleskates wrote:

thanks! LGTM. i must have been looking at a reference that's missing that requires...

No worries, easy to fix.

libcxx/include/variant

namespace std {
   constexpr bool operator>(const variant<Types...>&, const variant<Types...>&);
 
   template <class... Types>
   constexpr bool operator<=(const variant<Types...>&, const variant<Types...>&);
 
   template <class... Types>
   constexpr bool operator>=(const variant<Types...>&, const variant<Types...>&);
 
-  template <class... Types>
+  template <class... Types> requires (three_way_comparable<Types> && ...)
   constexpr common_comparison_category_t<compare_three_way_result_t<Types>...>
     operator<=>(const variant<Types...>&, const variant<Types...>&);           // since C++20
 
   // 20.7.6, visitation
   template <class Visitor, class... Variants>
   constexpr see below visit(Visitor&&, Variants&&...);
 
   template <class R, class Visitor, class... Variants>
constexpr bool operator==(const variant<_Types...>& __lhs,
   using __variant_detail::__visitation::__variant;
   if (__lhs.index() != __rhs.index()) return false;
   if (__lhs.valueless_by_exception()) return true;
   return __variant::__visit_value_at(__lhs.index(), __convert_to_bool<equal_to<>>{}, __lhs, __rhs);
 }
 
 #  if _LIBCPP_STD_VER > 17
 
-template <class... _Types>
+template <class... _Types> requires (three_way_comparable<_Types> && ...)
 _LIBCPP_HIDE_FROM_ABI constexpr common_comparison_category_t<compare_three_way_result_t<_Types>...>
 operator<=>(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) {
   using __variant_detail::__visitation::__variant;
   using __result_t = common_comparison_category_t<compare_three_way_result_t<_Types>...>;
   if (__lhs.valueless_by_exception() && __rhs.valueless_by_exception())
     return strong_ordering::equal;
   if (__lhs.valueless_by_exception())
     return strong_ordering::less;

libcxx/test/std/utilities/variant/variant.relops/three_way.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
 
 // <variant>
 
 // template <class... Types> class variant;
 
-// template<class... Types>
+// template <class... Types> requires (three_way_comparable<Types> && ...)
 //   constexpr std::common_comparison_category_t<
 //     std::compare_three_way_result_t<Types>...>
 //   operator<=>(const variant<Types...>& t, const variant<Types...>& u);
 
 #include <cassert>
 #include <limits>
 #include <type_traits>
 #include <utility>

 // operator<=> must resolve the return types of all its union types'
 // operator<=>s to determine its own return type, so it is detectable by SFINAE
 static_assert(!has_three_way_op<HasSimpleOrdering>);
 static_assert(!has_three_way_op<std::variant<int, HasSimpleOrdering>>);
 
 static_assert(!three_way_comparable<HasSimpleOrdering>);
 static_assert(!three_way_comparable<std::variant<int, HasSimpleOrdering>>);
 
-static_assert( has_three_way_op<HasOnlySpaceship>);
-static_assert( has_three_way_op<std::variant<int, HasOnlySpaceship>>);
+static_assert(has_three_way_op<HasOnlySpaceship>);
+static_assert(!has_three_way_op<std::variant<int, HasOnlySpaceship>>);
 
-// variants containing types with unavailable operator== still exist but will
-// generate a compilation error if their operator== is invoked, so the variant
-// type here participates when asked for operator== and operator<=> even though
-// it would actually fail.
 static_assert(!three_way_comparable<HasOnlySpaceship>);
-static_assert( three_way_comparable<std::variant<int, HasOnlySpaceship>>);
+static_assert(!three_way_comparable<std::variant<int, HasOnlySpaceship>>);
 
 static_assert( has_three_way_op<HasFullOrdering>);
 static_assert( has_three_way_op<std::variant<int, HasFullOrdering>>);
 
 static_assert( three_way_comparable<HasFullOrdering>);
 static_assert( three_way_comparable<std::variant<int, HasFullOrdering>>);
 
 int main(int, char**) {