Implement P0972R0: <chrono> zero(), min(), and max() should be noexcept

[mclow.lists]

Summary

This paper is up for a vote in San Diego next week.

Note: I marked the calls as noexcept all the time, not just for C++20 - because we have freedom to do that.

[EricWF]

Note: I marked the calls as noexcept all the time, not just for C++20 - because we have freedom to do that.
However, the tests just check when we're building for C++20.

I think this should be subject to the Beyonce rule: If you like the behavior, put a test on it.
I think we should use LIBCPP_ASSERT_NOEXCEPT to test our behavior pre-c++2a.

Other then that, this patch LGTM.

[ldionne]

LGTM too, but I agree w/ Eric regarding the tests. Also, the link to p0927r2 doesn't seem right.

[mclow.lists]

Added libc++-specific tests. Fixed link in summary.

[mclow.lists]

Committed revision 346766

include/chrono

 struct duration_values
 {
 public:
-    static constexpr Rep zero();
-    static constexpr Rep max();
-    static constexpr Rep min();
+    static constexpr Rep zero(); // noexcept in C++20
+    static constexpr Rep max();  // noexcept in C++20
+    static constexpr Rep min();  // noexcept in C++20
 };
 
 // duration

 
     // special values
 
-    static constexpr duration zero();
-    static constexpr duration min();
-    static constexpr duration max();
+    static constexpr duration zero(); // noexcept in C++20
+    static constexpr duration min();  // noexcept in C++20
+    static constexpr duration max();  // noexcept in C++20
 };
 
 typedef duration<long long,         nano> nanoseconds;

 
     // special values
 
-    static constexpr time_point min();
-    static constexpr time_point max();
+    static constexpr time_point min();  // noexcept in C++20
+    static constexpr time_point max();  // noexcept in C++20
 };
 
 } // chrono

 struct _LIBCPP_TEMPLATE_VIS duration_values
 {
 public:
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep zero() {return _Rep(0);}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep max()  {return numeric_limits<_Rep>::max();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep min()  {return numeric_limits<_Rep>::lowest();}
+    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep zero() _NOEXCEPT {return _Rep(0);}
+    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep max()  _NOEXCEPT {return numeric_limits<_Rep>::max();}
+    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep min()  _NOEXCEPT {return numeric_limits<_Rep>::lowest();}
 };
 
 #if _LIBCPP_STD_VER > 14

 
     // special values
 
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration zero() {return duration(duration_values<rep>::zero());}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration min()  {return duration(duration_values<rep>::min());}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration max()  {return duration(duration_values<rep>::max());}
+    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration zero() _NOEXCEPT {return duration(duration_values<rep>::zero());}
+    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration min()  _NOEXCEPT {return duration(duration_values<rep>::min());}
+    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration max()  _NOEXCEPT {return duration(duration_values<rep>::max());}
 };
 
 typedef duration<long long,         nano> nanoseconds;

 
     // special values
 
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point min() {return time_point(duration::min());}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point max() {return time_point(duration::max());}
+    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point min() _NOEXCEPT {return time_point(duration::min());}
+    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point max() _NOEXCEPT {return time_point(duration::max());}
 };
 
 } // chrono

test/std/utilities/time/time.duration/time.duration.special/max.pass.cpp

 
 // duration
 
