diff --git a/libcxx/docs/Status/SpaceshipProjects.csv b/libcxx/docs/Status/SpaceshipProjects.csv
--- a/libcxx/docs/Status/SpaceshipProjects.csv
+++ b/libcxx/docs/Status/SpaceshipProjects.csv
@@ -14,7 +14,7 @@
[syserr.errcat.nonvirtuals],| error_category,[comparisons.three.way],Unassigned,Not started
[syserr.compare],"| error_code
| error_condition",None,Unassigned,Not started
-[tuple.rel],| `tuple <https://reviews.llvm.org/D108250>`_,[expos.only.func],Kent Ross,In progress
+[tuple.rel],| `tuple <https://reviews.llvm.org/D108250>`_,[expos.only.func],Kent Ross,Complete
"[optional.relops]
[optional.nullops]
[optional.comp.with.t]","| optional
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -100,6 +100,7 @@
__compare/common_comparison_category.h
__compare/compare_three_way_result.h
__compare/ordering.h
+ __compare/synth_three_way.h
__concepts/arithmetic.h
__concepts/assignable.h
__concepts/boolean_testable.h
@@ -121,6 +122,7 @@
__concepts/same_as.h
__concepts/semiregular.h
__concepts/swappable.h
+ __concepts/three_way_comparable.h
__concepts/totally_ordered.h
__config
__debug
diff --git a/libcxx/include/__compare/synth_three_way.h b/libcxx/include/__compare/synth_three_way.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__compare/synth_three_way.h
@@ -0,0 +1,52 @@
+// THIS FILE NOT FOR REVIEW (see https://reviews.llvm.org/D107721 )
+//===----------------------------------------------------------------------===//
+//
+// 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_SYNTH_THREE_WAY_H
+#define _LIBCPP___COMPARE_SYNTH_THREE_WAY_H
+
+#include <__config>
+#include <__compare/ordering.h>
+#include <__concepts/boolean_testable.h>
+#include <__concepts/three_way_comparable.h>
+#include <__utility/declval.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR) && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+// [expos.only.func]
+
+constexpr auto __synth_three_way =
+ []<class _Tp, class _Up>(const _Tp& __t, const _Up& __u)
+ requires requires {
+ { __t < __u } -> __boolean_testable;
+ { __u < __t } -> __boolean_testable;
+ }
+ {
+ if constexpr (three_way_comparable_with<_Tp, _Up>) {
+ return __t <=> __u;
+ } else {
+ if (__t < __u) return weak_ordering::less;
+ if (__u < __t) return weak_ordering::greater;
+ return weak_ordering::equivalent;
+ }
+ };
+
+template <class _Tp, class _Up = _Tp>
+using __synth_three_way_result = decltype(__synth_three_way(declval<_Tp&>(), declval<_Up&>()));
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR) && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___COMPARE_SYNTH_THREE_WAY_H
diff --git a/libcxx/include/__concepts/three_way_comparable.h b/libcxx/include/__concepts/three_way_comparable.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__concepts/three_way_comparable.h
@@ -0,0 +1,52 @@
+// THIS FILE NOT FOR REVIEW
+#ifndef INCLUDE___CONCEPTS_THREE_WAY_COMPARABLE_H_
+#define INCLUDE___CONCEPTS_THREE_WAY_COMPARABLE_H_
+
+#include <__compare/common_comparison_category.h>
+#include <__compare/ordering.h>
+#include <__concepts/common_reference_with.h>
+#include <__concepts/equality_comparable.h>
+#include <__concepts/same_as.h>
+#include <__concepts/totally_ordered.h>
+#include <__config>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
+
+template<class T, class Cat>
+concept __compares_as =
+ same_as<common_comparison_category_t<T, Cat>, Cat>;
+
+template<class T, class Cat = partial_ordering>
+concept three_way_comparable =
+ __weakly_equality_comparable_with<T, T> &&
+ __partially_ordered_with<T, T> &&
+ requires(const remove_reference_t<T>& a, const remove_reference_t<T>& b) {
+ { a <=> b } -> __compares_as<Cat>;
+ };
+
+template<class T, class U, class Cat = partial_ordering>
+concept three_way_comparable_with =
+ three_way_comparable<T, Cat> &&
+ three_way_comparable<U, Cat> &&
+ common_reference_with<const remove_reference_t<T>&, const remove_reference_t<U>&> &&
+ three_way_comparable<
+ common_reference_t<const remove_reference_t<T>&, const remove_reference_t<U>&>, Cat> &&
+ __weakly_equality_comparable_with<T, U> &&
+ __partially_ordered_with<T, U> &&
+ requires(const remove_reference_t<T>& t, const remove_reference_t<U>& u) {
+ { t <=> u } -> __compares_as<Cat>;
+ { u <=> t } -> __compares_as<Cat>;
+ };
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif //INCLUDE___CONCEPTS_THREE_WAY_COMPARABLE_H_
diff --git a/libcxx/include/concepts b/libcxx/include/concepts
--- a/libcxx/include/concepts
+++ b/libcxx/include/concepts
@@ -150,6 +150,7 @@
#include <__concepts/same_as.h>
#include <__concepts/semiregular.h>
#include <__concepts/swappable.h>
+#include <__concepts/three_way_comparable.h> // NOT FOR REVIEW
#include <__concepts/totally_ordered.h>
#include <__config>
#include <version>
diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap
--- a/libcxx/include/module.modulemap
+++ b/libcxx/include/module.modulemap
@@ -363,6 +363,7 @@
module common_comparison_category { private header "__compare/common_comparison_category.h" }
module compare_three_way_result { private header "__compare/compare_three_way_result.h" }
module ordering { private header "__compare/ordering.h" }
+ module synth_three_way { private header "__compare/synth_three_way.h" }
}
}
module complex {
@@ -395,6 +396,7 @@
module same_as { private header "__concepts/same_as.h" }
module semiregular { private header "__concepts/semiregular.h" }
module swappable { private header "__concepts/swappable.h" }
+ module three_way_comparable { private header "__concepts/three_way_comparable.h" }
module totally_ordered { private header "__concepts/totally_ordered.h" }
}
}
diff --git a/libcxx/include/tuple b/libcxx/include/tuple
--- a/libcxx/include/tuple
+++ b/libcxx/include/tuple
@@ -132,11 +132,14 @@
// 20.4.1.6, relational operators:
template<class... T, class... U> bool operator==(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
-template<class... T, class... U> bool operator<(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
-template<class... T, class... U> bool operator!=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
-template<class... T, class... U> bool operator>(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
-template<class... T, class... U> bool operator<=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
-template<class... T, class... U> bool operator>=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
+template<class... T, class... U> bool operator<(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14, removed in C++20
+template<class... T, class... U> bool operator!=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14, removed in C++20
+template<class... T, class... U> bool operator>(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14, removed in C++20
+template<class... T, class... U> bool operator<=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14, removed in C++20
+template<class... T, class... U> bool operator>=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14, removed in C++20
+template<class... T, class... U>
+ constexpr common_comparison_category_t<synth-three-way-result<T, U>...>
+ operator<=>(const tuple<T...>&, const tuple<U...>&); // since C++20
template <class... Types, class Alloc>
struct uses_allocator<tuple<Types...>, Alloc>;
@@ -149,6 +152,8 @@
*/
+#include <__compare/common_comparison_category.h>
+#include <__compare/synth_three_way.h>
#include <__config>
#include <__functional/unwrap_ref.h>
#include <__functional_base>
@@ -156,6 +161,7 @@
#include <__memory/uses_allocator.h>
#include <__tuple>
#include <__utility/forward.h>
+#include <__utility/integer_sequence.h>
#include <__utility/move.h>
#include <compare>
#include <cstddef>
@@ -1300,6 +1306,30 @@
return __tuple_equal<sizeof...(_Tp)>()(__x, __y);
}
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR) && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+// operator<=>
+
+template <class ..._Tp, class ..._Up, size_t ..._Is>
+_LIBCPP_HIDE_FROM_ABI constexpr
+auto
+__tuple_compare_three_way(const tuple<_Tp...>& __x, const tuple<_Up...>& __y, index_sequence<_Is...>) {
+ common_comparison_category_t<__synth_three_way_result<_Tp, _Up>...> __result = strong_ordering::equal;
+ static_cast<void>(((__result = _VSTD::__synth_three_way(_VSTD::get<_Is>(__x), _VSTD::get<_Is>(__y)), __result != 0) || ...));
+ return __result;
+}
+
+template <class ..._Tp, class ..._Up>
+requires (sizeof...(_Tp) == sizeof...(_Up))
+_LIBCPP_HIDE_FROM_ABI constexpr
+common_comparison_category_t<__synth_three_way_result<_Tp, _Up>...>
+operator<=>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
+{
+ return __tuple_compare_three_way(__x, __y, index_sequence_for<_Tp...>{});
+}
+
+#else // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR) && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
template <class ..._Tp, class ..._Up>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool
@@ -1368,6 +1398,8 @@
return !(__y < __x);
}
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR) && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
// tuple_cat
template <class _Tp, class _Up> struct __tuple_cat_type;
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/compare/synth_three_way.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/compare/synth_three_way.module.verify.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/compare/synth_three_way.module.verify.cpp
@@ -0,0 +1,16 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__compare/synth_three_way.h'}}
+#include <__compare/synth_three_way.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/concepts/three_way_comparable.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/concepts/three_way_comparable.module.verify.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/concepts/three_way_comparable.module.verify.cpp
@@ -0,0 +1,16 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__concepts/three_way_comparable.h'}}
+#include <__concepts/three_way_comparable.h>
diff --git a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq_incompatible.compile.fail.cpp b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq_incompatible.compile.fail.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq_incompatible.compile.fail.cpp
@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template<class... TTypes, class... UTypes>
+// bool
+// operator==(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
+
+// UNSUPPORTED: c++03
+
+#include <tuple>
+
+static_cast<void>(std::tuple<int>(1) == std::tuple<int, long>(1, 2)); // expected-note {{requested here}}
+// expected-error-re@tuple:* {{static_assert failed{{.*}} "Can't compare tuples of different sizes"}}
+
+static_cast<void>(std::tuple<int, long>(1, 2) == std::tuple<int>(1)); // expected-note {{requested here}}
+// expected-error-re@tuple:* {{static_assert failed{{.*}} "Can't compare tuples of different sizes"}}
+// expected-error-re@__tuple:* {{static_assert failed{{.*}} "tuple_element index out of range"}}
+// expected-error@tuple:* {{no viable conversion from}}
diff --git a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/ge_incompatible.compile.fail.cpp b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/ge_incompatible.compile.fail.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/ge_incompatible.compile.fail.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template<class... TTypes, class... UTypes>
+// bool
+// operator>=(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
+
+// UNSUPPORTED: c++03
+
+#include <tuple>
+
+static_cast<void>(std::tuple<int>(1) >= std::tuple<int, long>(1, 2));
+// c++20 onwards
+// expected-error@-2 0-1 {{invalid operands to binary expression}}
+static_cast<void>(std::tuple<int, long>(1, 2) >= std::tuple<int>(1));
+// c++20 onwards
+// expected-error@-2 0-1 {{invalid operands to binary expression}}
+
+// c++11, c++14, c++17
+// expected-error-re@tuple:* 0-2 {{static_assert failed{{.*}} "Can't compare tuples of different sizes"}}
+// expected-error-re@__tuple:* 0-1 {{static_assert failed{{.*}} "tuple_element index out of range"}}
+// expected-error@tuple:* 0-1 {{no viable conversion from}}
+
+// c++14, c++17
+// expected-error@tuple:* 0-1 {{no matching function for call to 'get'}}
diff --git a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/gt_incompatible.compile.fail.cpp b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/gt_incompatible.compile.fail.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/gt_incompatible.compile.fail.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template<class... TTypes, class... UTypes>
+// bool
+// operator>(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
+
+// UNSUPPORTED: c++03
+
+#include <tuple>
+
+static_cast<void>(std::tuple<int>(1) > std::tuple<int, long>(1, 2));
+// c++20 onwards
+// expected-error@-2 0-1 {{invalid operands to binary expression}}
+static_cast<void>(std::tuple<int, long>(1, 2) > std::tuple<int>(1));
+// c++20 onwards
+// expected-error@-2 0-1 {{invalid operands to binary expression}}
+
+// c++11, c++14, c++17
+// expected-error-re@tuple:* 0-2 {{static_assert failed{{.*}} "Can't compare tuples of different sizes"}}
+// expected-error-re@__tuple:* 0-1 {{static_assert failed{{.*}} "tuple_element index out of range"}}
+// expected-error@tuple:* 0-1 {{no viable conversion from}}
+
+// c++14, c++17
+// expected-error@tuple:* 0-1 {{no matching function for call to 'get'}}
diff --git a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/le_incompatible.compile.fail.cpp b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/le_incompatible.compile.fail.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/le_incompatible.compile.fail.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template<class... TTypes, class... UTypes>
+// bool
+// operator<=(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
+
+// UNSUPPORTED: c++03
+
+#include <tuple>
+
+static_cast<void>(std::tuple<int>(1) <= std::tuple<int, long>(1, 2));
+// c++20 onwards
+// expected-error@-2 0-1 {{invalid operands to binary expression}}
+static_cast<void>(std::tuple<int, long>(1, 2) <= std::tuple<int>(1));
+// c++20 onwards
+// expected-error@-2 0-1 {{invalid operands to binary expression}}
+
+// c++11, c++14, c++17
+// expected-error-re@tuple:* 0-2 {{static_assert failed{{.*}} "Can't compare tuples of different sizes"}}
+// expected-error-re@__tuple:* 0-1 {{static_assert failed{{.*}} "tuple_element index out of range"}}
+// expected-error@tuple:* 0-1 {{no viable conversion from}}
+
+// c++14, c++17
+// expected-error@tuple:* 0-1 {{no matching function for call to 'get'}}
diff --git a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/lt_incompatible.compile.fail.cpp b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/lt_incompatible.compile.fail.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/lt_incompatible.compile.fail.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template<class... TTypes, class... UTypes>
+// bool
+// operator<(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
+
+// UNSUPPORTED: c++03
+
+#include <tuple>
+
+static_cast<void>(std::tuple<int>(1) < std::tuple<int, long>(1, 2));
+// c++20 onwards
+// expected-error@-2 0-1 {{invalid operands to binary expression}}
+static_cast<void>(std::tuple<int, long>(1, 2) < std::tuple<int>(1));
+// c++20 onwards
+// expected-error@-2 0-1 {{invalid operands to binary expression}}
+
+// c++11, c++14, c++17
+// expected-error-re@tuple:* 0-2 {{static_assert failed{{.*}} "Can't compare tuples of different sizes"}}
+// expected-error-re@__tuple:* 0-1 {{static_assert failed{{.*}} "tuple_element index out of range"}}
+// expected-error@tuple:* 0-1 {{no viable conversion from}}
+
+// c++14, c++17
+// expected-error@tuple:* 0-1 {{no matching function for call to 'get'}}
diff --git a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/ne_incompatible.compile.fail.cpp b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/ne_incompatible.compile.fail.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/ne_incompatible.compile.fail.cpp
@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template<class... TTypes, class... UTypes>
+// bool
+// operator!=(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
+
+// UNSUPPORTED: c++03
+
+#include <tuple>
+
+static_cast<void>(std::tuple<int>(1) != std::tuple<int, long>(1, 2)); // expected-note {{requested here}}
+// expected-error-re@tuple:* {{static_assert failed{{.*}} "Can't compare tuples of different sizes"}}
+
+static_cast<void>(std::tuple<int, long>(1, 2) != std::tuple<int>(1)); // expected-note {{requested here}}
+// expected-error-re@tuple:* {{static_assert failed{{.*}} "Can't compare tuples of different sizes"}}
+// expected-error-re@__tuple:* {{static_assert failed{{.*}} "tuple_element index out of range"}}
+// expected-error@tuple:* {{no viable conversion from}}
diff --git a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way.pass.cpp
@@ -0,0 +1,179 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template<class... TTypes, class... UTypes>
+// auto
+// operator<=>(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, libcpp-no-concepts
+
+#include <cassert>
+#include <compare>
+#include <limits>
+#include <tuple>
+
+#include "test_macros.h"
+
+// A custom three-way result type
+struct CustomEquality {
+ friend constexpr bool operator==(const CustomEquality&, int) noexcept { return true; }
+ friend constexpr bool operator<(const CustomEquality&, int) noexcept { return false; }
+ friend constexpr bool operator<(int, const CustomEquality&) noexcept { return false; }
+};
+
+constexpr bool test() {
+ // Empty tuple
+ {
+ typedef std::tuple<> T0;
+ // No member types yields strong ordering (all are equal).
+ ASSERT_SAME_TYPE(decltype(T0() <=> T0()), std::strong_ordering);
+ assert((T0() <=> T0()) == std::strong_ordering::equal);
+ }
+ // Mixed types with integers, which compare strongly ordered
+ {
+ typedef std::tuple<long> T1;
+ typedef std::tuple<short> T2;
+ ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::strong_ordering);
+ assert((T1(1) <=> T2(1)) == std::strong_ordering::equal);
+ assert((T1(1) <=> T2(0)) == std::strong_ordering::greater);
+ assert((T1(1) <=> T2(2)) == std::strong_ordering::less);
+ }
+ {
+ typedef std::tuple<long, unsigned int> T1;
+ typedef std::tuple<short, unsigned long> T2;
+ ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::strong_ordering);
+ assert((T1(1, 2) <=> T2(1, 2)) == std::strong_ordering::equal);
+ assert((T1(1, 2) <=> T2(0, 2)) == std::strong_ordering::greater);
+ assert((T1(1, 2) <=> T2(2, 2)) == std::strong_ordering::less);
+ assert((T1(1, 2) <=> T2(1, 1)) == std::strong_ordering::greater);
+ assert((T1(1, 2) <=> T2(1, 3)) == std::strong_ordering::less);
+ }
+ {
+ typedef std::tuple<long, int, unsigned short> T1;
+ typedef std::tuple<short, long, unsigned int> T2;
+ ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::strong_ordering);
+ assert((T1(1, 2, 3) <=> T2(1, 2, 3)) == std::strong_ordering::equal);
+ assert((T1(1, 2, 3) <=> T2(0, 2, 3)) == std::strong_ordering::greater);
+ assert((T1(1, 2, 3) <=> T2(2, 2, 3)) == std::strong_ordering::less);
+ assert((T1(1, 2, 3) <=> T2(1, 1, 3)) == std::strong_ordering::greater);
+ assert((T1(1, 2, 3) <=> T2(1, 3, 3)) == std::strong_ordering::less);
+ assert((T1(1, 2, 3) <=> T2(1, 2, 2)) == std::strong_ordering::greater);
+ assert((T1(1, 2, 3) <=> T2(1, 2, 4)) == std::strong_ordering::less);
+ }
+ // Mixed types with floating point, which compare partially ordered
+ {
+ typedef std::tuple<long> T1;
+ typedef std::tuple<double> T2;
+ ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::partial_ordering);
+ assert((T1(1) <=> T2(1)) == std::partial_ordering::equivalent);
+ assert((T1(1) <=> T2(0.9)) == std::partial_ordering::greater);
+ assert((T1(1) <=> T2(1.1)) == std::partial_ordering::less);
+ // Comparisons with NaN are non-constexpr in GCC
+ assert((T1(1) <=> T2(std::numeric_limits<double>::quiet_NaN())) == std::partial_ordering::unordered);
+ }
+ {
+ typedef std::tuple<long, float> T1;
+ typedef std::tuple<double, unsigned int> T2;
+ ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::partial_ordering);
+ assert((T1(1, 2) <=> T2(1, 2)) == std::partial_ordering::equivalent);
+ assert((T1(1, 2) <=> T2(0.9, 2)) == std::partial_ordering::greater);
+ assert((T1(1, 2) <=> T2(1.1, 2)) == std::partial_ordering::less);
+ assert((T1(1, 2) <=> T2(1, 1)) == std::partial_ordering::greater);
+ assert((T1(1, 2) <=> T2(1, 3)) == std::partial_ordering::less);
+ // Comparisons with NaN are non-constexpr in GCC
+ assert((T1(1, 2) <=> T2(std::numeric_limits<double>::quiet_NaN(), 2)) == std::partial_ordering::unordered);
+ assert((T1(1, std::numeric_limits<float>::quiet_NaN()) <=> T2(1, 2)) == std::partial_ordering::unordered);
+ }
+ {
+ typedef std::tuple<short, float, double> T1;
+ typedef std::tuple<double, long, unsigned int> T2;
+ ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::partial_ordering);
+ assert((T1(1, 2, 3) <=> T2(1, 2, 3)) == std::partial_ordering::equivalent);
+ assert((T1(1, 2, 3) <=> T2(0.9, 2, 3)) == std::partial_ordering::greater);
+ assert((T1(1, 2, 3) <=> T2(1.1, 2, 3)) == std::partial_ordering::less);
+ assert((T1(1, 2, 3) <=> T2(1, 1, 3)) == std::partial_ordering::greater);
+ assert((T1(1, 2, 3) <=> T2(1, 3, 3)) == std::partial_ordering::less);
+ assert((T1(1, 2, 3) <=> T2(1, 2, 2)) == std::partial_ordering::greater);
+ assert((T1(1, 2, 3) <=> T2(1, 2, 4)) == std::partial_ordering::less);
+ // Comparisons with NaN are non-constexpr in GCC
+ assert((T1(1, 2, 3) <=> T2(std::numeric_limits<double>::quiet_NaN(), 2, 3)) == std::partial_ordering::unordered);
+ assert((T1(1, std::numeric_limits<float>::quiet_NaN(), 3) <=> T2(1, 2, 3)) == std::partial_ordering::unordered);
+ assert((T1(1, 2, std::numeric_limits<double>::quiet_NaN()) <=> T2(1, 2, 3)) == std::partial_ordering::unordered);
+ }
+ // Ordering classes and synthesized three way comparison
+ {
+ typedef std::tuple<long, int, unsigned int> T1;
+ typedef std::tuple<int, long, unsigned short> T2;
+ // All strongly ordered members yields strong ordering.
+ ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::strong_ordering);
+ }
+ {
+ struct WeakSpaceship {
+ constexpr bool operator==(const WeakSpaceship&) const { return true; }
+ constexpr std::weak_ordering operator<=>(const WeakSpaceship&) const { return std::weak_ordering::equivalent; }
+ };
+ {
+ typedef std::tuple<int, unsigned int, WeakSpaceship> T1;
+ typedef std::tuple<int, unsigned long, WeakSpaceship> T2;
+ // Strongly ordered members and a weakly ordered member yields weak ordering.
+ ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::weak_ordering);
+ }
+ {
+ typedef std::tuple<unsigned int, int, WeakSpaceship> T1;
+ typedef std::tuple<double, long, WeakSpaceship> T2;
+ // Doubles are partially ordered, so one partial, one strong, and one weak ordering
+ // yields partial ordering.
+ ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::partial_ordering);
+ }
+ }
+ {
+ struct NoSpaceship {
+ constexpr bool operator==(const NoSpaceship&) const { return true; }
+ constexpr bool operator<(const NoSpaceship&) const { return false; }
+ };
+ typedef std::tuple<int, unsigned int, NoSpaceship> T1;
+ typedef std::tuple<int, unsigned long, NoSpaceship> T2;
+ // Strongly ordered members and a weakly ordered member (synthesized) yields weak ordering.
+ ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::weak_ordering);
+ }
+ {
+ struct SpaceshipNoEquals {
+ constexpr std::strong_ordering operator<=>(const SpaceshipNoEquals&) const { return std::strong_ordering::equal; }
+ constexpr bool operator<(const SpaceshipNoEquals&) const { return false; }
+ };
+ typedef std::tuple<int, unsigned int, SpaceshipNoEquals> T1;
+ typedef std::tuple<int, unsigned long, SpaceshipNoEquals> T2;
+ // Spaceship operator with no == operator falls back on the < operator and weak ordering.
+ ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::weak_ordering);
+ }
+ {
+ struct CustomSpaceship {
+ constexpr CustomEquality operator<=>(const CustomSpaceship&) const { return CustomEquality(); }
+ };
+ typedef std::tuple<int, unsigned int, CustomSpaceship> T1;
+ typedef std::tuple<short, unsigned long, CustomSpaceship> T2;
+ typedef std::tuple<CustomSpaceship> T3;
+ // Custom three way return types cannot be used in synthesized three way comparison,
+ // but they can be used for (rewritten) operator< when synthesizing a weak ordering.
+ ASSERT_SAME_TYPE(decltype(T1() <=> T2()), std::weak_ordering);
+ ASSERT_SAME_TYPE(decltype(T3() <=> T3()), std::weak_ordering);
+ }
+
+ return true;
+}
+
+int main(int, char**) {
+ static_assert(test());
+ assert(test());
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way_incompatible.compile.pass.cpp b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way_incompatible.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/three_way_incompatible.compile.pass.cpp
@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template<class... TTypes, class... UTypes>
+// auto
+// operator<=>(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, libcpp-no-concepts
+
+#include <tuple>
+
+template <class T, class U>
+concept can_compare = requires(T t, U u) { t <=> u; };
+
+typedef std::tuple<int> T1;
+typedef std::tuple<int, long> T2;
+
+static_assert(!can_compare<T1, T2>, "");
+static_assert(!can_compare<T2, T1>, "");