[libc++][spaceship] Implement `operator<=>` for `optional`

[H-G-Hristov]

Summary

Implements parts of P1614R2: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1614r2.html

• Implemented operator<=> for optional
• Updated "optional synopsis" to match the current draft https://eel.is/c++draft/optional closer
• Implemented https://cplusplus.github.io/LWG/issue3566
• Implemented https://cplusplus.github.io/LWG/issue3746

[H-G-Hristov]

• Updated SpaceshipProjects.csv

[H-G-Hristov]

Rebased

[H-G-Hristov]

• Fix CI

[H-G-Hristov]

Fix CI

[H-G-Hristov]

Run CI

[H-G-Hristov]

Run CI

[H-G-Hristov]

• Minor tweak

[H-G-Hristov]

Run CI

[H-G-Hristov]

Rebased

[philnik]

libcxx/docs/Status/SpaceshipProjects.csv

25

It looks like this patch implements LWG3566. If that's the case, please mark it as completed.

libcxx/include/optional

1330

Please clang-format the new code.

1431

This should just be an #else AFAICT.

1588

Please implement LWG3746.

libcxx/test/std/utilities/optional/optional.comp_with_t/compare.three_way.pass.cpp

26

Please add a SFINAE test for the three_way_comparable_with constraint.

29

Please also add tests for a user-defined type that is comparable to int.

libcxx/test/std/utilities/optional/optional.relops/compare.three_way.pass.cpp

27–30

Also, let's use two optionals to make sure it's not comparing addresses or something like that.

31

Please also add tests where one of the optionals has a value (both left and right).

[H-G-Hristov]

Thank you for the review.

• Addressed comments

[H-G-Hristov]

• Implemented LWG3746

[H-G-Hristov]

• Minor tweaks

[H-G-Hristov]

Ping @philnik

The CI issue is unrelated.

Sorry if personal pings are unacceptable!

[philnik]

In D146392#4301291, @H-G-Hristov wrote:

Ping @philnik

The CI issue is unrelated.

Sorry if personal pings are unacceptable!

That's fine (and even important in some cases), especially if the person requested changes.

LGTM with the last comment addressed.

libcxx/test/std/utilities/optional/optional.comp_with_t/compare.three_way.pass.cpp

29

I wanted you to test that it doesn't convert 'U' to 'T' :D (The other tests are also nice though)

35–76

I don't think any of this is necessary. You don't have to make it work like an int to make it comparable to an int.

[H-G-Hristov]

• Addressed comments

[H-G-Hristov]

Rebased

[H-G-Hristov]

Thank you for the review. I think I have addressed your comment. I just don't get what's going on with the CI. I haven't seen a green build for over a week.

[H-G-Hristov]

Rebased

[Mordante]

In D146392#4308372, @H-G-Hristov wrote:

Thank you for the review. I think I have addressed your comment. I just don't get what's going on with the CI. I haven't seen a green build for over a week.

The santizers are known to be buggy at the moment. The others should work again.

libcxx/include/optional

1431

Typically we use the same condition in the comments. I was confused you wanted to use operator<=> before C++20.

[H-G-Hristov]

• Addressed comments

[H-G-Hristov]

In D146392#4310020, @Mordante wrote:

In D146392#4308372, @H-G-Hristov wrote:

Thank you for the review. I think I have addressed your comment. I just don't get what's going on with the CI. I haven't seen a green build for over a week.

The santizers are known to be buggy at the moment. The others should work again.

@Mordante Thank you for the remark. It looks like I marked the comment as done but failed to do it.

In most of my revisions I see: merge_guards_bot fail and no other info or at least I don't know what to look for.

[ldionne]

LGTM. The CI is passing if you know where to look. Thanks a lot for the patch!

libcxx/docs/Status/Cxx2bIssues.csv

 `3498 <https://wg21.link/LWG3498>`__,"Inconsistent ``noexcept``-specifiers for ``basic_syncbuf``","October 2021","",""
 `3535 <https://wg21.link/LWG3535>`__,"``join_view::iterator::iterator_category`` and ``::iterator_concept`` lie","October 2021","|Complete|","15.0","|ranges|"
 `3554 <https://wg21.link/LWG3554>`__,"``chrono::parse`` needs ``const charT*`` and ``basic_string_view<charT>`` overloads","October 2021","","","|chrono|"
 `3557 <https://wg21.link/LWG3557>`__,"The ``static_cast`` expression in ``convertible_to`` has the wrong operand","October 2021","|Complete|","14.0"
 `3559 <https://wg21.link/LWG3559>`__,"Semantic requirements of ``sized_range`` is circular","October 2021","|Nothing To Do|","","|ranges|"
 `3560 <https://wg21.link/LWG3560>`__,"``ranges::equal`` and ``ranges::is_permutation`` should short-circuit for ``sized_ranges``","October 2021","","","|ranges|"
 `3561 <https://wg21.link/LWG3561>`__,"Issue with internal counter in ``discard_block_engine``","October 2021","",""
 `3563 <https://wg21.link/LWG3563>`__,"``keys_view`` example is broken","October 2021","","","|ranges|"
