[libc++][chrono] Adds operator<=> for day.

[Mordante]

Summary

Since the calendar classes were introduced in C++20 there's no need to
keep the old comparison operators.

This commit does the day calender class, the other calendar classes will
be in a followup commit.

Implements parts of:

• P1614R2 The mothership has landed

[ldionne]

libcxx/include/chrono

16

We have a test for mandated inclusions, does it need to be updated?

libcxx/test/support/test_comparisons.h

10–13 ↗

(On Diff #440048)

Suggestion:

FooOrder<expected-ordering> => All seven comparison operators
FooComparison => All six pre-C++20 comparison operators
FooEqual => operator== and operator!=

This can be done in a separate patch. I don't think we actually need to have a separate FooES for testing operator== and operator<=> only, if that's already tested in FooOrder (which would then test all 7 operators).

134–135 ↗

(On Diff #440048)

Funky indentation.

[Mordante]

Addresses review comments.

Most new changes will be moved to a separate patch.

[Mordante]

Rebase on landed 129578 to test CI.

libcxx/include/__chrono/day.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_DAY_H
 #define _LIBCPP___CHRONO_DAY_H
 
 #include <__chrono/duration.h>
 #include <__config>
+#include <compare>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD
public:
     _LIBCPP_HIDE_FROM_ABI inline constexpr bool ok() const noexcept { return __d >= 1 && __d <= 31; }
   };
 
 
 _LIBCPP_HIDE_FROM_ABI inline constexpr
 bool operator==(const day& __lhs, const day& __rhs) noexcept
 { return static_cast<unsigned>(__lhs) == static_cast<unsigned>(__rhs); }
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator!=(const day& __lhs, const day& __rhs) noexcept
-{ return !(__lhs == __rhs); }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator< (const day& __lhs, const day& __rhs) noexcept
-{ return static_cast<unsigned>(__lhs) <  static_cast<unsigned>(__rhs); }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator> (const day& __lhs, const day& __rhs) noexcept
-{ return __rhs < __lhs; }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator<=(const day& __lhs, const day& __rhs) noexcept
-{ return !(__rhs < __lhs);}
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator>=(const day& __lhs, const day& __rhs) noexcept
-{ return !(__lhs < __rhs); }
+_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering operator<=>(const day& __lhs, const day& __rhs) noexcept {
+  return static_cast<unsigned>(__lhs) <=> static_cast<unsigned>(__rhs);
+}
 
 _LIBCPP_HIDE_FROM_ABI inline constexpr
 day operator+ (const day& __lhs, const days& __rhs) noexcept
 { return day(static_cast<unsigned>(__lhs) + __rhs.count()); }
 
 _LIBCPP_HIDE_FROM_ABI inline constexpr
 day operator+ (const days& __lhs, const day& __rhs) noexcept
 { return __rhs + __lhs; }

libcxx/include/chrono

 // -*- 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
 #define _LIBCPP_CHRONO
 
 /*
     chrono synopsis
 
+#include <compare> // C++20
+
 namespace std
 {
 namespace chrono
 {
 
 template <class ToDuration, class Rep, class Period>
 constexpr
 ToDuration

 
 // 25.8.2, class last_spec    // C++20
 struct last_spec;
 
 // 25.8.3, class day          // C++20
 
 class day;
 constexpr bool operator==(const day& x, const day& y) noexcept;
-constexpr bool operator!=(const day& x, const day& y) noexcept;
-constexpr bool operator< (const day& x, const day& y) noexcept;
-constexpr bool operator> (const day& x, const day& y) noexcept;
-constexpr bool operator<=(const day& x, const day& y) noexcept;
-constexpr bool operator>=(const day& x, const day& y) noexcept;
+constexpr strong_ordering operator<=>(const day& x, const day& y) noexcept;
 constexpr day  operator+(const day&  x, const days& y) noexcept;
 constexpr day  operator+(const days& x, const day&  y) noexcept;
 constexpr day  operator-(const day&  x, const days& y) noexcept;
 constexpr days operator-(const day&  x, const day&  y) noexcept;
 
 // 25.8.4, class month    // C++20
 class month;
 constexpr bool operator==(const month& x, const month& y) noexcept;

 #include <__chrono/system_clock.h>
 #include <__chrono/time_point.h>
 #include <__chrono/weekday.h>
 #include <__chrono/year.h>
 #include <__chrono/year_month.h>
 #include <__chrono/year_month_day.h>
 #include <__chrono/year_month_weekday.h>
 #include <__config>
-#include <compare>
 #include <version>
 
+// standard-mandated includes
+#include <compare>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_CHRONO

libcxx/test/std/time/time.cal/time.cal.day/time.cal.day.nonmembers/comparisons.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>
 // class day;
 
 // constexpr bool operator==(const day& x, const day& y) noexcept;
 //   Returns: unsigned{x} == unsigned{y}.
-// constexpr bool operator<(const day& x, const day& y) noexcept;
-//   Returns: unsigned{x} < unsigned{y}.
-
+// constexpr strong_ordering operator<=>(const day& x, const day& y) noexcept;
+//   Returns: unsigned{x} <=> unsigned{y}.
 
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main(int, char**)
-{
-    using day = std::chrono::day;
+constexpr bool test() {
 
-    AssertComparisonsAreNoexcept<day>();
-    AssertComparisonsReturnBool<day>();
-
-    static_assert(testComparisonsValues<day>(0U, 0U), "");
-    static_assert(testComparisonsValues<day>(0U, 1U), "");
-
-    //  Some 'ok' values as well
-    static_assert(testComparisonsValues<day>( 5U,  5U), "");
-    static_assert(testComparisonsValues<day>( 5U, 10U), "");
+  // Validate invalid values. The range [0, 255] is guaranteed to be allowed.
+  assert(testOrderValues<day>(0U, 0U));
+  assert(testOrderValues<day>(0U, 1U));
+  assert(testOrderValues<day>(254U, 255U));
+  assert(testOrderValues<day>(255U, 255U));
 
-    for (unsigned i = 1; i < 10; ++i)
-        for (unsigned j = 1; j < 10; ++j)
-            assert(testComparisonsValues<day>(i, j));
+  // Validate some valid values.
+      assert(testOrderValues<day>(i, j));
+
+  return true;
+}
+
+int main(int, char**) {
+  using day = std::chrono::day;
+  AssertOrderAreNoexcept<day>();
+  AssertOrderReturn<std::strong_ordering, day>();
+
+  test();
+  static_assert(test());
 
   return 0;
 }