Support relaxed constexpr on chrono::duration operations

[AntonBikineev]

Summary

This addresses a proposal p0505r0. Synopsis as follows:

template <class Rep, class Period = ratio<1>>
class duration {
public:
    // 20.17.5.3, arithmetic:
    constexpr duration operator+() const;
    constexpr duration operator-() const;
    constexpr duration& operator++();
    constexpr duration operator++(int);
    constexpr duration& operator--();
    constexpr duration operator--(int);

    constexpr duration& operator+=(const duration& d);
    constexpr duration& operator-=(const duration& d);

    constexpr duration& operator*=(const rep& rhs);
    constexpr duration& operator/=(const rep& rhs);
    constexpr duration& operator%=(const rep& rhs);
    constexpr duration& operator%=(const duration& rhs);
};

[mclow.lists]

This looks good to me. Don't forget to update www/cxx1z_status.html (about line 136)

[mclow.lists]

Also should have cfe-commits as a subscriber.

[EricWF]

LGTM as well.

include/chrono

public:
     // observer
 
     constexpr rep count() const;
 
     // arithmetic
 
     constexpr duration  operator+() const;
     constexpr duration  operator-() const;
-    duration& operator++();
-    duration  operator++(int);
-    duration& operator--();
-    duration  operator--(int);
-
-    duration& operator+=(const duration& d);
-    duration& operator-=(const duration& d);
-
-    duration& operator*=(const rep& rhs);
-    duration& operator/=(const rep& rhs);
+    constexpr duration& operator++();
+    constexpr duration  operator++(int);
+    constexpr duration& operator--();
+    constexpr duration  operator--(int);
+
+    constexpr duration& operator+=(const duration& d);
+    constexpr duration& operator-=(const duration& d);
+
+    constexpr duration& operator*=(const rep& rhs);
+    constexpr duration& operator/=(const rep& rhs);
+    constexpr duration& operator%=(const rep& rhs);
+    constexpr duration& operator%=(const duration& rhs);
 
     // special values
 
     static constexpr duration zero();
     static constexpr duration min();
     static constexpr duration max();
 };
 