-`3566 <https://wg21.link/LWG3566>`__,"Constraint recursion for ``operator<=>(optional<T>, U)``","October 2021","","","|spaceship|"
+`3566 <https://wg21.link/LWG3566>`__,"Constraint recursion for ``operator<=>(optional<T>, U)``","October 2021","Complete","17.0","|spaceship|"
 `3567 <https://wg21.link/LWG3567>`__,"Formatting move-only iterators take two","October 2021","|Complete|","16.0","|format| |ranges|"
 `3568 <https://wg21.link/LWG3568>`__,"``basic_istream_view`` needs to initialize ``value_``","October 2021","|Complete|","16.0","|ranges|"
 `3570 <https://wg21.link/LWG3570>`__,"``basic_osyncstream::emit`` should be an unformatted output function","October 2021","",""
 `3571 <https://wg21.link/LWG3571>`__,"``flush_emit`` should set ``badbit`` if the ``emit`` call fails","October 2021","",""
 `3572 <https://wg21.link/LWG3572>`__,"``copyable-box`` should be fully ``constexpr``","October 2021","|Complete|","14.0","|ranges|"
 `3573 <https://wg21.link/LWG3573>`__,"Missing Throws element for ``basic_string_view(It begin, End end)``","October 2021","|Complete|","14.0"
 `3574 <https://wg21.link/LWG3574>`__,"``common_iterator`` should be completely ``constexpr``-able","October 2021","|Complete|","14.0","|ranges|"
 `3580 <https://wg21.link/LWG3580>`__,"``iota_view``'s ``iterator``'s binary ``operator+`` should be improved","October 2021","|Complete|","14.0","|ranges|"

 "`3677 <https://wg21.link/LWG3677>`__","Is a cv-qualified ``pair`` specially handled in uses-allocator construction?", "November 2022","","",""
 "`3717 <https://wg21.link/LWG3717>`__","``common_view::end`` should improve ``random_access_range`` case", "November 2022","","","|ranges|"
 "`3732 <https://wg21.link/LWG3732>`__","``prepend_range`` and ``append_range`` can't be amortized constant time", "November 2022","|Nothing to do|","","|ranges|"
 "`3736 <https://wg21.link/LWG3736>`__","``move_iterator`` missing ``disable_sized_sentinel_for`` specialization", "November 2022","","","|ranges|"
 "`3737 <https://wg21.link/LWG3737>`__","``take_view::sentinel`` should provide ``operator-``", "November 2022","","","|ranges|"
 "`3738 <https://wg21.link/LWG3738>`__","Missing preconditions for ``take_view`` constructor", "November 2022","|Complete|","16.0","|ranges|"
 "`3743 <https://wg21.link/LWG3743>`__","``ranges::to``'s reserve may be ill-formed", "November 2022","","","|ranges|"
 "`3745 <https://wg21.link/LWG3745>`__","``std::atomic_wait`` and its friends lack ``noexcept``", "November 2022","|Complete|","16.0",""
-"`3746 <https://wg21.link/LWG3746>`__","``optional``'s spaceship with ``U`` with a type derived from optional causes infinite constraint meta-recursion", "November 2022","","","|spaceship|"
+"`3746 <https://wg21.link/LWG3746>`__","``optional``'s spaceship with ``U`` with a type derived from optional causes infinite constraint meta-recursion", "November 2022","Complete","17.0","|spaceship|"
 "`3747 <https://wg21.link/LWG3747>`__","``ranges::uninitialized_copy_n``, ``ranges::uninitialized_move_n``, and ``ranges::destroy_n`` should use ``std::move``", "November 2022","","","|ranges|"
 "`3750 <https://wg21.link/LWG3750>`__","Too many papers bump ``__cpp_lib_format``", "November 2022","","","|format|"
 "`3751 <https://wg21.link/LWG3751>`__","Missing feature macro for ``flat_set``", "November 2022","","","|flat_containers|"
 "`3753 <https://wg21.link/LWG3753>`__","Clarify entity vs. freestanding entity", "November 2022","","",""
 "`3754 <https://wg21.link/LWG3754>`__","Class template expected synopsis contains declarations that do not match the detailed description", "November 2022","|Nothing to do|","",""
 "`3755 <https://wg21.link/LWG3755>`__","``tuple-for-each`` can call ``user-defined`` ``operator,``", "November 2022","|Complete|","17.0",""
 "`3757 <https://wg21.link/LWG3757>`__","What's the effect of ``std::forward_like<void>(x)``?", "November 2022","","",""
 "`3759 <https://wg21.link/LWG3759>`__","``ranges::rotate_copy`` should use ``std::move``", "November 2022","","","|ranges|"

