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

[H-G-Hristov]

Summary

Depends on D145881

Implements parts of P1614R2: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1614r2.html
Implements operator<=> for time_point

[H-G-Hristov]

• Updated URL

[H-G-Hristov]

• Updated test

[H-G-Hristov]

• Updated test

[H-G-Hristov]

Rebased

[Mordante]

In general LGTM modulo some nits.

libcxx/test/std/time/time.point/time.point.comparisons/compare.three_way.pass.cpp

23

Pedantic, but this include is mandated not to be required. The chrono header is required to include this header.
(http://eel.is/c++draft/time.syn)

32

I would prefer to have some test where Duration::rep is a floating-point type.

[H-G-Hristov]

• Fix CI

[H-G-Hristov]

In D146250#4210818, @Mordante wrote:

In general LGTM modulo some nits.

Thank you for the review. I'll do that.

[H-G-Hristov]

• Fix CI

[H-G-Hristov]

Updated tests

[Mordante]

libcxx/test/std/time/time.point/time.point.comparisons/compare.three_way.pass.cpp

61

Instead of one big test I would suggest to use 3 smaller tests and call these 3 test from this test function.

That makes is clearer which 3 parts you are testing.

[H-G-Hristov]

• Addressed comments

[H-G-Hristov]

Thank you for the review. I think I addressed the suggestion.

[H-G-Hristov]

Run CI

[H-G-Hristov]

Rebased

[H-G-Hristov]

Run CI

[H-G-Hristov]

Rebased to run CI

[Mordante]

Thanks, LGTM!

[H-G-Hristov]

In D146250#4253091, @Mordante wrote:

Thanks, LGTM!

Thank you for the review!

libcxx/docs/Status/SpaceshipProjects.csv

 | `[stack.ops] <https://wg21.link/stack.ops>`_,| stack,None,Unassigned,|Not Started|
 | `[reverse.iter.cmp] <https://wg21.link/reverse.iter.cmp>`_,| `reverse_iterator <https://reviews.llvm.org/D113695>`_,None,Mikhail Maltsev,|Complete|
 | `[move.iter.op.comp] <https://wg21.link/move.iter.op.comp>`_,| `move_iterator <https://reviews.llvm.org/D117656>`_,None,Arthur O'Dwyer,|Complete|
 | `[counted.iter.cmp] <https://wg21.link/counted.iter.cmp>`_,| `counted_iterator <https://reviews.llvm.org/D106205>`_,None,Zoe Carver,|Complete|
 | `[range.iota.iterator] <https://wg21.link/range.iota.iterator>`_,| `ranges::iota_view::iterator <https://reviews.llvm.org/D110774>`_,[concepts.cmp],Arthur O'Dwyer,|Complete|
 | `[range.transform.iterator] <https://wg21.link/range.transform.iterator>`_,| `ranges::transform_view::iterator <https://reviews.llvm.org/D110774>`_,[concepts.cmp],Arthur O'Dwyer,|Complete|
 | `[range.elements.iterator] <https://wg21.link/range.elements.iterator>`_,| ranges::elements_view::iterator,[concepts.cmp],Hui Xie,|Complete|
 | `[time.duration.comparisons] <https://wg21.link/time.duration.comparisons>`_, `chrono::duration <https://reviews.llvm.org/D145881>`_, None, Hristo Hristov, |Complete|
-| `[time.point.comparisons] <https://wg21.link/time.point.comparisons>`_, "chrono::time_point", None, Mark de Wever, |Not Started|
+| `[time.point.comparisons] <https://wg21.link/time.point.comparisons>`_, `chrono::time_point <https://reviews.llvm.org/D146250>`_, None, Hristo Hristov, |Complete|
 "| `[time.cal.day.nonmembers] <https://wg21.link/time.cal.day.nonmembers>`_
 | `[time.cal.month.nonmembers] <https://wg21.link/time.cal.month.nonmembers>`_
 | `[time.cal.year.nonmembers] <https://wg21.link/time.cal.year.nonmembers>`_
 | `[time.cal.md.nonmembers] <https://wg21.link/time.cal.md.nonmembers>`_
 | `[time.cal.mdlast] <https://wg21.link/time.cal.mdlast>`_
 | `[time.cal.ym.nonmembers] <https://wg21.link/time.cal.ym.nonmembers>`_
 | `[time.cal.ymd.nonmembers] <https://wg21.link/time.cal.ymd.nonmembers>`_
 | `[time.cal.ymdlast.nonmembers] <https://wg21.link/time.cal.ymdlast.nonmembers>`_","| `chrono::day <https://reviews.llvm.org/D129887>`_

libcxx/include/__chrono/time_point.h

 // -*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___CHRONO_TIME_POINT_H
 #define _LIBCPP___CHRONO_TIME_POINT_H
 
 #include <__chrono/duration.h>
+#include <__compare/ordering.h>
+#include <__compare/three_way_comparable.h>
 #include <__config>
 #include <__type_traits/common_type.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_convertible.h>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

 template <class _Clock, class _Duration1, class _Duration2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
 bool
 operator==(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
 {
     return __lhs.time_since_epoch() == __rhs.time_since_epoch();
 }
 
+#if _LIBCPP_STD_VER <= 17
+
 // time_point !=
 
 template <class _Clock, class _Duration1, class _Duration2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
 bool
 operator!=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
 {
     return !(__lhs == __rhs);
 }
 
+#endif // _LIBCPP_STD_VER <= 17
+
 // time_point <
 
 template <class _Clock, class _Duration1, class _Duration2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
 bool
 operator<(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
 {
     return __lhs.time_since_epoch() < __rhs.time_since_epoch();

 template <class _Clock, class _Duration1, class _Duration2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
 bool
 operator>=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
 {
     return !(__lhs < __rhs);
 }
 
+#if _LIBCPP_STD_VER >= 20
+
+template <class _Clock, class _Duration1, three_way_comparable_with<_Duration1> _Duration2>
+_LIBCPP_HIDE_FROM_ABI constexpr auto
+operator<=>(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) {
+    return __lhs.time_since_epoch() <=> __rhs.time_since_epoch();
+}
+
+#endif // _LIBCPP_STD_VER >= 20
+
 // time_point operator+(time_point x, duration y);
 
 template <class _Clock, class _Duration1, class _Rep2, class _Period2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
 time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type>
 operator+(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 {
     typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Tr;

libcxx/include/chrono

 template <class Clock, class Duration1, class Duration2>
   typename common_type<Duration1, Duration2>::type
   operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 
 // time_point comparisons (all constexpr in C++14)
 template <class Clock, class Duration1, class Duration2>
    bool operator==(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
-   bool operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
+   bool operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); // removed in C++20
 template <class Clock, class Duration1, class Duration2>
    bool operator< (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
    bool operator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
    bool operator> (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
    bool operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
+template<class Clock, class Duration1,
+         three_way_comparable_with<Duration1> Duration2>
+  constexpr auto operator<=>(const time_point<Clock, Duration1>& lhs,
+                             const time_point<Clock, Duration2>& rhs);                                // since C++20
 
 // time_point_cast (constexpr in C++14)
 
 template <class ToDuration, class Clock, class Duration>
   time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);
 
 template <class ToDuration, class Clock, class Duration>
     constexpr time_point<Clock, ToDuration>

libcxx/test/std/time/time.point/time.point.comparisons/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
+
+// <chrono>
+
+// time_point
+
+// template<class Clock, class Duration1,
+//          three_way_comparable_with<Duration1> Duration2>
+//   constexpr auto operator<=>(const time_point<Clock, Duration1>& lhs,
+//                              const time_point<Clock, Duration2>& rhs);
+
+#include <cassert>
+#include <chrono>
+#include <ratio>
+
+#include "test_comparisons.h"
+
+constexpr bool test() {
+  using Clock     = std::chrono::system_clock;
+
+  using Duration1 = std::chrono::milliseconds;
+  using Duration2 = std::chrono::microseconds;
+  using T1        = std::chrono::time_point<Clock, Duration1>;
+  using T2        = std::chrono::time_point<Clock, Duration2>;
+
+  {
+    T1 t1(Duration1(3));
+    T1 t2(Duration1(3));
+    assert((t1 <=> t2) == std::strong_ordering::equal);
+    assert(testOrder(t1, t2, std::strong_ordering::equal));
+  }
+  {
+    T1 t1(Duration1(3));
+    T1 t2(Duration1(4));
+    assert((t1 <=> t2) == std::strong_ordering::less);
+    assert(testOrder(t1, t2, std::strong_ordering::less));
+  }
+  {
+    T1 t1(Duration1(3));
+    T2 t2(Duration2(3000));
+    assert((t1 <=> t2) == std::strong_ordering::equal);
+    assert(testOrder(t1, t2, std::strong_ordering::equal));
+  }
+  {
+    T1 t1(Duration1(3));
+    T2 t2(Duration2(3001));
+    assert((t1 <=> t2) == std::strong_ordering::less);
+    assert(testOrder(t1, t2, std::strong_ordering::less));
+    assert((t2 <=> t1) == std::strong_ordering::greater);
+    assert(testOrder(t2, t1, std::strong_ordering::greater));
+  }
+
+  using DInt30Hz = std::chrono::duration<int, std::ratio<1, 30>>;
+  using DInt60Hz = std::chrono::duration<int, std::ratio<1, 60>>;
+
+  using TIntR1 = std::chrono::time_point<Clock, DInt30Hz>;
+  using TIntR2 = std::chrono::time_point<Clock, DInt60Hz>;
+
+  {
+    TIntR1 t1(DInt30Hz(10));
+    TIntR2 t2(DInt60Hz(20));
+    assert((t1 <=> t2) == std::strong_ordering::equal);
+    assert(testOrder(t1, t2, std::strong_ordering::equal));
+  }
+  {
+    TIntR1 t1(DInt30Hz(10));
+    TIntR2 t2(DInt60Hz(21));
+    assert((t1 <=> t2) == std::strong_ordering::less);
+    assert(testOrder(t1, t2, std::strong_ordering::less));
+  }
+  {
+    TIntR1 t1(DInt30Hz(11));
+    TIntR2 t2(DInt60Hz(20));
+    assert((t1 <=> t2) == std::strong_ordering::greater);
+    assert(testOrder(t1, t2, std::strong_ordering::greater));
+  }
+
+  using DF30Hz = std::chrono::duration<double, std::ratio<1, 30>>;
+  using DF60Hz = std::chrono::duration<double, std::ratio<1, 60>>;
+  using F1 = std::chrono::time_point<Clock, DF30Hz>;
+  using F2 = std::chrono::time_point<Clock, DF60Hz>;
+
+  // Skipped equality comparison test for floating point values.
+  {
+    F1 t1(DF30Hz(3.5));
+    F2 t2(DF60Hz(7.1));
+    assert((t1 <=> t2) == std::weak_ordering::less);
+    assert(testOrder(t1, t2, std::weak_ordering::less));
+  }
+  {
+    F1 t1(DF30Hz(3.6));
+    F2 t2(DF60Hz(7.0));
+    assert((t1 <=> t2) == std::weak_ordering::greater);
+    assert(testOrder(t1, t2, std::weak_ordering::greater));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  assert(test());
+  static_assert(test());
+  return 0;
+}