-// static constexpr duration max();
+// static constexpr duration max(); // noexcept after C++17
 
 #include <chrono>
 #include <limits>

 template <class D>
 void test()
 {
+#if TEST_STD_VER > 17
+  ASSERT_NOEXCEPT(std::chrono::duration_values<typename D::rep>::max());
+#endif
     {
     typedef typename D::rep Rep;
     Rep max_rep = std::chrono::duration_values<Rep>::max();

test/std/utilities/time/time.duration/time.duration.special/min.pass.cpp

 
 // duration
 
-// static constexpr duration min();
+// static constexpr duration min(); // noexcept after C++17
 
 #include <chrono>
 #include <limits>

 template <class D>
 void test()
 {
+#if TEST_STD_VER > 17
+  ASSERT_NOEXCEPT(std::chrono::duration_values<typename D::rep>::min());
+#endif
     {
     typedef typename D::rep Rep;
     Rep min_rep = std::chrono::duration_values<Rep>::min();

test/std/utilities/time/time.duration/time.duration.special/zero.pass.cpp

 
 // duration
 
-// static constexpr duration zero();
+// static constexpr duration zero(); // noexcept after C++17
 
 #include <chrono>
 #include <cassert>

 template <class D>
 void test()
 {
+#if TEST_STD_VER > 17
+  ASSERT_NOEXCEPT(std::chrono::duration_values<typename D::rep>::zero());
+#endif
     {
     typedef typename D::rep Rep;
     Rep zero_rep = std::chrono::duration_values<Rep>::zero();

test/std/utilities/time/time.point/time.point.special/max.pass.cpp

 
 // time_point
 
-// static constexpr time_point max();
+// static constexpr time_point max(); // noexcept after C++17
 
 #include <chrono>
 #include <cassert>

     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds Duration;
     typedef std::chrono::time_point<Clock, Duration> TP;
+#if TEST_STD_VER > 17
+  ASSERT_NOEXCEPT(TP::max());
+#endif
     assert(TP::max() == TP(Duration::max()));
 }

test/std/utilities/time/time.point/time.point.special/min.pass.cpp

 
 // time_point
 
-// static constexpr time_point min();
+// static constexpr time_point min(); // noexcept after C++17
 
 #include <chrono>
 #include <cassert>

     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds Duration;
     typedef std::chrono::time_point<Clock, Duration> TP;
+#if TEST_STD_VER > 17
+  ASSERT_NOEXCEPT(TP::max());
+#endif
     assert(TP::min() == TP(Duration::min()));
 }

test/std/utilities/time/time.traits/time.traits.duration_values/max.pass.cpp

 
 // <chrono>
 
-// duration_values::max
+// duration_values::max  // noexcept after C++17
 
 #include <chrono>
 #include <limits>

     static_assert(std::chrono::duration_values<Rep>::max() ==
            std::numeric_limits<Rep>::max(), "");
 #endif
+
+#if TEST_STD_VER > 17
+  ASSERT_NOEXCEPT(std::chrono::duration_values<int>::max());
+  ASSERT_NOEXCEPT(std::chrono::duration_values<double>::max());
+  ASSERT_NOEXCEPT(std::chrono::duration_values<Rep>::max());
+#endif
 }

test/std/utilities/time/time.traits/time.traits.duration_values/min.pass.cpp

 
 // <chrono>
 
-// duration_values::min
+// duration_values::min  // noexcept after C++17
 
 #include <chrono>
 #include <limits>

     static_assert(std::chrono::duration_values<Rep>::min() ==
            std::numeric_limits<Rep>::lowest(), "");
 #endif
+
+#if TEST_STD_VER > 17
+  ASSERT_NOEXCEPT(std::chrono::duration_values<int>::min());
+  ASSERT_NOEXCEPT(std::chrono::duration_values<double>::min());
+  ASSERT_NOEXCEPT(std::chrono::duration_values<Rep>::min());
+#endif
 }

test/std/utilities/time/time.traits/time.traits.duration_values/zero.pass.cpp

 
 // <chrono>
 
-// duration_values::zero
+// duration_values::zero  // noexcept after C++17
 
 #include <chrono>
 #include <cassert>

     static_assert(std::chrono::duration_values<int>::zero() == 0, "");
     static_assert(std::chrono::duration_values<Rep>::zero() == 0, "");
 #endif
+
+#if TEST_STD_VER > 17
+  ASSERT_NOEXCEPT(std::chrono::duration_values<int>::zero());
+  ASSERT_NOEXCEPT(std::chrono::duration_values<Rep>::zero());
+#endif
 }