libcxx/docs/Status/SpaceshipProjects.csv

 | `[pairs.spec] <https://wg21.link/pairs.spec>`_,| `pair <https://reviews.llvm.org/D107721>`_,[expos.only.func],Kent Ross,|Complete|
 | `[syserr.errcat.nonvirtuals] <https://wg21.link/syserr.errcat.nonvirtuals>`_,| `error_category <https://reviews.llvm.org/D131363>`_,[comparisons.three.way],Adrian Vogelsgesang,|Complete|
 | `[syserr.compare] <https://wg21.link/syserr.compare>`_,"| `error_code <https://reviews.llvm.org/D131371>`_
 | `error_condition <https://reviews.llvm.org/D131371>`_",None,Adrian Vogelsgesang,|Complete|
 | `[tuple.rel] <https://wg21.link/tuple.rel>`_,| `tuple <https://reviews.llvm.org/D108250>`_,[expos.only.func],Kent Ross,|Complete|
 "| `[optional.relops] <https://wg21.link/optional.relops>`_
 | `[optional.nullops] <https://wg21.link/optional.nullops>`_
 | `[optional.comp.with.t] <https://wg21.link/optional.comp.with.t>`_","| `optional <https://reviews.llvm.org/D146392>`_
-| `nullopt <https://reviews.llvm.org/D146392>`_",None,Hristo Hristov,|In Progress|
+| `nullopt <https://reviews.llvm.org/D146392>`_",None,Hristo Hristov,|Complete|
 "| `[variant.relops] <https://wg21.link/variant.relops>`_
 | `[variant.monostate.relops] <https://wg21.link/variant.monostate.relops>`_","| `monostate <https://reviews.llvm.org/D131372>`_
 | `variant <https://reviews.llvm.org/D131372>`_",None,Kent Ross,|Complete|
 | `[unique.ptr.special] <https://wg21.link/unique.ptr.special>`_,| `unique_ptr <https://reviews.llvm.org/D130838>`_,[comparisons.three.way],Adrian Vogelsgesang,|Complete|
 | `[util.smartptr.shared.cmp] <https://wg21.link/util.smartptr.shared.cmp>`_,| `shared_ptr <https://reviews.llvm.org/D130852>`_,[comparisons.three.way],Adrian Vogelsgesang,|Complete|
 | `[type.index.members] <https://wg21.link/type.index.members>`_,| `type_index <https://reviews.llvm.org/D131357>`_,None,Adrian Vogelsgesang,|Complete|
 | `[charconv.syn] <https://wg21.link/charconv.syn>`_,| `to_chars_result <https://reviews.llvm.org/D112366>`_,None,Mark de Wever,|Complete|
 | `[charconv.syn] <https://wg21.link/charconv.syn>`_,| `from_chars_result <https://reviews.llvm.org/D112366>`_,None,Mark de Wever,|Complete|