#endif
     // observer
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR rep count() const {return __rep_;}
 
     // arithmetic
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR duration  operator+() const {return *this;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR duration  operator-() const {return duration(-__rep_);}
-    _LIBCPP_INLINE_VISIBILITY duration& operator++()      {++__rep_; return *this;}
-    _LIBCPP_INLINE_VISIBILITY duration  operator++(int)   {return duration(__rep_++);}
-    _LIBCPP_INLINE_VISIBILITY duration& operator--()      {--__rep_; return *this;}
-    _LIBCPP_INLINE_VISIBILITY duration  operator--(int)   {return duration(__rep_--);}
-
-    _LIBCPP_INLINE_VISIBILITY duration& operator+=(const duration& __d) {__rep_ += __d.count(); return *this;}
-    _LIBCPP_INLINE_VISIBILITY duration& operator-=(const duration& __d) {__rep_ -= __d.count(); return *this;}
-
-    _LIBCPP_INLINE_VISIBILITY duration& operator*=(const rep& rhs) {__rep_ *= rhs; return *this;}
-    _LIBCPP_INLINE_VISIBILITY duration& operator/=(const rep& rhs) {__rep_ /= rhs; return *this;}
-    _LIBCPP_INLINE_VISIBILITY duration& operator%=(const rep& rhs) {__rep_ %= rhs; return *this;}
-    _LIBCPP_INLINE_VISIBILITY duration& operator%=(const duration& rhs) {__rep_ %= rhs.count(); return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator++()      {++__rep_; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration  operator++(int)   {return duration(__rep_++);}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator--()      {--__rep_; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration  operator--(int)   {return duration(__rep_--);}
+
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator+=(const duration& __d) {__rep_ += __d.count(); return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator-=(const duration& __d) {__rep_ -= __d.count(); return *this;}
+
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator*=(const rep& rhs) {__rep_ *= rhs; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator/=(const rep& rhs) {__rep_ /= rhs; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const rep& rhs) {__rep_ %= rhs; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const duration& rhs) {__rep_ %= rhs.count(); return *this;}
 
     // 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());}
 };
 

test/std/utilities/time/time.duration/time.duration.arithmetic/op_++.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <chrono>
 
 // duration
 
-// duration& operator++();
+// constexpr duration& operator++();
 
 #include <chrono>
 #include <cassert>
 
+#include "test_macros.h"
+
+#if TEST_STD_VER > 14
+constexpr std::chrono::hours test_ce(int n) {
+    std::chrono::hours h(n);
+    std::chrono::hours h2 = ++h;
+    return h2;
+}
+#endif
+
 int main()
 {
     std::chrono::hours h(3);
     std::chrono::hours& href = ++h;
     assert(&href == &h);
     assert(h.count() == 4);
+
+#if TEST_STD_VER > 14
+    {
+    static_assert ( test_ce (2) == std::chrono::hours(3), "" );
+    static_assert ( test_ce (5) == std::chrono::hours(6), "" );
+    }
+#endif
 }

test/std/utilities/time/time.duration/time.duration.arithmetic/op_++int.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <chrono>
 
 // duration
 
-// duration operator++(int);
+// constexpr duration operator++(int);
 
 #include <chrono>
 #include <cassert>
 
+#include "test_macros.h"
+
+#if TEST_STD_VER > 14
+constexpr std::chrono::hours test_ce(int n) {
+    std::chrono::hours h(n);
+    std::chrono::hours h2 = h++;
+    return h2;
+}
+#endif
+
 int main()
 {
     std::chrono::hours h(3);
     std::chrono::hours h2 = h++;
     assert(h.count() == 4);
     assert(h2.count() == 3);
+
+#if TEST_STD_VER > 14
+    {
+    static_assert ( test_ce (2) == std::chrono::hours(2), "" );
+    static_assert ( test_ce (5) == std::chrono::hours(5), "" );
+    }
+#endif
 }

test/std/utilities/time/time.duration/time.duration.arithmetic/op_+=.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <chrono>
 
 // duration
 
-// duration& operator+=(const duration& d);
+// constexpr duration& operator+=(const duration& d);
 
 #include <chrono>
 #include <cassert>
 
+#include "test_macros.h"
+
+#if TEST_STD_VER > 14
+constexpr std::chrono::hours test_ce(int n, int k) {
+    typedef std::chrono::hours H;
+    H h(n);
+    h += H(k);
+    return h;
+}
+#endif
+
 int main()
 {
     std::chrono::seconds s(3);
     s += std::chrono::seconds(2);
     assert(s.count() == 5);
     s += std::chrono::minutes(2);
     assert(s.count() == 125);
+
+#if TEST_STD_VER > 14
+    {
+    static_assert ( test_ce (7, 2) == std::chrono::hours(9), "" );
+    static_assert ( test_ce (9, 5) == std::chrono::hours(14), "" );
+    static_assert ( test_ce (5, 0) == std::chrono::hours(5), "" );
+    static_assert ( test_ce (0, 0) == std::chrono::hours(0), "" );
+    }
+#endif
 }

test/std/utilities/time/time.duration/time.duration.arithmetic/op_--.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <chrono>
 
 // duration
 
-// duration& operator--();
+// constexpr duration& operator--();
 
 #include <chrono>
 #include <cassert>
 
+#include "test_macros.h"
+
+#if TEST_STD_VER > 14
+constexpr std::chrono::hours test_ce(int n) {
+    std::chrono::hours h(n);
+    std::chrono::hours h2 = --h;
+    return h2;
+}
+#endif
+
 int main()
 {
     std::chrono::hours h(3);
     std::chrono::hours& href = --h;
     assert(&href == &h);
     assert(h.count() == 2);
+
+#if TEST_STD_VER > 14
+    {
+    static_assert ( test_ce (2) == std::chrono::hours(1), "" );
+    static_assert ( test_ce (5) == std::chrono::hours(4), "" );
+    }
+#endif
 }

test/std/utilities/time/time.duration/time.duration.arithmetic/op_--int.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <chrono>
 
 // duration
 
-// duration operator--(int);
+// constexpr duration operator--(int);
 
 #include <chrono>
 #include <cassert>
 
+#include "test_macros.h"
+
+#if TEST_STD_VER > 14
+constexpr std::chrono::hours test_ce(int n) {
+    std::chrono::hours h(n);
+    std::chrono::hours h2 = h--;
+    return h2;
+}
+#endif
+
 int main()
 {
     std::chrono::hours h(3);
     std::chrono::hours h2 = h--;
     assert(h.count() == 2);
     assert(h2.count() == 3);
+
+#if TEST_STD_VER > 14
+    {
+    static_assert ( test_ce (2) == std::chrono::hours(2), "" );
+    static_assert ( test_ce (5) == std::chrono::hours(5), "" );
+    }
+#endif
 }

test/std/utilities/time/time.duration/time.duration.arithmetic/op_-=.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <chrono>
 
 // duration
 
-// duration& operator-=(const duration& d);
+// constexpr duration& operator-=(const duration& d);
 
 #include <chrono>
 #include <cassert>
 
+#include "test_macros.h"
+
+#if TEST_STD_VER > 14
+constexpr std::chrono::hours test_ce(int n, int k) {
+    typedef std::chrono::hours H;
+    H h(n);
+    h -= H(k);
+    return h;
+}
+#endif
+
 int main()
 {
     std::chrono::seconds s(3);
     s -= std::chrono::seconds(2);
     assert(s.count() == 1);
     s -= std::chrono::minutes(2);
     assert(s.count() == -119);
+
+#if TEST_STD_VER > 14
+    {
+    static_assert ( test_ce (7, 2) == std::chrono::hours(5), "" );
+    static_assert ( test_ce (9, 5) == std::chrono::hours(4), "" );
+    static_assert ( test_ce (5, 0) == std::chrono::hours(5), "" );
+    static_assert ( test_ce (0, 0) == std::chrono::hours(0), "" );
+    }
+#endif
 }

test/std/utilities/time/time.duration/time.duration.arithmetic/op_divide=.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <chrono>
 
 // duration
 
-// duration& operator/=(const rep& rhs);
+// constexpr duration& operator/=(const rep& rhs);
 
 #include <chrono>
 #include <cassert>
 
+#include "test_macros.h"
+
+#if TEST_STD_VER > 14
+constexpr std::chrono::hours test_ce(int n, int k) {
+    std::chrono::hours h(n);
+    h /= k;
+    return h;
+}
+#endif
+
 int main()
 {
     std::chrono::nanoseconds ns(15);
     ns /= 5;
     assert(ns.count() == 3);
+
+#if TEST_STD_VER > 14
+    {
+    static_assert ( test_ce (8, 2) == std::chrono::hours(4), "" );
+    static_assert ( test_ce (9, 3) == std::chrono::hours(3), "" );
+    static_assert ( test_ce (0, 5) == std::chrono::hours(0), "" );
+    }
+#endif
 }

test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=duration.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <chrono>
 
 // duration
 
-// duration& operator%=(const duration& rhs)
+// constexpr duration& operator%=(const duration& rhs)
 
 #include <chrono>
 #include <cassert>
 
+#include "test_macros.h"
+
+#if TEST_STD_VER > 14
+constexpr std::chrono::hours test_ce(int n, int k) {
+    typedef std::chrono::hours H;
+    H h(n);
+    h %= H(k);
+    return h;
+}
+#endif
+
 int main()
 {
     std::chrono::microseconds us(11);
     std::chrono::microseconds us2(3);
     us %= us2;
     assert(us.count() == 2);
     us %= std::chrono::milliseconds(3);
     assert(us.count() == 2);
+
+#if TEST_STD_VER > 14
+    {
+    static_assert ( test_ce (7, 2) == std::chrono::hours(1), "" );
+    static_assert ( test_ce (9, 5) == std::chrono::hours(4), "" );
+    static_assert ( test_ce (0, 4) == std::chrono::hours(0), "" );
+    }
+#endif
 }

test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=rep.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <chrono>
 
 // duration
 
-// duration& operator%=(const rep& rhs)
+// constexpr duration& operator%=(const rep& rhs)
 
 #include <chrono>
 #include <cassert>
 
+#include "test_macros.h"
+
+#if TEST_STD_VER > 14
+constexpr std::chrono::hours test_ce(int n, int k) {
+    std::chrono::hours h(n);
+    h %= k;
+    return h;
+}
+#endif
+
 int main()
 {
     std::chrono::microseconds us(11);
     us %= 3;
     assert(us.count() == 2);
+
+#if TEST_STD_VER > 14
+    {
+    static_assert ( test_ce (7, 2) == std::chrono::hours(1), "" );
+    static_assert ( test_ce (9, 5) == std::chrono::hours(4), "" );
+    static_assert ( test_ce (0, 4) == std::chrono::hours(0), "" );
+    }
+#endif
 }

test/std/utilities/time/time.duration/time.duration.arithmetic/op_times=.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <chrono>
 
 // duration
 
-// duration& operator*=(const rep& rhs);
+// constexpr duration& operator*=(const rep& rhs);
 
 #include <chrono>
 #include <cassert>
 
+#include "test_macros.h"
+
+#if TEST_STD_VER > 14
+constexpr std::chrono::hours test_ce(int n, int k) {
+    std::chrono::hours h(n);
+    h *= k;
+    return h;
+}
+#endif
+
 int main()
 {
     std::chrono::nanoseconds ns(3);
     ns *= 5;
     assert(ns.count() == 15);
+
+#if TEST_STD_VER > 14
+    {
+    static_assert ( test_ce (7, 2) == std::chrono::hours(14), "" );
+    static_assert ( test_ce (9, 5) == std::chrono::hours(45), "" );
+    static_assert ( test_ce (5, 0) == std::chrono::hours(0), "" );
+    static_assert ( test_ce (0, 0) == std::chrono::hours(0), "" );
+    }
+#endif
 }

www/cxx1z_status.html

-->
   <tr><td><a href="http://wg21.link/P0403R1">P0403R1</a></td><td>LWG</td><td>Literal suffixes for <tt>basic_string_view</tt></td><td>Issaquah</td><td></td><td></td></tr>
   <tr><td><a href="http://wg21.link/P0414R2">P0414R2</a></td><td>LWG</td><td>Merging shared_ptr changes from Library Fundamentals to C++17</td><td>Issaquah</td><td></td><td></td></tr>
   <tr><td><a href="http://wg21.link/P0418R2">P0418R2</a></td><td>LWG</td><td>Fail or succeed: there is no atomic lattice</td><td>Issaquah</td><td></td><td></td></tr>
   <tr><td><a href="http://wg21.link/P0426R1">P0426R1</a></td><td>LWG</td><td>Constexpr for <tt>std::char_traits</tt></td><td>Issaquah</td><td></td><td></td></tr>
   <tr><td><a href="http://wg21.link/P0435R1">P0435R1</a></td><td>LWG</td><td>Resolving LWG Issues re <tt>common_type</tt></td><td>Issaquah</td><td></td><td></td></tr>
   <tr><td><a href="http://wg21.link/P0502R0">P0502R0</a></td><td>LWG</td><td>Throwing out of a parallel algorithm terminates - but how?</td><td>Issaquah</td><td></td><td></td></tr>
   <tr><td><a href="http://wg21.link/P0503R0">P0503R0</a></td><td>LWG</td><td>Correcting library usage of "literal type"</td><td>Issaquah</td><td></td><td></td></tr>
   <tr><td><a href="http://wg21.link/P0504R0">P0504R0</a></td><td>LWG</td><td>Revisiting in-place tag types for any/optional/variant</td><td>Issaquah</td><td></td><td></td></tr>
-  <tr><td><a href="http://wg21.link/P0505R0">P0505R0</a></td><td>LWG</td><td>Wording for GB 50 - constexpr for chrono</td><td>Issaquah</td><td></td><td></td></tr>
+  <tr><td><a href="http://wg21.link/P0505R0">P0505R0</a></td><td>LWG</td><td>Wording for GB 50 - constexpr for chrono</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
   <tr><td><a href="http://wg21.link/P0508R0">P0508R0</a></td><td>LWG</td><td>Wording for GB 58 - structured bindings for node_handles</td><td>Issaquah</td><td></td><td></td></tr>
   <tr><td><a href="http://wg21.link/P0509R1">P0509R1</a></td><td>LWG</td><td>Updating “Restrictions on exception handling”</td><td>Issaquah</td><td></td><td></td></tr>
   <tr><td><a href="http://wg21.link/P0510R0">P0510R0</a></td><td>LWG</td><td>Disallowing references, incomplete types, arrays, and empty variants</td><td>Issaquah</td><td></td><td></td></tr>
   <tr><td><a href="http://wg21.link/P0513R0">P0513R0</a></td><td>LWG</td><td>Poisoning the Hash</td><td>Issaquah</td><td></td><td></td></tr>
   <tr><td><a href="http://wg21.link/P0516R0">P0516R0</a></td><td>LWG</td><td>Clarify That shared_future’s Copy Operations have Wide Contracts</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
   <tr><td><a href="http://wg21.link/P0517R0">P0517R0</a></td><td>LWG</td><td>Make future_error Constructible</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
   <tr><td><a href="http://wg21.link/P0521R0">P0521R0</a></td><td>LWG</td><td>Proposed Resolution for CA 14 (shared_ptr use_count/unique)</td><td>Issaquah</td><td></td><td></td></tr>