libcxx/include/optional

 #define _LIBCPP_OPTIONAL
 
 /*
     optional synopsis
 
 // C++1z
 
 namespace std {
-  // 23.6.3, optional for object types
-  template <class T> class optional;
+  // [optional.optional], class template optional
+  template <class T>
+    class optional;
+
+  template<class T>
+    concept is-derived-from-optional = requires(const T& t) {       // exposition only
+      []<class U>(const optional<U>&){ }(t);
+    };
 
-  // 23.6.4, no-value state indicator
+  // [optional.nullopt], no-value state indicator
   struct nullopt_t{see below };
   inline constexpr nullopt_t nullopt(unspecified );
 
-  // 23.6.5, class bad_optional_access
+  // [optional.bad.access], class bad_optional_access
   class bad_optional_access;
 
-  // 23.6.6, relational operators
+  // [optional.relops], relational operators
   template <class T, class U>
     constexpr bool operator==(const optional<T>&, const optional<U>&);
   template <class T, class U>
     constexpr bool operator!=(const optional<T>&, const optional<U>&);
   template <class T, class U>
     constexpr bool operator<(const optional<T>&, const optional<U>&);
   template <class T, class U>
     constexpr bool operator>(const optional<T>&, const optional<U>&);
   template <class T, class U>
     constexpr bool operator<=(const optional<T>&, const optional<U>&);
   template <class T, class U>
     constexpr bool operator>=(const optional<T>&, const optional<U>&);
+  template<class T, three_way_comparable_with<T> U>
+    constexpr compare_three_way_result_t<T, U>
+      operator<=>(const optional<T>&, const optional<U>&); // since C++20
 
-  // 23.6.7 comparison with nullopt
-  template <class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept;
-  template <class T> constexpr bool operator==(nullopt_t, const optional<T>&) noexcept;
-  template <class T> constexpr bool operator!=(const optional<T>&, nullopt_t) noexcept;
-  template <class T> constexpr bool operator!=(nullopt_t, const optional<T>&) noexcept;
-  template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept;
-  template <class T> constexpr bool operator<(nullopt_t, const optional<T>&) noexcept;
-  template <class T> constexpr bool operator<=(const optional<T>&, nullopt_t) noexcept;
-  template <class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept;
-  template <class T> constexpr bool operator>(const optional<T>&, nullopt_t) noexcept;
-  template <class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept;
-  template <class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept;
-  template <class T> constexpr bool operator>=(nullopt_t, const optional<T>&) noexcept;
+  // [optional.nullops], comparison with nullopt
+  template<class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept;
+  template<class T> constexpr bool operator==(nullopt_t, const optional<T>&) noexcept; // until C++17
+  template<class T> constexpr bool operator!=(const optional<T>&, nullopt_t) noexcept; // until C++17
+  template<class T> constexpr bool operator!=(nullopt_t, const optional<T>&) noexcept; // until C++17
+  template<class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept;  // until C++17
+  template<class T> constexpr bool operator<(nullopt_t, const optional<T>&) noexcept;  // until C++17
+  template<class T> constexpr bool operator<=(const optional<T>&, nullopt_t) noexcept; // until C++17
+  template<class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept; // until C++17
+  template<class T> constexpr bool operator>(const optional<T>&, nullopt_t) noexcept;  // until C++17
+  template<class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept;  // until C++17
+  template<class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept; // until C++17
+  template<class T> constexpr bool operator>=(nullopt_t, const optional<T>&) noexcept; // until C++17
+  template<class T>
+    constexpr strong_ordering operator<=>(const optional<T>&, nullopt_t) noexcept;     // since C++20
 
-  // 23.6.8, comparison with T
-  template <class T, class U> constexpr bool operator==(const optional<T>&, const U&);
-  template <class T, class U> constexpr bool operator==(const T&, const optional<U>&);
-  template <class T, class U> constexpr bool operator!=(const optional<T>&, const U&);
-  template <class T, class U> constexpr bool operator!=(const T&, const optional<U>&);
-  template <class T, class U> constexpr bool operator<(const optional<T>&, const U&);
-  template <class T, class U> constexpr bool operator<(const T&, const optional<U>&);
-  template <class T, class U> constexpr bool operator<=(const optional<T>&, const U&);
-  template <class T, class U> constexpr bool operator<=(const T&, const optional<U>&);
-  template <class T, class U> constexpr bool operator>(const optional<T>&, const U&);
-  template <class T, class U> constexpr bool operator>(const T&, const optional<U>&);
-  template <class T, class U> constexpr bool operator>=(const optional<T>&, const U&);
-  template <class T, class U> constexpr bool operator>=(const T&, const optional<U>&);
+  // [optional.comp.with.t], comparison with T
+  template<class T, class U> constexpr bool operator==(const optional<T>&, const U&);
+  template<class T, class U> constexpr bool operator==(const T&, const optional<U>&);
+  template<class T, class U> constexpr bool operator!=(const optional<T>&, const U&);
+  template<class T, class U> constexpr bool operator!=(const T&, const optional<U>&);
+  template<class T, class U> constexpr bool operator<(const optional<T>&, const U&);
+  template<class T, class U> constexpr bool operator<(const T&, const optional<U>&);
+  template<class T, class U> constexpr bool operator<=(const optional<T>&, const U&);
+  template<class T, class U> constexpr bool operator<=(const T&, const optional<U>&);
+  template<class T, class U> constexpr bool operator>(const optional<T>&, const U&);
+  template<class T, class U> constexpr bool operator>(const T&, const optional<U>&);
+  template<class T, class U> constexpr bool operator>=(const optional<T>&, const U&);
+  template<class T, class U> constexpr bool operator>=(const T&, const optional<U>&);
+  template<class T, class U>
+      requires (!is-derived-from-optional<U>) && three_way_comparable_with<T, U>
+    constexpr compare_three_way_result_t<T, U>
+      operator<=>(const optional<T>&, const U&);                                       // since C++20
+
+  // [optional.specalg], specialized algorithms
+  template<class T>
+    void swap(optional<T>&, optional<T>&) noexcept(see below ); // constexpr in C++20
 
-  // 23.6.9, specialized algorithms
-  template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below ); // constexpr in C++20
-  template <class T> constexpr optional<see below > make_optional(T&&);
-  template <class T, class... Args>
+  template<class T>
+    constexpr optional<see below > make_optional(T&&);
+  template<class T, class... Args>
     constexpr optional<T> make_optional(Args&&... args);
-  template <class T, class U, class... Args>
+  template<class T, class U, class... Args>
     constexpr optional<T> make_optional(initializer_list<U> il, Args&&... args);
 
-  // 23.6.10, hash support
-  template <class T> struct hash;
-  template <class T> struct hash<optional<T>>;
+  // [optional.hash], hash support
+  template<class T> struct hash;
+  template<class T> struct hash<optional<T>>;
 
-  template <class T> class optional {
+  template<class T>
+  class optional {
   public:
     using value_type = T;
 
-    // 23.6.3.1, constructors
+    // [optional.ctor], constructors
     constexpr optional() noexcept;
     constexpr optional(nullopt_t) noexcept;
     constexpr optional(const optional &);
     constexpr optional(optional &&) noexcept(see below);
-    template <class... Args> constexpr explicit optional(in_place_t, Args &&...);
-    template <class U, class... Args>
+    template<class... Args>
+      constexpr explicit optional(in_place_t, Args &&...);
+    template<class U, class... Args>
       constexpr explicit optional(in_place_t, initializer_list<U>, Args &&...);
-    template <class U = T>
+    template<class U = T>
       constexpr explicit(see-below) optional(U &&);
-    template <class U>
-      explicit(see-below) optional(const optional<U> &);         // constexpr in C++20
-    template <class U>
-      explicit(see-below) optional(optional<U> &&);              // constexpr in C++20
+    template<class U>
+      explicit(see-below) optional(const optional<U> &);                          // constexpr in C++20
+    template<class U>
+      explicit(see-below) optional(optional<U> &&);                               // constexpr in C++20
 
-    // 23.6.3.2, destructor
+    // [optional.dtor], destructor
     ~optional(); // constexpr in C++20
 
-    // 23.6.3.3, assignment
-    optional &operator=(nullopt_t) noexcept;                     // constexpr in C++20
+    // [optional.assign], assignment
+    optional &operator=(nullopt_t) noexcept;                                      // constexpr in C++20
     constexpr optional &operator=(const optional &);
     constexpr optional &operator=(optional &&) noexcept(see below);
-    template <class U = T> optional &operator=(U &&);            // constexpr in C++20
-    template <class U> optional &operator=(const optional<U> &); // constexpr in C++20
-    template <class U> optional &operator=(optional<U> &&);      // constexpr in C++20
-    template <class... Args> T& emplace(Args &&...);             // constexpr in C++20
-    template <class U, class... Args>
-      T& emplace(initializer_list<U>, Args &&...);               // constexpr in C++20
+    template<class U = T> optional &operator=(U &&);                              // constexpr in C++20
+    template<class U> optional &operator=(const optional<U> &);                   // constexpr in C++20
+    template<class U> optional &operator=(optional<U> &&);                        // constexpr in C++20
+    template<class... Args> T& emplace(Args &&...);                               // constexpr in C++20
+    template<class U, class... Args> T& emplace(initializer_list<U>, Args &&...); // constexpr in C++20
 
-    // 23.6.3.4, swap
+    // [optional.swap], swap
     void swap(optional &) noexcept(see below ); // constexpr in C++20
 
-    // 23.6.3.5, observers
+    // [optional.observe], observers
     constexpr T const *operator->() const;
     constexpr T *operator->();
     constexpr T const &operator*() const &;
     constexpr T &operator*() &;
     constexpr T &&operator*() &&;
     constexpr const T &&operator*() const &&;
     constexpr explicit operator bool() const noexcept;
     constexpr bool has_value() const noexcept;
     constexpr T const &value() const &;
     constexpr T &value() &;
     constexpr T &&value() &&;
     constexpr const T &&value() const &&;
-    template <class U> constexpr T value_or(U &&) const &;
-    template <class U> constexpr T value_or(U &&) &&;
+    template<class U> constexpr T value_or(U &&) const &;
+    template<class U> constexpr T value_or(U &&) &&;
 
     // [optional.monadic], monadic operations
     template<class F> constexpr auto and_then(F&& f) &;         // since C++23
     template<class F> constexpr auto and_then(F&& f) &&;        // since C++23
     template<class F> constexpr auto and_then(F&& f) const&;    // since C++23
     template<class F> constexpr auto and_then(F&& f) const&&;   // since C++23
     template<class F> constexpr auto transform(F&& f) &;        // since C++23
     template<class F> constexpr auto transform(F&& f) &&;       // since C++23
     template<class F> constexpr auto transform(F&& f) const&;   // since C++23
     template<class F> constexpr auto transform(F&& f) const&&;  // since C++23
     template<class F> constexpr optional or_else(F&& f) &&;     // since C++23
     template<class F> constexpr optional or_else(F&& f) const&; // since C++23
 
-    // 23.6.3.6, modifiers
-    void reset() noexcept; // constexpr in C++20
+    // [optional.mod], modifiers
+    void reset() noexcept;                                      // constexpr in C++20
 
   private:
-    T *val; // exposition only
+    T *val;         // exposition only
   };
 
   template<class T>
     optional(T) -> optional<T>;
 
 } // namespace std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
+#include <__compare/compare_three_way_result.h>
+#include <__compare/three_way_comparable.h>
 #include <__concepts/invocable.h>
 #include <__config>
 #include <__functional/hash.h>
 #include <__functional/invoke.h>
 #include <__functional/unary_function.h>
 #include <__memory/addressof.h>
 #include <__memory/construct_at.h>
 #include <__tuple_dir/sfinae_helpers.h>

 template <class _Tp>
 using __optional_sfinae_assign_base_t = __sfinae_assign_base<
     (is_copy_constructible<_Tp>::value && is_copy_assignable<_Tp>::value),
     (is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value)
 >;
 
 template<class _Tp>
 class optional;
+
+#if _LIBCPP_STD_VER >= 20
+
+template <class _Tp>
+concept __is_derived_from_optional = requires(const _Tp& __t) { []<class __Up>(const optional<__Up>&) {}(__t); };
+
+#  endif // _LIBCPP_STD_VER >= 20
+
 template <class _Tp>
 struct __is_std_optional : false_type {};
 template <class _Tp> struct __is_std_optional<optional<_Tp>> : true_type {};
 
 template <class _Tp>
 class optional
     : private __optional_move_assign_base<_Tp>
     , private __optional_sfinae_ctor_base_t<_Tp>

 {
     if (!static_cast<bool>(__y))
         return true;
     if (!static_cast<bool>(__x))
         return false;
     return *__x >= *__y;
 }
 
+#if _LIBCPP_STD_VER >= 20
+
+template <class _Tp, three_way_comparable_with<_Tp> _Up>
+_LIBCPP_HIDE_FROM_ABI constexpr compare_three_way_result_t<_Tp, _Up>
+operator<=>(const optional<_Tp>& __x, const optional<_Up>& __y) {
+    if (__x && __y)
+      return *__x <=> *__y;
+    return __x.has_value() <=> __y.has_value();
+}
+
+#endif // _LIBCPP_STD_VER >= 20
+
 // Comparisons with nullopt
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY constexpr
 bool
 operator==(const optional<_Tp>& __x, nullopt_t) noexcept
 {
     return !static_cast<bool>(__x);
 }
 
+#if _LIBCPP_STD_VER <= 17
+
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY constexpr
 bool
 operator==(nullopt_t, const optional<_Tp>& __x) noexcept
 {
     return !static_cast<bool>(__x);
 }
 

 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY constexpr
 bool
 operator>=(nullopt_t, const optional<_Tp>& __x) noexcept
 {
     return !static_cast<bool>(__x);
 }
 
+#else // _LIBCPP_STD_VER >= 20
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering operator<=>(const optional<_Tp>& __x, nullopt_t) noexcept {
+    return __x.has_value() <=> false;
+}
+
+#endif // _LIBCPP_STD_VER <= 17
+
 // Comparisons with T
 template <class _Tp, class _Up>
 _LIBCPP_INLINE_VISIBILITY constexpr
 enable_if_t<
     is_convertible_v<decltype(std::declval<const _Tp&>() ==
         std::declval<const _Up&>()), bool>,
     bool
 >
is_convertible_v<decltype(std::declval<const _Tp&>() >=
         std::declval<const _Up&>()), bool>,
     bool
 >
 operator>=(const _Tp& __v, const optional<_Up>& __x)
 {
     return static_cast<bool>(__x) ? __v >= *__x : true;
 }
 
+#if _LIBCPP_STD_VER >= 20
+
+template <class _Tp, class _Up>
+  requires(!__is_std_optional<_Up>::value) && three_way_comparable_with<_Tp, _Up>
+_LIBCPP_HIDE_FROM_ABI constexpr compare_three_way_result_t<_Tp, _Up>
+operator<=>(const optional<_Tp>& __x, const _Up& __v) {
+    return __x.has_value() ? *__x <=> __v : strong_ordering::less;
+}
+
+#endif // _LIBCPP_STD_VER >= 20
+
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
 enable_if_t<
     is_move_constructible_v<_Tp> && is_swappable_v<_Tp>,
     void
 >
 swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y)))

libcxx/test/std/utilities/optional/optional.comp_with_t/compare.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
+
+// <optional>
+
+// [optional.comp.with.t], comparison with T
+
+// template<class T, class U>
+//     requires (!is-derived-from-optional<U>) && three_way_comparable_with<T, U>
+//   constexpr compare_three_way_result_t<T, U>
+//     operator<=>(const optional<T>&, const U&);
+
+#include <cassert>
+#include <compare>
+#include <optional>
+
+#include "test_comparisons.h"
+
+struct SomeInt {
+  using difference_type = int;
+
+  int value_;
+  constexpr explicit SomeInt(int value = 0) : value_(value) {}
+
+  auto operator<=>(const SomeInt&) const = default;
+
+  friend constexpr SomeInt& operator+=(SomeInt& lhs, const SomeInt& rhs) {
+    lhs.value_ += rhs.value_;
+    return lhs;
+  }
+  friend constexpr SomeInt& operator-=(SomeInt& lhs, const SomeInt& rhs) {
+    lhs.value_ -= rhs.value_;
+    return lhs;
+  }
+
+  friend constexpr SomeInt& operator+=(SomeInt& lhs, difference_type rhs) {
+    lhs.value_ += rhs;
+    return lhs;
+  }
+  friend constexpr SomeInt& operator-=(SomeInt& lhs, difference_type rhs) {
+    lhs.value_ -= rhs;
+    return lhs;
+  }
+
+  friend constexpr SomeInt operator+(SomeInt lhs, SomeInt rhs) { return SomeInt{lhs.value_ + rhs.value_}; }
+  friend constexpr int operator-(SomeInt lhs, SomeInt rhs) { return lhs.value_ - rhs.value_; }
+
+  friend constexpr SomeInt operator+(SomeInt lhs, difference_type rhs) { return SomeInt{lhs.value_ + rhs}; }
+  friend constexpr int operator-(SomeInt lhs, difference_type rhs) { return lhs.value_ - rhs; }
+
+  friend constexpr SomeInt operator+(difference_type lhs, SomeInt rhs) { return SomeInt{lhs + rhs.value_}; }
+  friend constexpr int operator-(difference_type lhs, SomeInt rhs) { return lhs - rhs.value_; }
+
+  constexpr SomeInt& operator++() {
+    ++value_;
+    return *this;
+  }
+  constexpr SomeInt operator++(int) {
+    auto tmp = *this;
+    ++value_;
+    return tmp;
+  }
+  constexpr SomeInt& operator--() {
+    --value_;
+    return *this;
+  }
+  constexpr SomeInt operator--(int) {
+    auto tmp = *this;
+    --value_;
+    return tmp;
+  }
+};
+
+template <class T, class U>
+concept HasSpaceship = requires(T t, U u) { t <=> u; };
+
+// SFINAE tests.
+
+static_assert(std::three_way_comparable_with<std::optional<int>, std::optional<int>>);
+static_assert(HasSpaceship<std::optional<int>, std::optional<int>>);
+
+static_assert(std::three_way_comparable_with<std::optional<SomeInt>, std::optional<SomeInt>>);
+static_assert(HasSpaceship<std::optional<SomeInt>, std::optional<SomeInt>>);
+
+static_assert(!HasSpaceship<std::optional<int>, std::optional<SomeInt>>);
+
+// Runtime and static tests.
+
+constexpr void test_custom_integral() {
+  {
+    SomeInt t{3};
+    std::optional<SomeInt> op{3};
+    assert((t <=> op) == std::strong_ordering::equal);
+    assert(testOrder(t, op, std::strong_ordering::equal));
+  }
+  {
+    SomeInt t{2};
+    std::optional<SomeInt> op{3};
+    assert((t <=> op) == std::strong_ordering::less);
+    assert(testOrder(t, op, std::strong_ordering::less));
+  }
+  {
+    SomeInt t{3};
+    std::optional<SomeInt> op{2};
+    assert((t <=> op) == std::strong_ordering::greater);
+    assert(testOrder(t, op, std::strong_ordering::greater));
+  }
+}
+
+constexpr void test_int() {
+  {
+    int t{3};
+    std::optional<int> op{3};
+    assert((t <=> op) == std::strong_ordering::equal);
+    assert(testOrder(t, op, std::strong_ordering::equal));
+  }
+  {
+    int t{2};
+    std::optional<int> op{3};
+    assert((t <=> op) == std::strong_ordering::less);
+    assert(testOrder(t, op, std::strong_ordering::less));
+  }
+  {
+    int t{3};
+    std::optional<int> op{2};
+    assert((t <=> op) == std::strong_ordering::greater);
+    assert(testOrder(t, op, std::strong_ordering::greater));
+  }
+}
+
+constexpr bool test() {
+  test_custom_integral();
+  test_int();
+
+  return true;
+}
+
+int main() {
+  assert(test());
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/optional/optional.nullops/compare.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
+
+// <optional>
+
+// [optional.nullops], comparison with nullopt
+
+// template<class T>
+//   constexpr strong_ordering operator<=>(const optional<T>&, nullopt_t) noexcept;
+
+#include <cassert>
+#include <compare>
+#include <optional>
+
+#include "test_comparisons.h"
+
+constexpr bool test() {
+  {
+    std::optional<int> op;
+    assert((std::nullopt <=> op) == std::strong_ordering::equal);
+    assert(testOrder(std::nullopt, op, std::strong_ordering::equal));
+    assert((op <=> std::nullopt) == std::strong_ordering::equal);
+    assert(testOrder(op, std::nullopt, std::strong_ordering::equal));
+  }
+  {
+    std::optional<int> op{1};
+    assert((std::nullopt <=> op) == std::strong_ordering::less);
+    assert(testOrder(std::nullopt, op, std::strong_ordering::less));
+  }
+  {
+    std::optional<int> op{1};
+    assert((op <=> std::nullopt) == std::strong_ordering::greater);
+    assert(testOrder(op, std::nullopt, std::strong_ordering::greater));
+  }
+
+  return true;
+}
+
+int main() {
+  assert(test());
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/optional/optional.relops/compare.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
+
+// <optional>
+
+// [optional.relops], relational operators
+
+// template<class T, three_way_comparable_with<T> U>
+//   constexpr compare_three_way_result_t<T, U>
+//     operator<=>(const optional<T>&, const optional<U>&);
+
+#include <cassert>
+#include <compare>
+#include <optional>
+
+#include "test_comparisons.h"
+
+constexpr bool test() {
+  {
+    std::optional<int> op1;
+    std::optional<int> op2;
+
+    assert((op1 <=> op2) == std::strong_ordering::equal);
+    assert(testOrder(op1, op2, std::strong_ordering::equal));
+  }
+  {
+    std::optional<int> op1{3};
+    std::optional<int> op2{3};
+    assert((op1 <=> op1) == std::strong_ordering::equal);
+    assert(testOrder(op1, op1, std::strong_ordering::equal));
+    assert((op1 <=> op2) == std::strong_ordering::equal);
+    assert(testOrder(op1, op2, std::strong_ordering::equal));
+    assert((op2 <=> op1) == std::strong_ordering::equal);
+    assert(testOrder(op2, op1, std::strong_ordering::equal));
+  }
+  {
+    std::optional<int> op;
+    std::optional<int> op1{2};
+    std::optional<int> op2{3};
+    assert((op <=> op2) == std::strong_ordering::less);
+    assert(testOrder(op, op2, std::strong_ordering::less));
+    assert((op1 <=> op2) == std::strong_ordering::less);
+    assert(testOrder(op1, op2, std::strong_ordering::less));
+  }
+  {
+    std::optional<int> op;
+    std::optional<int> op1{3};
+    std::optional<int> op2{2};
+    assert((op1 <=> op) == std::strong_ordering::greater);
+    assert(testOrder(op1, op, std::strong_ordering::greater));
+    assert((op1 <=> op2) == std::strong_ordering::greater);
+    assert(testOrder(op1, op2, std::strong_ordering::greater));
+  }
+
+  return true;
+}
+
+int main() {
+  assert(test());
+  static_assert(test());
+  return 0;
+}