From cb05812195acc199d3d6ec82957795954dd00c95 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Fri, 15 Nov 2019 14:02:19 +0000 Subject: [PATCH 001/143] Partially implement P0355R7 --- stl/inc/chrono | 1335 ++++++++++++++++++++++++++++++++++++++++++ stl/inc/yvals_core.h | 2 + 2 files changed, 1337 insertions(+) diff --git a/stl/inc/chrono b/stl/inc/chrono index 0db70fba7b3..eb4d5483a72 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -14,9 +14,14 @@ #include #include +#if _HAS_CXX20 +#include +#endif // _HAS_CXX20 + #pragma pack(push, _CRT_PACKING) #pragma warning(push, _STL_WARNING_LEVEL) #pragma warning(disable : _STL_DISABLED_WARNINGS) +#pragma warning(disable : 4308) // needed for constexpr date arithmetic _STL_DISABLE_CLANG_WARNINGS #pragma push_macro("new") #undef new @@ -196,6 +201,23 @@ namespace chrono { return _MyDur; } +#if _HAS_CXX20 + constexpr time_point& operator++() { + ++_MyDur; + return *this; + } + constexpr time_point operator++(int) { + return time_point{_MyDur++}; + } + constexpr time_point& operator--() { + --_MyDur; + return *this; + } + constexpr time_point operator--(int) { + return time_point{_MyDur--}; + } +#endif // _HAS_CXX20 + _CONSTEXPR17 time_point& operator+=(const _Duration& _Dur) noexcept(is_arithmetic_v) /* strengthened */ { _MyDur += _Dur; return *this; @@ -471,6 +493,12 @@ namespace chrono { using seconds = duration; using minutes = duration>; using hours = duration>; +#if _HAS_CXX20 + using days = duration, hours::period>>; + using weeks = duration, days::period>>; + using years = duration, days::period>>; + using months = duration>>; +#endif // _HAS_CXX20 // time_point ARITHMETIC template @@ -602,6 +630,14 @@ namespace chrono { } }; +#if _HAS_CXX20 + // SYS_TIME aliases + template + using sys_time = time_point; + using sys_seconds = sys_time; + using sys_days = sys_time; +#endif // _HAS_CXX20 + struct steady_clock { // wraps QueryPerformanceCounter using rep = long long; using period = nano; @@ -620,6 +656,1297 @@ namespace chrono { }; using high_resolution_clock = steady_clock; + +#if _HAS_CXX20 + struct local_t {}; + + template + using local_time = time_point; + using local_seconds = local_time; + using local_days = local_time; + + struct last_spec { + explicit last_spec() = default; + }; + inline constexpr last_spec last{}; + + class day { + unsigned char _Day; + + public: + day() = default; + constexpr explicit day(unsigned _Val) noexcept; + + constexpr day& operator++() noexcept; + constexpr day operator++(int) noexcept; + constexpr day& operator--() noexcept; + constexpr day operator--(int) noexcept; + + constexpr day& operator+=(const days& _Days) noexcept; + constexpr day& operator-=(const days& _Days) noexcept; + + constexpr explicit operator unsigned() const noexcept; + constexpr bool ok() const noexcept; + }; + + class month { + unsigned char _Month; + + public: + month() = default; + constexpr explicit month(unsigned _Val) noexcept; + + constexpr month& operator++() noexcept; + constexpr month operator++(int) noexcept; + constexpr month& operator--() noexcept; + constexpr month operator--(int) noexcept; + + constexpr month& operator+=(const months& _Months) noexcept; + constexpr month& operator-=(const months& _Months) noexcept; + + constexpr explicit operator unsigned() const noexcept; + constexpr bool ok() const noexcept; + }; + + class year { + short _Year; + + public: + year() = default; + constexpr explicit year(int _Val) noexcept; + + constexpr year& operator++() noexcept; + constexpr year operator++(int) noexcept; + constexpr year& operator--() noexcept; + constexpr year operator--(int) noexcept; + + constexpr year& operator+=(const years& _Years) noexcept; + constexpr year& operator-=(const years& _Years) noexcept; + + constexpr year operator+() const noexcept; + constexpr year operator-() const noexcept; + + constexpr bool is_leap() const noexcept; + + constexpr explicit operator int() const noexcept; + + constexpr bool ok() const noexcept; + + static constexpr year(min)() noexcept; + static constexpr year(max)() noexcept; + }; + + class weekday { + unsigned char _Weekday; + static constexpr unsigned _Weekday_from_days(int _Tp) noexcept; + friend constexpr bool operator==(const weekday& _Left, const weekday& _Right) noexcept; + friend constexpr weekday operator+(const weekday& _Left, const days& _Right) noexcept; + + public: + weekday() = default; + constexpr explicit weekday(unsigned _Val) noexcept; + constexpr weekday(const sys_days& _Sys_day) noexcept; + constexpr explicit weekday(const local_days& _Local_day) noexcept; + + constexpr weekday& operator++() noexcept; + constexpr weekday operator++(int) noexcept; + constexpr weekday& operator--() noexcept; + constexpr weekday operator--(int) noexcept; + + constexpr weekday& operator+=(const days& _Days) noexcept; + constexpr weekday& operator-=(const days& _Days) noexcept; + + constexpr unsigned c_encoding() const noexcept; + constexpr unsigned iso_encoding() const noexcept; + constexpr bool ok() const noexcept; + + constexpr class weekday_indexed operator[](unsigned _Index) const noexcept; + constexpr class weekday_last operator[](last_spec) const noexcept; + }; + + class weekday_indexed { + chrono::weekday _Weekday; + unsigned char _Index; + + public: + weekday_indexed() = default; + constexpr weekday_indexed(const chrono::weekday& _Wd, unsigned _Idx) noexcept; + + constexpr chrono::weekday weekday() const noexcept; + constexpr unsigned index() const noexcept; + constexpr bool ok() const noexcept; + }; + + class weekday_last { + chrono::weekday _Weekday; + + public: + constexpr explicit weekday_last(const chrono::weekday& _Wd) noexcept; + + constexpr chrono::weekday weekday() const noexcept; + constexpr bool ok() const noexcept; + }; + + class month_day { + chrono::month _Month; + chrono::day _Day; + + public: + month_day() = default; + constexpr month_day(const chrono::month& _M, const chrono::day& _D) noexcept; + + constexpr chrono::month month() const noexcept; + constexpr chrono::day day() const noexcept; + constexpr bool ok() const noexcept; + }; + + class month_day_last { + chrono::month _Month; + + public: + constexpr explicit month_day_last(const chrono::month& _M) noexcept; + + constexpr chrono::month month() const noexcept; + constexpr bool ok() const noexcept; + }; + + class month_weekday { + chrono::month _Month; + chrono::weekday_indexed _Weekday_index; + + public: + constexpr month_weekday(const chrono::month& _M, const chrono::weekday_indexed& _Wdi) noexcept; + + constexpr chrono::month month() const noexcept; + constexpr chrono::weekday_indexed weekday_indexed() const noexcept; + + constexpr bool ok() const noexcept; + }; + + class month_weekday_last { + chrono::month _Month; + chrono::weekday_last _Weekday_last; + + public: + constexpr month_weekday_last(const chrono::month& _M, const chrono::weekday_last& _Wdl) noexcept; + + constexpr chrono::month month() const noexcept; + constexpr chrono::weekday_last weekday_last() const noexcept; + constexpr bool ok() const noexcept; + }; + + class year_month { + chrono::year _Year; + chrono::month _Month; + + public: + year_month() = default; + constexpr year_month(const chrono::year& _Y, const chrono::month& _M) noexcept; + + constexpr chrono::year year() const noexcept; + constexpr chrono::month month() const noexcept; + + constexpr year_month& operator+=(const months& _Months) noexcept; + constexpr year_month& operator-=(const months& _Months) noexcept; + constexpr year_month& operator+=(const years& _Years) noexcept; + constexpr year_month& operator-=(const years& _Years) noexcept; + + constexpr bool ok() const noexcept; + }; + + class year_month_day { + chrono::year _Year; + chrono::month _Month; + chrono::day _Day; + static constexpr year_month_day _Civil_from_days(int _Tp) noexcept; + constexpr days _Days_from_civil() const noexcept; + + public: + year_month_day() = default; + constexpr year_month_day(const chrono::year& _Y, const chrono::month& _M, const chrono::day& _D) noexcept; + constexpr year_month_day(const class year_month_day_last& _Ymdl) noexcept; + constexpr year_month_day(const sys_days& _Sys_days) noexcept; + constexpr explicit year_month_day(const local_days& _Local_days) noexcept; + + constexpr year_month_day& operator+=(const months& _Months) noexcept; + constexpr year_month_day& operator-=(const months& _Months) noexcept; + constexpr year_month_day& operator+=(const years& _Years) noexcept; + constexpr year_month_day& operator-=(const years& _Years) noexcept; + + constexpr chrono::year year() const noexcept; + constexpr chrono::month month() const noexcept; + constexpr chrono::day day() const noexcept; + + constexpr operator sys_days() const noexcept; + constexpr explicit operator local_days() const noexcept; + constexpr bool ok() const noexcept; + }; + + class year_month_day_last { + chrono::year _Year; + chrono::month_day_last _Month_day_last; + + public: + constexpr year_month_day_last(const chrono::year& _Y, const chrono::month_day_last& _Mdl) noexcept; + + constexpr year_month_day_last& operator+=(const months& _Months) noexcept; + constexpr year_month_day_last& operator-=(const months& _Months) noexcept; + constexpr year_month_day_last& operator+=(const years& _Years) noexcept; + constexpr year_month_day_last& operator-=(const years& _Years) noexcept; + + constexpr chrono::year year() const noexcept; + constexpr chrono::month month() const noexcept; + constexpr chrono::month_day_last month_day_last() const noexcept; + constexpr chrono::day day() const noexcept; + + constexpr operator sys_days() const noexcept; + constexpr explicit operator local_days() const noexcept; + constexpr bool ok() const noexcept; + }; + + class year_month_weekday { + chrono::year _Year; + chrono::month _Month; + chrono::weekday_indexed _Weekday_index; + static constexpr year_month_weekday _Ymwd_from_days(days _Dp) noexcept; + + public: + year_month_weekday() = default; + constexpr year_month_weekday( + const chrono::year& _Y, const chrono::month& _M, const chrono::weekday_indexed& _Wdi) noexcept; + constexpr year_month_weekday(const sys_days& _Sys_days) noexcept; + constexpr explicit year_month_weekday(const local_days& _Local_days) noexcept; + + constexpr year_month_weekday& operator+=(const months& _Months) noexcept; + constexpr year_month_weekday& operator-=(const months& _Months) noexcept; + constexpr year_month_weekday& operator+=(const years& _Years) noexcept; + constexpr year_month_weekday& operator-=(const years& _Years) noexcept; + + constexpr chrono::year year() const noexcept; + constexpr chrono::month month() const noexcept; + constexpr chrono::weekday weekday() const noexcept; + constexpr unsigned index() const noexcept; + constexpr chrono::weekday_indexed weekday_indexed() const noexcept; + + constexpr operator sys_days() const noexcept; + constexpr explicit operator local_days() const noexcept; + constexpr bool ok() const noexcept; + }; + + class year_month_weekday_last { + chrono::year _Year; + chrono::month _Month; + chrono::weekday_last _Weekday_last; + + public: + constexpr year_month_weekday_last( + const chrono::year& _Y, const chrono::month& _M, const chrono::weekday_last& _Wdl) noexcept; + + constexpr year_month_weekday_last& operator+=(const months& _Months) noexcept; + constexpr year_month_weekday_last& operator-=(const months& _Months) noexcept; + constexpr year_month_weekday_last& operator+=(const years& _Years) noexcept; + constexpr year_month_weekday_last& operator-=(const years& _Years) noexcept; + + constexpr chrono::year year() const noexcept; + constexpr chrono::month month() const noexcept; + constexpr chrono::weekday weekday() const noexcept; + constexpr chrono::weekday_last weekday_last() const noexcept; + + constexpr operator sys_days() const noexcept; + constexpr explicit operator local_days() const noexcept; + constexpr bool ok() const noexcept; + }; + + constexpr year_month operator/(const year& _Year, const month& _Month) noexcept; + constexpr year_month operator/(const year& _Year, int _Month) noexcept; + constexpr month_day operator/(const month& _Month, const day& _Day) noexcept; + constexpr month_day operator/(const month& _Month, int _Day) noexcept; + constexpr month_day operator/(int _Month, const day& _Day) noexcept; + constexpr month_day operator/(const day& _Day, const month& _Month) noexcept; + constexpr month_day operator/(const day& _Day, int _Month) noexcept; + constexpr month_day_last operator/(const month& _Month, last_spec) noexcept; + constexpr month_day_last operator/(int _Month, last_spec) noexcept; + constexpr month_day_last operator/(last_spec, const month& _Month) noexcept; + constexpr month_day_last operator/(last_spec, int _Month) noexcept; + constexpr month_weekday operator/(const month& _Month, const weekday_indexed& _Wdi) noexcept; + constexpr month_weekday operator/(int _Month, const weekday_indexed& _Wdi) noexcept; + constexpr month_weekday operator/(const weekday_indexed& _Wdi, const month& _Month) noexcept; + constexpr month_weekday operator/(const weekday_indexed& _Wdi, int _Month) noexcept; + constexpr month_weekday_last operator/(const month& _Month, const weekday_last& _Wdl) noexcept; + constexpr month_weekday_last operator/(int _Month, const weekday_last& _Wdl) noexcept; + constexpr month_weekday_last operator/(const weekday_last& _Wdl, const month& _Month) noexcept; + constexpr month_weekday_last operator/(const weekday_last& _Wdl, int _Month) noexcept; + constexpr year_month_day operator/(const year_month& _Ym, const day& _Day) noexcept; + constexpr year_month_day operator/(const year_month& _Ym, int _Day) noexcept; + constexpr year_month_day operator/(const year& _Year, const month_day& _Md) noexcept; + constexpr year_month_day operator/(int _Year, const month_day& _Md) noexcept; + constexpr year_month_day operator/(const month_day& _Md, const year& _Year) noexcept; + constexpr year_month_day operator/(const month_day& _Md, int _Year) noexcept; + constexpr year_month_day_last operator/(const year_month& _Ym, last_spec) noexcept; + constexpr year_month_day_last operator/(const year& _Year, const month_day_last& _Mdl) noexcept; + constexpr year_month_day_last operator/(int _Year, const month_day_last& _Mdl) noexcept; + constexpr year_month_day_last operator/(const month_day_last& _Mdl, const year& _Year) noexcept; + constexpr year_month_day_last operator/(const month_day_last& _Mdl, int _Year) noexcept; + constexpr year_month_weekday operator/(const year_month& _Ym, const weekday_indexed& _Wdi) noexcept; + constexpr year_month_weekday operator/(const year& _Year, const month_weekday& _Mwd) noexcept; + constexpr year_month_weekday operator/(int _Year, const month_weekday& _Mwd) noexcept; + constexpr year_month_weekday operator/(const month_weekday& _Mwd, const year& _Year) noexcept; + constexpr year_month_weekday operator/(const month_weekday& _Mwd, int _Year) noexcept; + constexpr year_month_weekday_last operator/(const year_month& ym, const weekday_last& _Wdl) noexcept; + constexpr year_month_weekday_last operator/(const year& _Year, const month_weekday_last& mwdl) noexcept; + constexpr year_month_weekday_last operator/(int _Year, const month_weekday_last& mwdl) noexcept; + constexpr year_month_weekday_last operator/(const month_weekday_last& mwdl, const year& _Year) noexcept; + constexpr year_month_weekday_last operator/(const month_weekday_last& mwdl, int _Year) noexcept; + + // day + constexpr day::day(unsigned _Val) noexcept : _Day{static_cast(_Val)} {} + + constexpr day& day::operator++() noexcept { + ++_Day; + return *this; + } + constexpr day day::operator++(int) noexcept { + return day{_Day++}; + } + constexpr day& day::operator--() noexcept { + --_Day; + return *this; + } + constexpr day day::operator--(int) noexcept { + return day{_Day--}; + } + + constexpr day::operator unsigned() const noexcept { + return _Day; + } + constexpr bool day::ok() const noexcept { + return _Day >= 1 && _Day <= 31; + } + + constexpr bool operator==(const day& _Left, const day& _Right) noexcept { + return static_cast(_Left) == static_cast(_Right); + } + constexpr strong_ordering operator<=>(const day& _Left, const day& _Right) noexcept { + return static_cast(_Left) <=> static_cast(_Right); + } + + constexpr day operator+(const day& _Left, const days& _Right) noexcept { + return day{static_cast(_Left) + _Right.count()}; + } + constexpr day operator+(const days& _Left, const day& _Right) noexcept { + return _Right + _Left; + } + constexpr day operator-(const day& _Left, const days& _Right) noexcept { + return _Left + -_Right; + } + constexpr days operator-(const day& _Left, const day& _Right) noexcept { + return days{static_cast(static_cast(_Left)) - static_cast(static_cast(_Right))}; + } + + constexpr day& day::operator+=(const days& _Days) noexcept { + *this = *this + _Days; + return *this; + } + constexpr day& day::operator-=(const days& _Days) noexcept { + *this = *this - _Days; + return *this; + } + + // month + constexpr month::month(unsigned _Val) noexcept : _Month{static_cast(_Val)} {} + + constexpr month& month::operator++() noexcept { + *this += months{1}; + return *this; + } + constexpr month month::operator++(int) noexcept { + month _Temp{*this}; + ++(*this); + return _Temp; + } + constexpr month& month::operator--() noexcept { + *this -= months{1}; + return *this; + } + constexpr month month::operator--(int) noexcept { + month _Temp{*this}; + --(*this); + return _Temp; + } + constexpr month::operator unsigned() const noexcept { + return static_cast(_Month); + } + constexpr bool month::ok() const noexcept { + return _Month >= 1 && _Month <= 12; + } + + constexpr bool operator==(const month& _Left, const month& _Right) noexcept { + return static_cast(_Left) == static_cast(_Right); + } + constexpr strong_ordering operator<=>(const month& _Left, const month& _Right) noexcept { + return static_cast(_Left) <=> static_cast(_Right); + } + + constexpr month operator+(const month& _Left, const months& _Right) noexcept { + const auto _M = static_cast(static_cast(_Left)) + (_Right.count() - 1); + const auto _Div = (_M >= 0 ? _M : _M - 11) / 12; + return month{static_cast(_M - _Div * 12 + 1)}; + } + constexpr month operator+(const months& _Left, const month& _Right) noexcept { + return _Right + _Left; + } + constexpr month operator-(const month& _Left, const months& _Right) noexcept { + return _Left + -_Right; + } + constexpr months operator-(const month& _Left, const month& _Right) noexcept { + const auto _M = static_cast(_Left) - static_cast(_Right); + return months{_M <= 11 ? _M : _M + 12}; + } + + constexpr month& month::operator+=(const months& _Months) noexcept { + *this = *this + _Months; + return *this; + } + constexpr month& month::operator-=(const months& _Months) noexcept { + *this = *this - _Months; + return *this; + } + + // year + constexpr year::year(int _Val) noexcept : _Year{static_cast(_Val)} {} + + constexpr year& year::operator++() noexcept { + ++_Year; + return *this; + } + constexpr year year::operator++(int) noexcept { + return year{_Year++}; + } + constexpr year& year::operator--() noexcept { + --_Year; + return *this; + } + constexpr year year::operator--(int) noexcept { + return year{_Year--}; + } + + constexpr year year::operator+() const noexcept { + return *this; + } + constexpr year year::operator-() const noexcept { + return year{-_Year}; + } + + constexpr bool year::is_leap() const noexcept { + return _Year % 4 == 0 && (_Year % 100 != 0 || _Year % 400 == 0); + } + + constexpr year::operator int() const noexcept { + return static_cast(_Year); + } + constexpr bool year::ok() const noexcept { + return (min)()._Year <= _Year && _Year <= (max)()._Year; + } + + constexpr year(year::min)() noexcept { + return year{-32767}; + } + constexpr year(year::max)() noexcept { + return year{32767}; + } + + constexpr bool operator==(const year& _Left, const year& _Right) noexcept { + return static_cast(_Left) == static_cast(_Right); + } + constexpr strong_ordering operator<=>(const year& _Left, const year& _Right) noexcept { + return static_cast(_Left) <=> static_cast(_Right); + } + + constexpr year operator+(const year& _Left, const years& _Right) noexcept { + return year{static_cast(_Left) + _Right.count()}; + } + constexpr year operator+(const years& _Left, const year& _Right) noexcept { + return _Right + _Left; + } + constexpr year operator-(const year& _Left, const years& _Right) noexcept { + return _Left + -_Right; + } + constexpr years operator-(const year& _Left, const year& _Right) noexcept { + return years{static_cast(_Left) - static_cast(_Right)}; + } + + constexpr year& year::operator+=(const years& _Years) noexcept { + *this = *this + _Years; + return *this; + } + constexpr year& year::operator-=(const years& _Years) noexcept { + *this = *this - _Years; + return *this; + } + + // weekday + // courtesy of Howard Hinnant + // https://howardhinnant.github.io/date_algorithms.html#weekday_from_days + constexpr unsigned weekday::_Weekday_from_days(int _Tp) noexcept { + return static_cast(_Tp >= -4 ? (_Tp + 4) % 7 : (_Tp + 5) % 7 + 6); + } + constexpr weekday::weekday(unsigned _Val) noexcept : _Weekday{static_cast(_Val == 7 ? 0 : _Val)} {} + constexpr weekday::weekday(const sys_days& _Sys_day) noexcept + : _Weekday{static_cast(_Weekday_from_days(_Sys_day.time_since_epoch().count()))} {} + constexpr weekday::weekday(const local_days& _Local_day) noexcept + : _Weekday{static_cast(_Weekday_from_days(_Local_day.time_since_epoch().count()))} {} + + + constexpr unsigned weekday::c_encoding() const noexcept { + return _Weekday; + } + constexpr unsigned weekday::iso_encoding() const noexcept { + return _Weekday == 0u ? 7u : _Weekday; + } + constexpr bool weekday::ok() const noexcept { + return _Weekday <= 6; + } + + constexpr weekday_indexed weekday::operator[](unsigned _Index) const noexcept { + return {*this, _Index}; + } + constexpr weekday_last weekday::operator[](last_spec) const noexcept { + return weekday_last{*this}; + } + + constexpr bool operator==(const weekday& _Left, const weekday& _Right) noexcept { + return _Left._Weekday == _Right._Weekday; + } + + constexpr weekday operator+(const weekday& _Left, const days& _Right) noexcept { + const auto _Wd = static_cast(_Left._Weekday) + _Right.count(); + const auto _Div = (_Wd >= 0 ? _Wd : _Wd - 6) / 7; + return weekday{static_cast(_Wd - _Div * 7)}; + } + constexpr weekday operator+(const days& _Left, const weekday& _Right) noexcept { + return _Right + _Left; + } + constexpr weekday operator-(const weekday& _Left, const days& _Right) noexcept { + return _Left + -_Right; + } + constexpr days operator-(const weekday& _Left, const weekday& _Right) noexcept { + const int _Wd = _Left.c_encoding() - _Right.c_encoding(); + const int _Wk = (_Wd >= 0 ? _Wd : _Wd - 6) / 7; + return days{_Wd - _Wk * 7}; + } + + constexpr weekday& weekday::operator++() noexcept { + return *this += days{1}; + } + constexpr weekday weekday::operator++(int) noexcept { + weekday _Temp{*this}; + ++(*this); + return _Temp; + } + constexpr weekday& weekday::operator--() noexcept { + return *this -= days{1}; + } + constexpr weekday weekday::operator--(int) noexcept { + weekday _Temp{*this}; + --(*this); + return _Temp; + } + + constexpr weekday& weekday::operator+=(const days& _Days) noexcept { + return *this = *this + _Days; + } + constexpr weekday& weekday::operator-=(const days& _Days) noexcept { + return *this = *this - _Days; + } + + // weekday_indexed + constexpr weekday_indexed::weekday_indexed(const chrono::weekday& _Wd, unsigned _Idx) noexcept + : _Weekday{_Wd}, _Index{static_cast(_Idx)} {} + + constexpr chrono::weekday weekday_indexed::weekday() const noexcept { + return _Weekday; + } + constexpr unsigned weekday_indexed::index() const noexcept { + return _Index; + } + constexpr bool weekday_indexed::ok() const noexcept { + return _Weekday.ok() && 1 <= _Index && _Index <= 5; + } + constexpr bool operator==(const weekday_indexed& _Left, const weekday_indexed& _Right) noexcept { + return _Left.weekday() == _Right.weekday() && _Left.index() == _Right.index(); + } + + // weekday_last + constexpr weekday_last::weekday_last(const chrono::weekday& _Wd) noexcept : _Weekday{_Wd} {} + + constexpr chrono::weekday weekday_last::weekday() const noexcept { + return _Weekday; + } + constexpr bool weekday_last::ok() const noexcept { + return _Weekday.ok(); + } + + constexpr bool operator==(const weekday_last& _Left, const weekday_last& _Right) noexcept { + return _Left.weekday() == _Right.weekday(); + } + + // month_day + constexpr month_day::month_day(const chrono::month& _M, const chrono::day& _D) noexcept : _Month{_M}, _Day{_D} {} + + constexpr chrono::month month_day::month() const noexcept { + return _Month; + } + constexpr chrono::day month_day::day() const noexcept { + return _Day; + } + constexpr bool month_day::ok() const noexcept { + if (!_Month.ok() || !_Day.ok()) + return false; + + const auto _D = static_cast(_Day); + const auto _M = static_cast(_Month); + + if (_M == 2 && _D > 29) + return false; + if (_M == 4 || _M == 6 || _M == 9 || _M == 11) + return _D <= 30; + return true; + } + + constexpr bool operator==(const month_day& _Left, const month_day& _Right) noexcept { + return _Left.month() == _Right.month() && _Left.day() == _Right.day(); + } + constexpr strong_ordering operator<=>(const month_day& _Left, const month_day& _Right) noexcept { + if (auto _Comp = _Left.month() <=> _Right.month(); _Comp != 0) + return _Comp; + return _Left.day() <=> _Right.day(); + } + + // month_day_last + constexpr month_day_last::month_day_last(const chrono::month& _M) noexcept : _Month{_M} {} + + constexpr chrono::month month_day_last::month() const noexcept { + return _Month; + } + constexpr bool month_day_last::ok() const noexcept { + return _Month.ok(); + } + + constexpr bool operator==(const month_day_last& _Left, const month_day_last& _Right) { + return _Left.month() == _Right.month(); + } + constexpr strong_ordering operator<=>(const month_day_last& _Left, const month_day_last& _Right) { + return _Left.month() <=> _Right.month(); + } + + // month_weekday + constexpr month_weekday::month_weekday(const chrono::month& _M, const chrono::weekday_indexed& _Wdi) noexcept + : _Month{_M}, _Weekday_index{_Wdi} {} + + constexpr chrono::month month_weekday::month() const noexcept { + return _Month; + } + constexpr chrono::weekday_indexed month_weekday::weekday_indexed() const noexcept { + return _Weekday_index; + } + + constexpr bool month_weekday::ok() const noexcept { + return _Month.ok() && _Weekday_index.ok(); + } + + constexpr bool operator==(const month_weekday& _Left, const month_weekday& _Right) { + return _Left.month() == _Right.month() && _Left.weekday_indexed() == _Right.weekday_indexed(); + } + + // month_weekday_last + constexpr month_weekday_last::month_weekday_last(const chrono::month& _M, const chrono::weekday_last& _Wdl) noexcept + : _Month{_M}, _Weekday_last{_Wdl} {} + + constexpr chrono::month month_weekday_last::month() const noexcept { + return _Month; + } + constexpr chrono::weekday_last month_weekday_last::weekday_last() const noexcept { + return _Weekday_last; + } + constexpr bool month_weekday_last::ok() const noexcept { + return _Month.ok() && _Weekday_last.ok(); + } + + constexpr bool operator==(const month_weekday_last& _Left, const month_weekday_last& _Right) noexcept { + return _Left.month() == _Right.month() && _Left.weekday_last() == _Right.weekday_last(); + } + + // year_month + constexpr year_month::year_month(const chrono::year& _Y, const chrono::month& _M) noexcept + : _Year{_Y}, _Month{_M} {} + + constexpr chrono::year year_month::year() const noexcept { + return _Year; + } + constexpr chrono::month year_month::month() const noexcept { + return _Month; + } + + constexpr bool year_month::ok() const noexcept { + return _Year.ok() && _Month.ok(); + } + + constexpr bool operator==(const year_month& _Left, const year_month& _Right) noexcept { + return _Left.year() == _Right.year() && _Left.month() == _Right.month(); + } + constexpr strong_ordering operator<=>(const year_month& _Left, const year_month& _Right) noexcept { + if (auto _Comp = _Left.year() <=> _Right.year(); _Comp != 0) + return _Comp; + return _Left.month() <=> _Right.month(); + } + + constexpr year_month operator+(const year_month& _Left, const months& _Right) noexcept { + const auto _M = static_cast(static_cast(_Left.month())) + (_Right.count() - 1); + const auto _Div = (_M >= 0 ? _M : _M - 11) / 12; + return year_month{_Left.year() + years{_Div}, month{static_cast(_M - _Div * 12 + 1)}}; + } + constexpr year_month operator+(const months& _Left, const year_month& _Right) noexcept { + return _Right + _Left; + } + + constexpr year_month operator-(const year_month& _Left, const months& _Right) noexcept { + return _Left + -_Right; + } + + constexpr months operator-(const year_month& _Left, const year_month& _Right) noexcept { + return _Left.year() - _Right.year() + + months{static_cast(static_cast(_Left.month())) + - static_cast(static_cast(_Right.month()))}; + } + + constexpr year_month operator+(const year_month& _Left, const years& _Right) noexcept { + return (_Left.year() + _Right) / _Left.month(); + } + + constexpr year_month operator+(const years& _Left, const year_month& _Right) noexcept { + return _Right + _Left; + } + + constexpr year_month operator-(const year_month& _Left, const years& _Right) noexcept { + return _Left + -_Right; + } + + constexpr year_month& year_month::operator+=(const months& _Months) noexcept { + *this = *this + _Months; + return *this; + } + constexpr year_month& year_month::operator-=(const months& _Months) noexcept { + *this = *this - _Months; + return *this; + } + constexpr year_month& year_month::operator+=(const years& _Years) noexcept { + *this = *this + _Years; + return *this; + } + constexpr year_month& year_month::operator-=(const years& _Years) noexcept { + *this = *this - _Years; + return *this; + } + + // year_month_day + // Thanks again to Howard https://howardhinnant.github.io/date_algorithms.html#civil_from_days + constexpr year_month_day year_month_day::_Civil_from_days(int _Tp) noexcept { + static_assert(_STD numeric_limits::digits >= 18); + static_assert(_STD numeric_limits::digits >= 20); + const int _Z = _Tp + 719468; + const int _Era = (_Z >= 0 ? _Z : _Z - 146096) / 146097; + const unsigned _Doe = static_cast(_Z - _Era * 146097); + const unsigned _Yoe = (_Doe - _Doe / 1460 + _Doe / 36524 - _Doe / 146096) / 365; + const int _Y = static_cast(_Yoe) + _Era * 400; + const unsigned _Doy = _Doe - (365 * _Yoe + _Yoe / 4 - _Yoe / 100); + const unsigned _Mp = (5 * _Doy + 2) / 153; + const unsigned _D = _Doy - (153 * _Mp + 2) / 5 + 1; + const unsigned _M = _Mp + (_Mp < 10 ? 3 : -9); + return year_month_day(chrono::year{_Y + (_M <= 2)}, chrono::month{_M}, chrono::day{_D}); + } + + constexpr year_month_day::year_month_day( + const chrono::year& _Y, const chrono::month& _M, const chrono::day& _D) noexcept + : _Year{_Y}, _Month{_M}, _Day{_D} {} + constexpr year_month_day::year_month_day(const year_month_day_last& _Ymdl) noexcept + : _Year{_Ymdl.year()}, _Month{_Ymdl.month()}, _Day{_Ymdl.day()} {} + constexpr year_month_day::year_month_day(const sys_days& _Sys_days) noexcept + : year_month_day{_Civil_from_days(_Sys_days.time_since_epoch().count())} {} + constexpr year_month_day::year_month_day(const local_days& _Local_days) noexcept + : year_month_day{_Civil_from_days(_Local_days.time_since_epoch().count())} {} + + constexpr chrono::year year_month_day::year() const noexcept { + return _Year; + } + constexpr chrono::month year_month_day::month() const noexcept { + return _Month; + } + constexpr chrono::day year_month_day::day() const noexcept { + return _Day; + } + + constexpr year_month_day::operator sys_days() const noexcept { + return sys_days{_Year / _Month / chrono::day{1}} + (_Day - chrono::day{1}); + } + constexpr year_month_day::operator local_days() const noexcept { + return _STD chrono::local_days{static_cast(*this).time_since_epoch()}; + } + constexpr bool year_month_day::ok() const noexcept { + if (!_Year.ok() || !_Month.ok()) + return false; + return _Day >= chrono::day{1} && _Day <= (_Year / _Month / last).day(); + } + + constexpr bool operator==(const year_month_day& _Left, const year_month_day& _Right) noexcept { + return _Left.year() == _Right.year() && _Left.month() == _Right.month() && _Left.day() == _Right.day(); + } + constexpr strong_ordering operator<=>(const year_month_day& _Left, const year_month_day& _Right) noexcept { + if (auto _Comp = _Left.year() <=> _Right.year(); _Comp != 0) + return _Comp; + if (auto _Comp = _Left.month() <=> _Right.month(); _Comp != 0) + return _Comp; + return _Left.day() <=> _Right.day(); + } + + constexpr year_month_day operator+(const year_month_day& _Left, const months& _Right) noexcept { + return year_month{_Left.year() / _Left.month() + _Right} / _Left.day(); + } + + constexpr year_month_day operator+(const months& _Left, const year_month_day& _Right) noexcept { + return _Right + _Left; + } + + constexpr year_month_day operator-(const year_month_day& _Left, const months& _Right) noexcept { + return _Left + (-_Right); + } + + constexpr year_month_day operator+(const year_month_day& _Left, const years& _Right) noexcept { + return year{_Left.year() + _Right} / _Left.month() / _Left.day(); + } + + constexpr year_month_day operator+(const years& _Left, const year_month_day& _Right) noexcept { + return _Right + _Left; + } + + constexpr year_month_day operator-(const year_month_day& _Left, const years& _Right) noexcept { + return _Left + (-_Right); + } + + constexpr year_month_day& year_month_day::operator+=(const months& _Months) noexcept { + *this = *this + _Months; + return *this; + } + constexpr year_month_day& year_month_day::operator-=(const months& _Months) noexcept { + *this = *this - _Months; + return *this; + } + constexpr year_month_day& year_month_day::operator+=(const years& _Years) noexcept { + *this = *this + _Years; + return *this; + } + constexpr year_month_day& year_month_day::operator-=(const years& _Years) noexcept { + *this = *this - _Years; + return *this; + } + + // year_month_day_last + constexpr year_month_day_last::year_month_day_last( + const chrono::year& _Y, const chrono::month_day_last& _Mdl) noexcept + : _Year{_Y}, _Month_day_last{_Mdl} {} + + constexpr chrono::year year_month_day_last::year() const noexcept { + return _Year; + } + constexpr chrono::month year_month_day_last::month() const noexcept { + return _Month_day_last.month(); + } + constexpr chrono::month_day_last year_month_day_last::month_day_last() const noexcept { + return _Month_day_last; + } + constexpr chrono::day year_month_day_last::day() const noexcept { + // clang-format off + constexpr chrono::day _Days[] = { + chrono::day{31}, chrono::day{28}, chrono::day{31}, chrono::day{30}, + chrono::day{31}, chrono::day{30}, chrono::day{31}, chrono::day{31}, + chrono::day{30}, chrono::day{31}, chrono::day{30}, chrono::day{31}}; + // clang-format on + return month() == chrono::month{2} && _Year.is_leap() + ? _Days[static_cast(month()) - 1] + chrono::days{1} + : _Days[static_cast(month()) - 1]; + } + + constexpr year_month_day_last::operator sys_days() const noexcept { + return sys_days{year() / month() / day()}; + } + constexpr year_month_day_last::operator local_days() const noexcept { + return _STD chrono::local_days{static_cast(*this).time_since_epoch()}; + } + constexpr bool year_month_day_last::ok() const noexcept { + return _Year.ok() && _Month_day_last.ok(); + } + + constexpr bool operator==(const year_month_day_last& _Left, const year_month_day_last& _Right) noexcept { + return _Left.year() == _Right.year() && _Left.month_day_last() == _Right.month_day_last(); + } + constexpr strong_ordering operator<=>( + const year_month_day_last& _Left, const year_month_day_last& _Right) noexcept { + if (auto _Comp = _Left.year() <=> _Right.year(); _Comp != 0) + return _Comp; + return _Left.month_day_last() <=> _Right.month_day_last(); + } + + constexpr year_month_day_last operator+(const year_month_day_last& _Left, const months& _Right) noexcept { + return (_Left.year() / _Left.month() + _Right) / last; + } + constexpr year_month_day_last operator+(const months& _Left, const year_month_day_last& _Right) noexcept { + return _Right + _Left; + } + + constexpr year_month_day_last operator-(const year_month_day_last& _Left, const months& _Right) noexcept { + return _Left + (-_Right); + } + + constexpr year_month_day_last operator+(const year_month_day_last& _Left, const years& _Right) noexcept { + return {_Left.year() + _Right, _Left.month_day_last()}; + } + constexpr year_month_day_last operator+(const years& _Left, const year_month_day_last& _Right) noexcept { + return _Right + _Left; + } + constexpr year_month_day_last operator-(const year_month_day_last& _Left, const years& _Right) noexcept { + return _Left + (-_Right); + } + + constexpr year_month_day_last& year_month_day_last::operator+=(const months& _Months) noexcept { + *this = *this + _Months; + return *this; + } + constexpr year_month_day_last& year_month_day_last::operator-=(const months& _Months) noexcept { + *this = *this - _Months; + return *this; + } + constexpr year_month_day_last& year_month_day_last::operator+=(const years& _Years) noexcept { + *this = *this + _Years; + return *this; + } + constexpr year_month_day_last& year_month_day_last::operator-=(const years& _Years) noexcept { + *this = *this - _Years; + return *this; + } + + // year_month_weekday + constexpr year_month_weekday year_month_weekday::_Ymwd_from_days(days _Dp) noexcept { + const chrono::year_month_day _Ymd = sys_days{_Dp}; + const chrono::weekday _Wd = sys_days{_Dp}; + const auto _Idx = ((static_cast(_Ymd.day()) - 1) / 7) + 1; + return {_Ymd.year() / _Ymd.month() / _Wd[_Idx]}; + } + + constexpr std::chrono::year_month_weekday::year_month_weekday( + const chrono::year& _Y, const chrono::month& _M, const chrono::weekday_indexed& _Wdi) noexcept + : _Year{_Y}, _Month{_M}, _Weekday_index{_Wdi} {} + constexpr year_month_weekday::year_month_weekday(const sys_days& _Sys_days) noexcept + : year_month_weekday{_Ymwd_from_days(_Sys_days.time_since_epoch())} {} + constexpr year_month_weekday::year_month_weekday(const local_days& _Local_days) noexcept + : year_month_weekday{_Ymwd_from_days(_Local_days.time_since_epoch())} {} + + + constexpr chrono::year year_month_weekday::year() const noexcept { + return _Year; + } + constexpr chrono::month year_month_weekday::month() const noexcept { + return _Month; + } + constexpr chrono::weekday year_month_weekday::weekday() const noexcept { + return _Weekday_index.weekday(); + } + constexpr unsigned year_month_weekday::index() const noexcept { + return _Weekday_index.index(); + } + constexpr chrono::weekday_indexed year_month_weekday::weekday_indexed() const noexcept { + return _Weekday_index; + } + + constexpr year_month_weekday::operator sys_days() const noexcept { + const sys_days _First{_Year / _Month / 1}; + const days _Diff = weekday() - chrono::weekday{_First}; + const days _Days = _Diff + days{(index() - 1) * 7}; + return _First + _Days; + } + constexpr year_month_weekday::operator local_days() const noexcept { + return _STD chrono::local_days{static_cast(*this).time_since_epoch()}; + } + + constexpr bool year_month_weekday::ok() const noexcept { + if (!_Year.ok() || !_Month.ok() || !_Weekday_index.ok()) + return false; + if (_Weekday_index.index() <= 4) + return true; + const sys_days _First = _Year / _Month / chrono::weekday_indexed{weekday(), 1}; + const sys_days _Four = _First + days{28}; + return year_month_day{_Four}.month() == _Month; + } + constexpr bool operator==(const year_month_weekday& _Left, const year_month_weekday& _Right) noexcept { + return _Left.year() == _Right.year() && _Left.month() == _Right.month() + && _Left.weekday_indexed() == _Right.weekday_indexed(); + } + + constexpr year_month_weekday operator+(const year_month_weekday& _Left, const months& _Right) noexcept { + return (_Left.year() / _Left.month() + _Right) / _Left.weekday_indexed(); + } + constexpr year_month_weekday operator+(const months& _Left, const year_month_weekday& _Right) noexcept { + return _Right + _Left; + } + + constexpr year_month_weekday operator-(const year_month_weekday& _Left, const months& _Right) noexcept { + return _Left + (-_Right); + } + + constexpr year_month_weekday operator+(const year_month_weekday& _Left, const years& _Right) noexcept { + return year_month_weekday{_Left.year() + _Right, _Left.month(), _Left.weekday_indexed()}; + } + constexpr year_month_weekday operator+(const years& _Left, const year_month_weekday& _Right) noexcept { + return _Right + _Left; + } + + constexpr year_month_weekday operator-(const year_month_weekday& _Left, const years& _Right) noexcept { + return _Left + (-_Right); + } + + constexpr year_month_weekday& year_month_weekday::operator+=(const months& _Months) noexcept { + *this = *this + _Months; + return *this; + } + constexpr year_month_weekday& year_month_weekday::operator-=(const months& _Months) noexcept { + *this = *this - _Months; + return *this; + } + constexpr year_month_weekday& year_month_weekday::operator+=(const years& _Years) noexcept { + *this = *this + _Years; + return *this; + } + constexpr year_month_weekday& year_month_weekday::operator-=(const years& _Years) noexcept { + *this = *this - _Years; + return *this; + } + + // year_month_weekday_last + constexpr year_month_weekday_last::year_month_weekday_last( + const chrono::year& _Y, const chrono::month& _M, const chrono::weekday_last& _Wdl) noexcept + : _Year{_Y}, _Month{_M}, _Weekday_last{_Wdl} {} + + constexpr chrono::year year_month_weekday_last::year() const noexcept { + return _Year; + } + constexpr chrono::month year_month_weekday_last::month() const noexcept { + return _Month; + } + constexpr chrono::weekday year_month_weekday_last::weekday() const noexcept { + return _Weekday_last.weekday(); + } + constexpr chrono::weekday_last year_month_weekday_last::weekday_last() const noexcept { + return _Weekday_last; + } + + constexpr year_month_weekday_last::operator sys_days() const noexcept { + const sys_days _Last{_Year / _Month / last}; + const auto _Diff = chrono::weekday{_Last} - weekday(); + return _Last - _Diff; + } + constexpr year_month_weekday_last::operator local_days() const noexcept { + return _STD chrono::local_days{static_cast(*this).time_since_epoch()}; + } + constexpr bool year_month_weekday_last::ok() const noexcept { + return _Year.ok() && _Month.ok() && _Weekday_last.ok(); + } + + constexpr bool operator==(const year_month_weekday_last& _Left, const year_month_weekday_last& _Right) noexcept { + return _Left.year() == _Right.year() && _Left.month() == _Right.month() + && _Left.weekday_last() == _Right.weekday_last(); + } + + constexpr year_month_weekday_last operator+(const year_month_weekday_last& _Left, const months& _Right) noexcept { + return (_Left.year() / _Left.month() + _Right) / _Left.weekday_last(); + } + constexpr year_month_weekday_last operator+(const months& _Left, const year_month_weekday_last& _Right) noexcept { + return _Right + _Left; + } + + constexpr year_month_weekday_last operator-(const year_month_weekday_last& _Left, const months& _Right) noexcept { + return _Left + (-_Right); + } + + constexpr year_month_weekday_last operator+(const year_month_weekday_last& _Left, const years& _Right) noexcept { + return {_Left.year() + _Right, _Left.month(), _Left.weekday_last()}; + } + constexpr year_month_weekday_last operator+(const years& _Left, const year_month_weekday_last& _Right) noexcept { + return _Right + _Left; + } + + constexpr year_month_weekday_last operator-(const year_month_weekday_last& _Left, const years& _Right) noexcept { + return _Left + (-_Right); + } + + constexpr year_month_weekday_last& year_month_weekday_last::operator+=(const months& _Months) noexcept { + *this = *this + _Months; + return *this; + } + constexpr year_month_weekday_last& year_month_weekday_last::operator-=(const months& _Months) noexcept { + *this = *this - _Months; + return *this; + } + constexpr year_month_weekday_last& year_month_weekday_last::operator+=(const years& _Years) noexcept { + *this = *this + _Years; + return *this; + } + constexpr year_month_weekday_last& year_month_weekday_last::operator-=(const years& _Years) noexcept { + *this = *this - _Years; + return *this; + } + + // Civil calendar conventional syntax operators + constexpr year_month operator/(const year& _Year, const month& _Month) noexcept { + return {_Year, _Month}; + } + constexpr year_month operator/(const year& _Year, int _Month) noexcept { + return _Year / month{static_cast(_Month)}; + } + constexpr month_day operator/(const month& _Month, const day& _Day) noexcept { + return {_Month, _Day}; + } + constexpr month_day operator/(const month& _Month, int _Day) noexcept { + return _Month / day{static_cast(_Day)}; + } + constexpr month_day operator/(int _Month, const day& _Day) noexcept { + return month{static_cast(_Month)} / _Day; + } + constexpr month_day operator/(const day& _Day, const month& _Month) noexcept { + return _Month / _Day; + } + constexpr month_day operator/(const day& _Day, int _Month) noexcept { + return month{static_cast(_Month)} / _Day; + } + constexpr month_day_last operator/(const month& _Month, last_spec) noexcept { + return month_day_last{_Month}; + } + constexpr month_day_last operator/(int _Month, last_spec) noexcept { + return month{static_cast(_Month)} / last; + } + constexpr month_day_last operator/(last_spec, const month& _Month) noexcept { + return _Month / last; + } + constexpr month_day_last operator/(last_spec, int _Month) noexcept { + return month{static_cast(_Month)} / last; + } + constexpr month_weekday operator/(const month& _Month, const weekday_indexed& _Wdi) noexcept { + return {_Month, _Wdi}; + } + constexpr month_weekday operator/(int _Month, const weekday_indexed& _Wdi) noexcept { + return month{static_cast(_Month)} / _Wdi; + } + constexpr month_weekday operator/(const weekday_indexed& _Wdi, const month& _Month) noexcept { + return _Month / _Wdi; + } + constexpr month_weekday operator/(const weekday_indexed& _Wdi, int _Month) noexcept { + return month{static_cast(_Month)} / _Wdi; + } + constexpr month_weekday_last operator/(const month& _Month, const weekday_last& _Wdl) noexcept { + return {_Month, _Wdl}; + } + constexpr month_weekday_last operator/(int _Month, const weekday_last& _Wdl) noexcept { + return month{static_cast(_Month)} / _Wdl; + } + constexpr month_weekday_last operator/(const weekday_last& _Wdl, const month& _Month) noexcept { + return _Month / _Wdl; + } + constexpr month_weekday_last operator/(const weekday_last& _Wdl, int _Month) noexcept { + return month{static_cast(_Month)} / _Wdl; + } + constexpr year_month_day operator/(const year_month& _Ym, const day& _Day) noexcept { + return {_Ym.year(), _Ym.month(), _Day}; + } + constexpr year_month_day operator/(const year_month& _Ym, int _Day) noexcept { + return _Ym / day{static_cast(_Day)}; + } + constexpr year_month_day operator/(const year& _Year, const month_day& _Md) noexcept { + return _Year / _Md.month() / _Md.day(); + } + constexpr year_month_day operator/(int _Year, const month_day& _Md) noexcept { + return year{_Year} / _Md.month() / _Md.day(); + } + constexpr year_month_day operator/(const month_day& _Md, const year& _Year) noexcept { + return _Year / _Md.month() / _Md.day(); + } + constexpr year_month_day operator/(const month_day& _Md, int _Year) noexcept { + return year{_Year} / _Md.month() / _Md.day(); + } + constexpr year_month_day_last operator/(const year_month& _Ym, last_spec) noexcept { + return {_Ym.year(), month_day_last{_Ym.month()}}; + } + constexpr year_month_day_last operator/(const year& _Year, const month_day_last& _Mdl) noexcept { + return {_Year, _Mdl}; + } + constexpr year_month_day_last operator/(int _Year, const month_day_last& _Mdl) noexcept { + return year{_Year} / _Mdl; + } + constexpr year_month_day_last operator/(const month_day_last& _Mdl, const year& _Year) noexcept { + return _Year / _Mdl; + } + constexpr year_month_day_last operator/(const month_day_last& _Mdl, int _Year) noexcept { + return year{_Year} / _Mdl; + } + constexpr year_month_weekday operator/(const year_month& _Ym, const weekday_indexed& _Wdi) noexcept { + return year_month_weekday{_Ym.year(), _Ym.month(), _Wdi}; + } + constexpr year_month_weekday operator/(const year& _Year, const month_weekday& _Mwd) noexcept { + return year_month_weekday{_Year, _Mwd.month(), _Mwd.weekday_indexed()}; + } + constexpr year_month_weekday operator/(int _Year, const month_weekday& _Mwd) noexcept { + return year{_Year} / _Mwd; + } + constexpr year_month_weekday operator/(const month_weekday& _Mwd, const year& _Year) noexcept { + return _Year / _Mwd; + } + constexpr year_month_weekday operator/(const month_weekday& _Mwd, int _Year) noexcept { + return year{_Year} / _Mwd; + } + constexpr year_month_weekday_last operator/(const year_month& _Ym, const weekday_last& _Wdl) noexcept { + return {_Ym.year(), _Ym.month(), _Wdl}; + } + constexpr year_month_weekday_last operator/(const year& _Year, const month_weekday_last& _Mwdl) noexcept { + return {_Year, _Mwdl.month(), _Mwdl.weekday_last()}; + } + constexpr year_month_weekday_last operator/(int _Year, const month_weekday_last& _Mwdl) noexcept { + return year{_Year} / _Mwdl; + } + constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, const year& _Year) noexcept { + return _Year / _Mwdl; + } + constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, int _Year) noexcept { + return year{_Year} / _Mwdl; + } + + // Calendrical constants + inline constexpr weekday Sunday{0}; + inline constexpr weekday Monday{1}; + inline constexpr weekday Tuesday{2}; + inline constexpr weekday Wednesday{3}; + inline constexpr weekday Thursday{4}; + inline constexpr weekday Friday{5}; + inline constexpr weekday Saturday{6}; + + inline constexpr month January{1}; + inline constexpr month February{2}; + inline constexpr month March{3}; + inline constexpr month April{4}; + inline constexpr month May{5}; + inline constexpr month June{6}; + inline constexpr month July{7}; + inline constexpr month August{8}; + inline constexpr month September{9}; + inline constexpr month October{10}; + inline constexpr month November{11}; + inline constexpr month December{12}; +#endif // _HAS_CXX20 } // namespace chrono // HELPERS @@ -702,6 +2029,14 @@ inline namespace literals { long double _Val) noexcept /* strengthened */ { return chrono::duration(_Val); } +#if _HAS_CXX20 + _NODISCARD constexpr chrono::day operator"" d(unsigned long long _Day) noexcept /* strengthened */ { + return chrono::day{static_cast(_Day)}; + } + _NODISCARD constexpr chrono::year operator"" y(unsigned long long _Year) noexcept /* strengthened */ { + return chrono::year{static_cast(_Year)}; + } +#endif // _HAS_CXX20 } // namespace chrono_literals } // namespace literals diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h index 16005311b5b..db1f6880ada 100644 --- a/stl/inc/yvals_core.h +++ b/stl/inc/yvals_core.h @@ -22,6 +22,8 @@ // P0020R6 atomic, atomic, atomic // P0318R1 unwrap_reference, unwrap_ref_decay // P0325R4 to_array() +// P0355R7 Calendars And Time Zones +// (partially implemented) // P0356R5 bind_front() // P0439R0 enum class memory_order // P0457R2 starts_with()/ends_with() For basic_string/basic_string_view From 834bf8ae38fe41340bf5a3e19eba4b3d387215cc Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sat, 23 Nov 2019 13:14:50 +0000 Subject: [PATCH 002/143] Restore _Days_from_civil() --- stl/inc/chrono | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index eb4d5483a72..43dc5d24963 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1464,6 +1464,17 @@ namespace chrono { const unsigned _M = _Mp + (_Mp < 10 ? 3 : -9); return year_month_day(chrono::year{_Y + (_M <= 2)}, chrono::month{_M}, chrono::day{_D}); } + constexpr days year_month_day::_Days_from_civil() const noexcept { + static_assert(_STD numeric_limits::digits >= 18); + static_assert(_STD numeric_limits::digits >= 20); + const int _Y = static_cast(_Year) - (_Month <= chrono::month{2}); + const unsigned _M = static_cast(_Month); + const int _Era = (_Y >= 0 ? _Y : _Y - 399) / 400; + const unsigned _Yoe = static_cast(_Y - _Era * 400); + const unsigned _Doy = (153 * (_M + (_M > 2 ? -3 : 9)) + 2) / 5 + static_cast(_Day) - 1; + const unsigned _Doe = _Yoe * 365 + _Yoe / 4 - _Yoe / 100 + _Doy; + return days{_Era * 146097 + static_cast(_Doe) - 719468}; + } constexpr year_month_day::year_month_day( const chrono::year& _Y, const chrono::month& _M, const chrono::day& _D) noexcept @@ -1486,7 +1497,7 @@ namespace chrono { } constexpr year_month_day::operator sys_days() const noexcept { - return sys_days{_Year / _Month / chrono::day{1}} + (_Day - chrono::day{1}); + return sys_days{_Days_from_civil()}; } constexpr year_month_day::operator local_days() const noexcept { return _STD chrono::local_days{static_cast(*this).time_since_epoch()}; From cda289a09ab569ed7187a99abedb4e5cb3390e6c Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sun, 24 Nov 2019 17:11:50 +0000 Subject: [PATCH 003/143] Remove new lines --- stl/inc/chrono | 3 --- 1 file changed, 3 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 43dc5d24963..46c57d7cd71 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1302,10 +1302,8 @@ namespace chrono { constexpr bool month_day::ok() const noexcept { if (!_Month.ok() || !_Day.ok()) return false; - const auto _D = static_cast(_Day); const auto _M = static_cast(_Month); - if (_M == 2 && _D > 29) return false; if (_M == 4 || _M == 6 || _M == 9 || _M == 11) @@ -1660,7 +1658,6 @@ namespace chrono { constexpr year_month_weekday::year_month_weekday(const local_days& _Local_days) noexcept : year_month_weekday{_Ymwd_from_days(_Local_days.time_since_epoch())} {} - constexpr chrono::year year_month_weekday::year() const noexcept { return _Year; } From 91dd7bb835f31d126633bd7fca50edd6713abb9e Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sun, 24 Nov 2019 17:20:47 +0000 Subject: [PATCH 004/143] Use year_month_day_last for year_month_weekday::ok() --- stl/inc/chrono | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 46c57d7cd71..e7a1e8e82c4 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1689,9 +1689,10 @@ namespace chrono { return false; if (_Weekday_index.index() <= 4) return true; - const sys_days _First = _Year / _Month / chrono::weekday_indexed{weekday(), 1}; - const sys_days _Four = _First + days{28}; - return year_month_day{_Four}.month() == _Month; + const sys_days _First = _Year / _Month / 1; + const days _Diff = weekday() - chrono::weekday{_First}; + const days _Last = _Diff + days{29}; + return static_cast(_Last.count()) <= static_cast((year() / month() / last).day()); } constexpr bool operator==(const year_month_weekday& _Left, const year_month_weekday& _Right) noexcept { return _Left.year() == _Right.year() && _Left.month() == _Right.month() From dc5fda1ef9733ffe8eb4305271981e1fc4e9885e Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Fri, 3 Apr 2020 14:33:56 +0100 Subject: [PATCH 005/143] Use auto and disable warning supression --- stl/inc/chrono | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 58e2a9d1714..ab09c7d0931 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -21,7 +21,7 @@ #pragma pack(push, _CRT_PACKING) #pragma warning(push, _STL_WARNING_LEVEL) #pragma warning(disable : _STL_DISABLED_WARNINGS) -#pragma warning(disable : 4308) // needed for constexpr date arithmetic +// #pragma warning(disable : 4308) // needed for constexpr date arithmetic _STL_DISABLE_CLANG_WARNINGS #pragma push_macro("new") #undef new @@ -1229,8 +1229,8 @@ namespace chrono { return _Left + -_Right; } constexpr days operator-(const weekday& _Left, const weekday& _Right) noexcept { - const int _Wd = _Left.c_encoding() - _Right.c_encoding(); - const int _Wk = (_Wd >= 0 ? _Wd : _Wd - 6) / 7; + const auto _Wd = _Left.c_encoding() - _Right.c_encoding(); + const auto _Wk = (_Wd >= 0 ? _Wd : _Wd - 6) / 7; return days{_Wd - _Wk * 7}; } From 8db80ecb1ac6c0b89c0c8232fe67ba7caad80102 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Fri, 3 Apr 2020 15:27:47 +0100 Subject: [PATCH 006/143] Initial test code --- tests/std/test.lst | 1 + .../env.lst | 4 ++ .../test.cpp | 40 +++++++++++++++++++ 3 files changed, 45 insertions(+) create mode 100644 tests/std/tests/P0355R7_calendars_and_time_zones_dates/env.lst create mode 100644 tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp diff --git a/tests/std/test.lst b/tests/std/test.lst index 6d2945178b3..67232ef8ac9 100644 --- a/tests/std/test.lst +++ b/tests/std/test.lst @@ -205,6 +205,7 @@ tests\P0220R1_sample tests\P0220R1_searchers tests\P0220R1_string_view tests\P0325R4_to_array +tests\P0355R7_calendars_and_time_zones_dates tests\P0356R5_bind_front tests\P0357R3_supporting_incomplete_types_in_reference_wrapper tests\P0414R2_shared_ptr_for_arrays diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/env.lst b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/env.lst new file mode 100644 index 00000000000..642f530ffad --- /dev/null +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/env.lst @@ -0,0 +1,4 @@ +# Copyright (c) Microsoft Corporation. +# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +RUNALL_INCLUDE ..\usual_latest_matrix.lst diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp new file mode 100644 index 00000000000..5fc2cd3ad0f --- /dev/null +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -0,0 +1,40 @@ +// Copyright (c) Microsoft Corporation. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +#include +#include +#include + +using namespace std; +using namespace std::chrono; + +constexpr bool day_test() { + static_assert(is_trivially_copyable_v, "chrono::day is not trivially copyable"); + static_assert(is_standard_layout_v, "chrono::day is not standard layout"); + + day d1{0u}; + assert(static_cast(d1) == 0); + assert(static_cast(++d1) == 1); + assert(static_cast(d1++) == 1); + assert(static_cast(d1) == 2); + + assert(static_cast(--d1) == 1); + assert(static_cast(d1--) == 1); + assert(static_cast(d1) == 0); + + d1 += days{2}; + assert(static_cast(d1) == 2); + d1 -= days{2}; + assert(static_cast(d1) == 0); + + day d2{0u}; + assert(d1 == d2); + + return true; +} + + +int main() { + day_test(); + static_assert(day_test()); +} From 085832023facbcf78d23234e1a47e38f362b995b Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Fri, 3 Apr 2020 21:13:21 +0100 Subject: [PATCH 007/143] Fix day - days --- stl/inc/chrono | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index ab09c7d0931..970e6d103a3 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1036,7 +1036,7 @@ namespace chrono { return _Right + _Left; } constexpr day operator-(const day& _Left, const days& _Right) noexcept { - return _Left + -_Right; + return day{static_cast(_Left) - _Right.count()}; } constexpr days operator-(const day& _Left, const day& _Right) noexcept { return days{static_cast(static_cast(_Left)) - static_cast(static_cast(_Right))}; From 589eaf1386749652b27a50da275e540a3422126d Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sat, 4 Apr 2020 09:12:23 +0100 Subject: [PATCH 008/143] Finish day_test() --- .../test.cpp | 27 +++++++++++++++---- 1 file changed, 22 insertions(+), 5 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 5fc2cd3ad0f..0db55ce5c9b 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -8,7 +8,7 @@ using namespace std; using namespace std::chrono; -constexpr bool day_test() { +constexpr void day_test() { static_assert(is_trivially_copyable_v, "chrono::day is not trivially copyable"); static_assert(is_standard_layout_v, "chrono::day is not standard layout"); @@ -28,13 +28,30 @@ constexpr bool day_test() { assert(static_cast(d1) == 0); day d2{0u}; - assert(d1 == d2); + assert(d1 == d2++); + assert(d1 < d2); + assert(d2 > d1); + + day d3{0}; + assert(!d3.ok()); + ++d3; + for (int i = 1; i <= 31; ++i, ++d3) { + assert(d3.ok()); + } + assert(!d3.ok()); + + const auto d4 = 0d; + assert(d1 == d4); + static_assert(is_same_v, "0d is not chrono::day"); + // static_assert(is_same_v, "d4 is not chrono::day"); +} +constexpr bool test() { + day_test(); return true; } - int main() { - day_test(); - static_assert(day_test()); + test(); + static_assert(test()); } From 25f90b6a516f5ca2549a6f80875d99ff655c45a2 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sat, 4 Apr 2020 09:34:45 +0100 Subject: [PATCH 009/143] Missed day - day --- .../P0355R7_calendars_and_time_zones_dates/test.cpp | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 0db55ce5c9b..08d88ae750c 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -40,10 +40,15 @@ constexpr void day_test() { } assert(!d3.ok()); - const auto d4 = 0d; - assert(d1 == d4); + const day d4{2}; + const day d5{10}; + const days diff = d5 - d4; + assert(diff.count() == 8); + + const auto d6 = 0d; + assert(d1 == d6); static_assert(is_same_v, "0d is not chrono::day"); - // static_assert(is_same_v, "d4 is not chrono::day"); + // static_assert(is_same_v, "d6 is not chrono::day"); } constexpr bool test() { From f7e321ab71d44fa1465829dec974219c7181f2f5 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sat, 4 Apr 2020 11:03:56 +0100 Subject: [PATCH 010/143] Add month_test() --- .../test.cpp | 59 ++++++++++++++++++- 1 file changed, 58 insertions(+), 1 deletion(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 08d88ae750c..82a140df943 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -51,12 +51,69 @@ constexpr void day_test() { // static_assert(is_same_v, "d6 is not chrono::day"); } +constexpr void month_test() { + static_assert(is_trivially_copyable_v, "chrono::month is not trivially copyable"); + static_assert(is_standard_layout_v, "chrono::month is not standard layout"); + + month m1{1u}; + assert(static_cast(m1) == 1); + assert(static_cast(++m1) == 2); + assert(static_cast(m1++) == 2); + assert(static_cast(m1) == 3); + + assert(static_cast(--m1) == 2); + assert(static_cast(m1--) == 2); + assert(static_cast(m1) == 1); + + m1 += months{2}; + assert(static_cast(m1) == 3); + m1 -= months{2}; + assert(static_cast(m1) == 1); + + for (unsigned i = 0; i <= 255; ++i) { + if (i >= 1 && i <= 12) { + assert(month{i}.ok()); + } else { + assert(!month{i}.ok()); + } + } + + month m2{1u}; + assert(m1 == m2++); + assert(m2 > m1); + assert(m1 < m2); + + month m3 = m2 + months{11}; + assert(static_cast(m3) == 1); + m3 = months{11} + m2; + assert(static_cast(m3) == 1); + month m4 = m2 - months{2}; + assert(m4 == month{12}); + + months diff = m1 - m2; + assert(diff == months{11}); + + assert(month{1} == January); + assert(month{2} == February); + assert(month{3} == March); + assert(month{4} == April); + assert(month{5} == May); + assert(month{6} == June); + assert(month{7} == July); + assert(month{8} == August); + assert(month{9} == September); + assert(month{10} == October); + assert(month{11} == November); + assert(month{12} == December); +} + constexpr bool test() { day_test(); + month_test(); return true; } int main() { test(); - static_assert(test()); + // static_assert(test()); } From c0217d1c493aa9892891f5924a74116f87d770b9 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sat, 4 Apr 2020 11:10:22 +0100 Subject: [PATCH 011/143] Use types instead of casting --- .../test.cpp | 38 +++++++++---------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 82a140df943..a7251af6ab1 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -14,18 +14,18 @@ constexpr void day_test() { day d1{0u}; assert(static_cast(d1) == 0); - assert(static_cast(++d1) == 1); - assert(static_cast(d1++) == 1); - assert(static_cast(d1) == 2); + assert(++d1 == day{1}); + assert(d1++ == day{1}); + assert(d1 == day{2}); - assert(static_cast(--d1) == 1); - assert(static_cast(d1--) == 1); - assert(static_cast(d1) == 0); + assert(--d1 == day{1}); + assert(d1-- == day{1}); + assert(d1 == day{0}); d1 += days{2}; - assert(static_cast(d1) == 2); + assert(d1 == day{2}); d1 -= days{2}; - assert(static_cast(d1) == 0); + assert(d1 == day{0}); day d2{0u}; assert(d1 == d2++); @@ -43,7 +43,7 @@ constexpr void day_test() { const day d4{2}; const day d5{10}; const days diff = d5 - d4; - assert(diff.count() == 8); + assert(diff == days{8}); const auto d6 = 0d; assert(d1 == d6); @@ -57,18 +57,18 @@ constexpr void month_test() { month m1{1u}; assert(static_cast(m1) == 1); - assert(static_cast(++m1) == 2); - assert(static_cast(m1++) == 2); - assert(static_cast(m1) == 3); + assert(++m1 == month{2}); + assert(m1++ == month{2}); + assert(m1 == month{3}); - assert(static_cast(--m1) == 2); - assert(static_cast(m1--) == 2); - assert(static_cast(m1) == 1); + assert(--m1 == month{2}); + assert(m1-- == month{2}); + assert(m1 == month{1}); m1 += months{2}; - assert(static_cast(m1) == 3); + assert(m1 == month{3}); m1 -= months{2}; - assert(static_cast(m1) == 1); + assert(m1 == month{1}); for (unsigned i = 0; i <= 255; ++i) { if (i >= 1 && i <= 12) { @@ -84,9 +84,9 @@ constexpr void month_test() { assert(m1 < m2); month m3 = m2 + months{11}; - assert(static_cast(m3) == 1); + assert(m3 == month{1}); m3 = months{11} + m2; - assert(static_cast(m3) == 1); + assert(m3 == month{1}); month m4 = m2 - months{2}; assert(m4 == month{12}); From e5bc02145f3c62d8d4c33a769a2cb37596dfbb01 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sat, 4 Apr 2020 12:30:42 +0100 Subject: [PATCH 012/143] Add year_test() --- .../test.cpp | 70 ++++++++++++++++++- 1 file changed, 68 insertions(+), 2 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index a7251af6ab1..07521743909 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -48,7 +48,7 @@ constexpr void day_test() { const auto d6 = 0d; assert(d1 == d6); static_assert(is_same_v, "0d is not chrono::day"); - // static_assert(is_same_v, "d6 is not chrono::day"); + static_assert(is_same_v, "d6 is not chrono::day"); } constexpr void month_test() { @@ -63,7 +63,7 @@ constexpr void month_test() { assert(--m1 == month{2}); assert(m1-- == month{2}); - assert(m1 == month{1}); + assert(m1 == month{1}); m1 += months{2}; assert(m1 == month{3}); @@ -93,6 +93,18 @@ constexpr void month_test() { months diff = m1 - m2; assert(diff == months{11}); + static_assert(is_same_v); + static_assert(is_same_v); + static_assert(is_same_v); + static_assert(is_same_v); + static_assert(is_same_v); + static_assert(is_same_v); + static_assert(is_same_v); + static_assert(is_same_v); + static_assert(is_same_v); + static_assert(is_same_v); + static_assert(is_same_v); + static_assert(is_same_v); assert(month{1} == January); assert(month{2} == February); assert(month{3} == March); @@ -107,9 +119,63 @@ constexpr void month_test() { assert(month{12} == December); } +constexpr void year_test() { + static_assert(is_trivially_copyable_v, "chrono::year is not trivially copyable"); + static_assert(is_standard_layout_v, "chrono::year is not standard layout"); + + year y1{1}; + assert(static_cast(y1) == 1); + assert(++y1 == year{2}); + assert(y1++ == year{2}); + assert(y1 == year{3}); + + assert(--y1 == year{2}); + assert(y1-- == year{2}); + assert(y1 == year{1}); + + y1 += years{2}; + assert(y1 == year{3}); + y1 -= years{2}; + assert(y1 == year{1}); + + assert(+y1 == year{1}); + assert(-y1 == year{-1}); + + constexpr int y_min = -32767; + constexpr int y_max = 32767; + assert(year::min() == year{y_min}); + assert(year::max() == year{y_max}); + + for (int i = y_min; i <= y_max; i++) { + assert(year{i}.ok()); + if (i % 4 == 0 && (i % 100 != 0 || i % 400 == 0)) { + assert(year{i}.is_leap()); + } else { + assert(!year{i}.is_leap()); + } + } + year y2{1}; + assert(y1 == y2++); + assert(y1 < y2); + assert(y2 > y1); + + y2 = y1 + years{4}; + assert(y2 == year{5}); + y2 = years{4} + y1; + assert(y2 == year{5}); + + year y3 = y2 - years{4}; + assert(y3 == year{1}); + + const auto y4 = 2020y; + static_assert(is_same_v, "0y is not chrono::year"); + static_assert(is_same_v, "y4 is not chrono::year"); +} + constexpr bool test() { day_test(); month_test(); + year_test(); return true; } From ee0efe8f25b7606b6c9dbc95b5a96c79ea3c7606 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sat, 4 Apr 2020 15:49:54 +0100 Subject: [PATCH 013/143] Add weekday_test() and fix formatting --- .../test.cpp | 60 ++++++++++++++++++- 1 file changed, 58 insertions(+), 2 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 07521743909..7ba6c28fcee 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -131,7 +131,7 @@ constexpr void year_test() { assert(--y1 == year{2}); assert(y1-- == year{2}); - assert(y1 == year{1}); + assert(y1 == year{1}); y1 += years{2}; assert(y1 == year{3}); @@ -166,16 +166,72 @@ constexpr void year_test() { year y3 = y2 - years{4}; assert(y3 == year{1}); - + const auto y4 = 2020y; static_assert(is_same_v, "0y is not chrono::year"); static_assert(is_same_v, "y4 is not chrono::year"); } +constexpr void weekday_test() { + static_assert(is_trivially_copyable_v, "chrono::weekday is not trivially copyable"); + static_assert(is_standard_layout_v, "chrono::weekday is not standard layout"); + + assert(weekday{7} == weekday{0}); + assert(weekday{sys_days{}} == weekday{4}); + assert(weekday{local_days{}} == sys_days{local_days{}.time_since_epoch()}); + + weekday wd{0u}; + assert(wd == weekday{0}); + assert(++wd == weekday{1}); + assert(wd++ == weekday{1}); + assert(wd == weekday{2}); + + assert(--wd == weekday{1}); + assert(wd-- == weekday{1}); + assert(wd == weekday{0}); + + wd += days{2}; + assert(wd == weekday{2}); + wd -= days{3}; + assert(wd == weekday{6}); + + assert(weekday{0}.c_encoding() == 0u); + assert(weekday{0}.iso_encoding() == 7u); + + for (unsigned i = 0; i <= 255; ++i) { + if (i <= 7) { + assert(weekday{i}.ok()); + } else { + assert(!weekday{i}.ok()); + } + } + static_assert(is_same_v); + static_assert(is_same_v); + + assert(weekday{1} + days{6} == weekday{0}); + // assert(weekday{0} - weekday{1} == days{6}); + + static_assert(is_same_v); + static_assert(is_same_v); + static_assert(is_same_v); + static_assert(is_same_v); + static_assert(is_same_v); + static_assert(is_same_v); + static_assert(is_same_v); + assert(weekday{0} == Sunday); + assert(weekday{1} == Monday); + assert(weekday{2} == Tuesday); + assert(weekday{3} == Wednesday); + assert(weekday{4} == Thursday); + assert(weekday{5} == Friday); + assert(weekday{6} == Saturday); +} + constexpr bool test() { day_test(); month_test(); year_test(); + weekday_test(); return true; } From f6c31bee7d641b0f9757be0bdc88240f983b2200 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sat, 4 Apr 2020 16:05:12 +0100 Subject: [PATCH 014/143] Fix weekday - weekday --- stl/inc/chrono | 4 ++-- .../std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 970e6d103a3..e8d8a7ef4d8 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1230,8 +1230,8 @@ namespace chrono { } constexpr days operator-(const weekday& _Left, const weekday& _Right) noexcept { const auto _Wd = _Left.c_encoding() - _Right.c_encoding(); - const auto _Wk = (_Wd >= 0 ? _Wd : _Wd - 6) / 7; - return days{_Wd - _Wk * 7}; + const auto _Wk = _Wd <= 6 ? _Wd : _Wd + 7; + return days{_Wk}; } constexpr weekday& weekday::operator++() noexcept { diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 7ba6c28fcee..a0a92dff8ed 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -209,7 +209,7 @@ constexpr void weekday_test() { static_assert(is_same_v); assert(weekday{1} + days{6} == weekday{0}); - // assert(weekday{0} - weekday{1} == days{6}); + assert(weekday{0} - weekday{1} == days{6}); static_assert(is_same_v); static_assert(is_same_v); From 95317cb3e69f9961c6c68772f2569bcfa265989c Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sat, 4 Apr 2020 16:21:36 +0100 Subject: [PATCH 015/143] Add weekday_indexed_test() and restore static_assert --- .../test.cpp | 30 ++++++++++++++++++- 1 file changed, 29 insertions(+), 1 deletion(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index a0a92dff8ed..93c095d7091 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -227,15 +227,43 @@ constexpr void weekday_test() { assert(weekday{6} == Saturday); } +constexpr void weekday_indexed_test() { + static_assert(is_trivially_copyable_v, "chrono::weekday_indexed is not trivially copyable"); + static_assert(is_standard_layout_v, "chrono::weekday_indexed is not standard layout"); + + weekday_indexed wdi1{Monday, 2}; + assert(wdi1.weekday() == Monday); + assert(wdi1.index() == 2); + + weekday_indexed wdi2 = Monday[2]; + assert(wdi2.weekday() == Monday); + assert(wdi2.index() == 2); + + assert(wdi1 == wdi2); + + assert(!weekday_indexed(Sunday, 0).ok()); + for (unsigned i = 1; i <= 5; i++) { + assert(weekday_indexed(Sunday, i).ok()); + assert(weekday_indexed(Monday, i).ok()); + assert(weekday_indexed(Tuesday, i).ok()); + assert(weekday_indexed(Wednesday, i).ok()); + assert(weekday_indexed(Thursday, i).ok()); + assert(weekday_indexed(Friday, i).ok()); + assert(weekday_indexed(Saturday, i).ok()); + } + assert(!weekday_indexed(Sunday, 6).ok()); +} + constexpr bool test() { day_test(); month_test(); year_test(); weekday_test(); + weekday_indexed_test(); return true; } int main() { test(); - // static_assert(test()); + static_assert(test()); } From a7011108ef4a08188d740a31834b49ae53d26364 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sat, 4 Apr 2020 18:29:05 +0100 Subject: [PATCH 016/143] Add weekday_last_test() --- .../P0355R7_calendars_and_time_zones_dates/test.cpp | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 93c095d7091..d24476fd9c0 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -254,12 +254,24 @@ constexpr void weekday_indexed_test() { assert(!weekday_indexed(Sunday, 6).ok()); } +constexpr void weekday_last_test() { + static_assert(is_trivially_copyable_v, "chrono::weekday_last is not trivially copyable"); + static_assert(is_standard_layout_v, "chrono::weekday_last is not standard layout"); + + assert(weekday_last{Monday}.ok()); + assert(Monday[last].ok()); + assert(Monday[last].weekday() == Monday); + assert(weekday_last{Monday}.weekday() == Monday); + assert(weekday_last{Monday} == weekday_last{Monday}); +} + constexpr bool test() { day_test(); month_test(); year_test(); weekday_test(); weekday_indexed_test(); + weekday_last_test(); return true; } From b6613a4fedec9fb2956c07b0a0c0ca3c0b6f568f Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sun, 5 Apr 2020 14:43:24 +0100 Subject: [PATCH 017/143] Add test for time_point arithmetic --- CMakeSettings.json | 12 +++++-- tests/std/test.lst | 1 + .../env.lst | 4 +++ .../test.cpp | 31 +++++++++++++++++++ 4 files changed, 45 insertions(+), 3 deletions(-) create mode 100644 tests/std/tests/P0355R7_calendars_and_time_zones_time_point_arithmetic/env.lst create mode 100644 tests/std/tests/P0355R7_calendars_and_time_zones_time_point_arithmetic/test.cpp diff --git a/CMakeSettings.json b/CMakeSettings.json index f5c1dfff5c1..7765e991699 100644 --- a/CMakeSettings.json +++ b/CMakeSettings.json @@ -1,4 +1,4 @@ -{ +{ "configurations": [ { "name": "x86", @@ -22,7 +22,13 @@ "generator": "Ninja", "inheritEnvironments": [ "msvc_x64_x64" ], "installRoot": "${projectDir}\\out\\install\\${name}", - "variables": [] + "variables": [ + { + "name": "BUILD_TESTING", + "value": "True", + "type": "BOOL" + } + ] }, { "name": "ARM", @@ -49,4 +55,4 @@ "variables": [] } ] -} +} \ No newline at end of file diff --git a/tests/std/test.lst b/tests/std/test.lst index 67232ef8ac9..220bc04d1be 100644 --- a/tests/std/test.lst +++ b/tests/std/test.lst @@ -206,6 +206,7 @@ tests\P0220R1_searchers tests\P0220R1_string_view tests\P0325R4_to_array tests\P0355R7_calendars_and_time_zones_dates +tests\P0355R7_calendars_and_time_zones_time_point_arithmetic tests\P0356R5_bind_front tests\P0357R3_supporting_incomplete_types_in_reference_wrapper tests\P0414R2_shared_ptr_for_arrays diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_arithmetic/env.lst b/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_arithmetic/env.lst new file mode 100644 index 00000000000..642f530ffad --- /dev/null +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_arithmetic/env.lst @@ -0,0 +1,4 @@ +# Copyright (c) Microsoft Corporation. +# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +RUNALL_INCLUDE ..\usual_latest_matrix.lst diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_arithmetic/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_arithmetic/test.cpp new file mode 100644 index 00000000000..2cdb4f46eb8 --- /dev/null +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_arithmetic/test.cpp @@ -0,0 +1,31 @@ +// Copyright (c) Microsoft Corporation. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +#include +#include + +using namespace std::chrono; + +constexpr bool test() { + steady_clock::time_point tp1; + auto tp2 = tp1++; + assert(tp1.time_since_epoch().count() == 1); + assert(tp2.time_since_epoch().count() == 0); + tp2 = ++tp1; + assert(tp1.time_since_epoch().count() == 2); + assert(tp2.time_since_epoch().count() == 2); + + tp2 = tp1--; + assert(tp1.time_since_epoch().count() == 1); + assert(tp2.time_since_epoch().count() == 2); + tp2 = --tp1; + assert(tp1.time_since_epoch().count() == 0); + assert(tp2.time_since_epoch().count() == 0); + + return true; +} + +int main() { + test(); + static_assert(test()); +} From 6a84894535f71dd9f327c9d99bd37cfc694f425a Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sun, 5 Apr 2020 15:06:55 +0100 Subject: [PATCH 018/143] Create macro for type requirements --- .../test.cpp | 27 ++++++++++--------- 1 file changed, 15 insertions(+), 12 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index d24476fd9c0..7ddbf59fd19 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -8,9 +8,12 @@ using namespace std; using namespace std::chrono; +#define TRIVIAL_COPY_STANDARD_LAYOUT(TYPE) \ + static_assert(is_trivially_copyable_v, "chrono::" #TYPE " is not trivially copyable"); \ + static_assert(is_standard_layout_v, "chrono::" #TYPE " is not standard layout"); + constexpr void day_test() { - static_assert(is_trivially_copyable_v, "chrono::day is not trivially copyable"); - static_assert(is_standard_layout_v, "chrono::day is not standard layout"); + TRIVIAL_COPY_STANDARD_LAYOUT(day) day d1{0u}; assert(static_cast(d1) == 0); @@ -52,8 +55,7 @@ constexpr void day_test() { } constexpr void month_test() { - static_assert(is_trivially_copyable_v, "chrono::month is not trivially copyable"); - static_assert(is_standard_layout_v, "chrono::month is not standard layout"); + TRIVIAL_COPY_STANDARD_LAYOUT(month) month m1{1u}; assert(static_cast(m1) == 1); @@ -120,8 +122,7 @@ constexpr void month_test() { } constexpr void year_test() { - static_assert(is_trivially_copyable_v, "chrono::year is not trivially copyable"); - static_assert(is_standard_layout_v, "chrono::year is not standard layout"); + TRIVIAL_COPY_STANDARD_LAYOUT(year) year y1{1}; assert(static_cast(y1) == 1); @@ -173,8 +174,7 @@ constexpr void year_test() { } constexpr void weekday_test() { - static_assert(is_trivially_copyable_v, "chrono::weekday is not trivially copyable"); - static_assert(is_standard_layout_v, "chrono::weekday is not standard layout"); + TRIVIAL_COPY_STANDARD_LAYOUT(weekday) assert(weekday{7} == weekday{0}); assert(weekday{sys_days{}} == weekday{4}); @@ -228,8 +228,7 @@ constexpr void weekday_test() { } constexpr void weekday_indexed_test() { - static_assert(is_trivially_copyable_v, "chrono::weekday_indexed is not trivially copyable"); - static_assert(is_standard_layout_v, "chrono::weekday_indexed is not standard layout"); + TRIVIAL_COPY_STANDARD_LAYOUT(weekday_indexed) weekday_indexed wdi1{Monday, 2}; assert(wdi1.weekday() == Monday); @@ -255,8 +254,7 @@ constexpr void weekday_indexed_test() { } constexpr void weekday_last_test() { - static_assert(is_trivially_copyable_v, "chrono::weekday_last is not trivially copyable"); - static_assert(is_standard_layout_v, "chrono::weekday_last is not standard layout"); + TRIVIAL_COPY_STANDARD_LAYOUT(weekday_last) assert(weekday_last{Monday}.ok()); assert(Monday[last].ok()); @@ -265,6 +263,10 @@ constexpr void weekday_last_test() { assert(weekday_last{Monday} == weekday_last{Monday}); } +constexpr void month_day_test() { + TRIVIAL_COPY_STANDARD_LAYOUT(month_day) +} + constexpr bool test() { day_test(); month_test(); @@ -272,6 +274,7 @@ constexpr bool test() { weekday_test(); weekday_indexed_test(); weekday_last_test(); + month_day_test(); return true; } From 4a4757361b3d8fc7c6ceb1276621ecc0932d035d Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sun, 5 Apr 2020 15:54:41 +0100 Subject: [PATCH 019/143] Add month_day_test() --- .../test.cpp | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 7ddbf59fd19..90b4e4ace96 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -265,6 +265,34 @@ constexpr void weekday_last_test() { constexpr void month_day_test() { TRIVIAL_COPY_STANDARD_LAYOUT(month_day) + + month_day md{January, 1d}; + assert(md.month() == January); + assert(md.day() == 1d); + + assert(md < month_day(January, 2d)); + assert(month_day(January, 2d) > md); + assert(md < month_day(December, 25d)); + assert(month_day(December, 25d) > md); + assert(md == month_day(January, 1d)); + + for (unsigned i = 1; i <= 12; ++i) { + month m{i}; + for (unsigned d = 0; d <= 32; ++d) { + if (d == 0) { + assert(!month_day(m, day{d}).ok()); + } else if (d == 30 && m == February) { + assert(!month_day(m, day{d}).ok()); + break; + } else if (d == 31 && (m == April || m == June || m == September || m == November)) { + assert(!month_day(m, day{d}).ok()); + } else if (d == 32) { + assert(!month_day(m, day{d}).ok()); + } else { + assert(month_day(m, day{d}).ok()); + } + } + } } constexpr bool test() { From f4f998dc41d4a3f624f027b22065513cd14d5c3c Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sun, 5 Apr 2020 16:01:10 +0100 Subject: [PATCH 020/143] Restore CMakeSettings.json --- CMakeSettings.json | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) diff --git a/CMakeSettings.json b/CMakeSettings.json index 7765e991699..f5c1dfff5c1 100644 --- a/CMakeSettings.json +++ b/CMakeSettings.json @@ -1,4 +1,4 @@ -{ +{ "configurations": [ { "name": "x86", @@ -22,13 +22,7 @@ "generator": "Ninja", "inheritEnvironments": [ "msvc_x64_x64" ], "installRoot": "${projectDir}\\out\\install\\${name}", - "variables": [ - { - "name": "BUILD_TESTING", - "value": "True", - "type": "BOOL" - } - ] + "variables": [] }, { "name": "ARM", @@ -55,4 +49,4 @@ "variables": [] } ] -} \ No newline at end of file +} From 22cbc25c77597f4b98c556ed16625a66ce74e5f5 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Mon, 6 Apr 2020 10:56:57 +0100 Subject: [PATCH 021/143] Add month_day_last_test() --- .../test.cpp | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 90b4e4ace96..0d5b4737e57 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -295,6 +295,25 @@ constexpr void month_day_test() { } } +constexpr void month_day_last_test() { + TRIVIAL_COPY_STANDARD_LAYOUT(month_day_last) + + assert(month_day_last{February}.month() == February); + const auto mdl = January / last; + static_assert(is_same_v, "mdl is not const chrono::month_day_last"); + + unsigned i = 0; + assert(!month_day_last{month{i++}}.ok()); + for (; i <= 12; ++i) { + assert(month_day_last{month{i}}.ok()); + } + assert(!month_day_last{month{i}}.ok()); + + assert(month_day_last{January} == month_day_last{January}); + assert(month_day_last{January} < month_day_last{February}); + assert(month_day_last{December} > month_day_last{February}); +} + constexpr bool test() { day_test(); month_test(); @@ -303,6 +322,7 @@ constexpr bool test() { weekday_indexed_test(); weekday_last_test(); month_day_test(); + month_day_last_test(); return true; } From 797414a8529f13b90db79e77e557c60e5737accb Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Mon, 6 Apr 2020 11:38:53 +0100 Subject: [PATCH 022/143] Add year_month_test() --- .../test.cpp | 55 +++++++++++++++++++ 1 file changed, 55 insertions(+) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 0d5b4737e57..f272198282d 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -314,6 +314,60 @@ constexpr void month_day_last_test() { assert(month_day_last{December} > month_day_last{February}); } +constexpr void year_month_test() { + TRIVIAL_COPY_STANDARD_LAYOUT(year_month) + + year_month ym{2020y, January}; + assert(ym.year() == 2020y); + assert(ym.month() == January); + + ym += months{2}; + assert(ym.year() == 2020y); + assert(ym.month() == March); + ym -= months{2}; + assert(ym.year() == 2020y); + assert(ym.month() == January); + + ym += years{2}; + assert(ym.year() == 2022y); + assert(ym.month() == January); + ym -= years{2}; + assert(ym.year() == 2020y); + assert(ym.month() == January); + + // error C2131: expression did not evaluate to a constant + // failure was caused by evaluation exceeding step limit of 1048576 + // for (int i = static_cast(year::min()); i <= static_cast(year::max()); i++) { + // for (unsigned j = 0; j <= 255; ++j) { + // const year_month ym_is{year{i}, month{j}}; + // if (j >= 1 && j <= 12) { + // assert(ym_is.ok()); + // } else { + // assert(!ym_is.ok()); + // } + // } + //} + + assert((year_month{2020y, April} == year_month{2020y, April})); + assert((year_month{2019y, April} < year_month{2020y, April})); + assert((year_month{2020y, March} < year_month{2020y, April})); + assert((year_month{2020y, April} > year_month{2019y, April})); + assert((year_month{2020y, April} > year_month{2020y, March})); + + assert((ym + months{2} == year_month{2020y, March})); + assert((year_month{2020y, March} == ym + months{2})); + + assert((ym - months{2} == year_month{2019y, November})); + + assert((ym - year_month{2019y, January} == months{12})); + + assert((ym + years{2} == year_month{2022y, January})); + assert((year_month{2022y, January} == ym + years{2})); + + + assert((ym - years{2} == year_month{2018y, January})); +} + constexpr bool test() { day_test(); month_test(); @@ -323,6 +377,7 @@ constexpr bool test() { weekday_last_test(); month_day_test(); month_day_last_test(); + year_month_test(); return true; } From 2b3206dfbb25cce2c7d7d22a1d73f315cbd5f3d6 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Mon, 6 Apr 2020 13:51:13 +0100 Subject: [PATCH 023/143] Add month_weekday_test() and month_weekday_last_test() --- .../test.cpp | 37 +++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index f272198282d..5f445082cc0 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -314,6 +314,41 @@ constexpr void month_day_last_test() { assert(month_day_last{December} > month_day_last{February}); } +constexpr void month_weekday_test() { + TRIVIAL_COPY_STANDARD_LAYOUT(month_weekday) + + const month_weekday mwd1{January, Monday[2]}; + assert(mwd1.month() == January); + assert(mwd1.weekday_indexed().weekday() == Monday); + assert(mwd1.weekday_indexed().index() == 2); + + // error C2131: expression did not evaluate to a constant + // failure was caused by evaluation exceeding step limit of 1048576 + // for (unsigned m = 0; m <= 255; ++m) { + // for (unsigned wd = 0; wd <= 255; ++wd) { + // for (unsigned wdi = 0; wdi <= 6; ++wdi) { + // const month_weekday mwd2{month{m}, weekday_indexed{weekday{wd}, wdi}}; + // if (m >= 1 && m <= 12 && wd <= 7 && wdi >= 1 && wdi <= 5) { + // assert(mwd2.ok()); + // } else { + // assert(!mwd2.ok()); + // } + // } + // } + //} + + assert((month_weekday{January, Monday[2]} == month_weekday{January, Monday[2]})); +} + +constexpr void month_weekday_last_test() { + TRIVIAL_COPY_STANDARD_LAYOUT(month_weekday_last) + + month_weekday_last mwdl{January, Monday[last]}; + assert(mwdl.month() == January); + assert(mwdl.weekday_last().weekday() == Monday); + assert((mwdl == month_weekday_last{January, Monday[last]})); +} + constexpr void year_month_test() { TRIVIAL_COPY_STANDARD_LAYOUT(year_month) @@ -377,6 +412,8 @@ constexpr bool test() { weekday_last_test(); month_day_test(); month_day_last_test(); + month_weekday_test(); + month_weekday_last_test(); year_month_test(); return true; } From 75abdf132ec31d8c8614c6b27ec58a228fac0ec2 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Mon, 6 Apr 2020 17:56:44 +0100 Subject: [PATCH 024/143] Add non-passing year_month_day_test() --- .../test.cpp | 96 ++++++++++++++++++- 1 file changed, 95 insertions(+), 1 deletion(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 5f445082cc0..60e43753d49 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -403,6 +403,99 @@ constexpr void year_month_test() { assert((ym - years{2} == year_month{2018y, January})); } +constexpr void year_month_day_test() { + TRIVIAL_COPY_STANDARD_LAYOUT(year_month_day) + + year_month_day ymd1{year{2020}, month{1}, day{1}}; + assert(ymd1.year() == 2020y); + assert(ymd1.month() == January); + assert(ymd1.day() == 1d); + + year_month_day ymd2{2020y / January / last}; + assert(ymd2.year() == 2020y); + assert(ymd2.month() == January); + assert(ymd2.day() == 31d); + + year_month_day epoch{sys_days{}}; + assert(epoch.year() == 1970y); + assert(epoch.month() == January); + assert(epoch.day() == 1d); + + local_days ldp; + sys_days sys{ldp.time_since_epoch()}; + year_month_day ymld{ldp}; + assert((ymld == year_month_day{sys})); + + ymd1 += months{2}; + assert(ymd1.year() == 2020y); + assert(ymd1.month() == March); + assert(ymd1.day() == 1d); + + ymd1 -= months{2}; + assert(ymd1.year() == 2020y); + assert(ymd1.month() == January); + assert(ymd1.day() == 1d); + + ymd1 += years{2}; + assert(ymd1.year() == 2022y); + assert(ymd1.month() == January); + assert(ymd1.day() == 1d); + + ymd1 -= years{2}; + assert(ymd1.year() == 2020y); + assert(ymd1.month() == January); + assert(ymd1.day() == 1d); + + assert((year_month_day{2020y, April, 06d} == sys_days{days{18'358}})); + assert(year_month_day{sys_days{2017y / January / 0}} == 2016y / December / 31); + assert(year_month_day{sys_days{2017y / January / 31}} == 2017y / January / 31); + assert(year_month_day{sys_days{2017y / January / 32}} == 2017y / February / 1); + + assert(static_cast(ymld) == local_days{}); + + constexpr int y_min = static_cast(year::min()); + constexpr int y_max = static_cast(year::max()); + + // for (int iy = y_min; iy <= y_max; ++iy) { + // for (auto um = 0u; um <= 255u; ++um) { + // for (auto ud = 0u; ud <= 32u; ++ud) { + // year y{iy}; + // month m{um}; + // day d{ud}; + // if (y.ok() && m.ok() && d >= 1d && d <= (y / m / last).day()) { + // assert(((y / m / d).ok())); + // } else { + // assert((!(y / m / d).ok())); + // } + // } + // } + //} + + assert((year_month_day{2020y, January, 1d} == year_month_day{2020y, January, 1d})); + assert((year_month_day{2019y, January, 1d} < year_month_day{2020y, January, 1d})); + assert((year_month_day{2020y, January, 1d} < year_month_day{2020y, February, 1d})); + assert((year_month_day{2020y, January, 1d} < year_month_day{2020y, January, 2d})); + assert((year_month_day{2020y, January, 1d} > year_month_day{2019y, January, 1d})); + assert((year_month_day{2020y, February, 1d} > year_month_day{2020y, January, 1d})); + assert((year_month_day{2020y, January, 2d} > year_month_day{2020y, January, 1d})); + + const auto ymd3 = year_month_day{2019y, December, 31d} + months{2}; + assert((ymd3 == year_month_day{2020y, February, 31d})); + assert(!ymd3.ok()); + assert((months{2} + year_month_day{2019y, December, 31d} == ymd3)); + + const auto ymd4 = year_month_day{2020y, January, 1d} - months{2}; + assert((ymd4 == year_month_day{2019y, November, 1d})); + + const auto ymd5 = year_month_day{2020y, January, 1d} + years{2}; + assert((ymd5 == year_month_day{2022y, January, 1d})); + assert((years{2} + year_month_day{2020y, January, 1d} == ymd5)); + + const auto ymd8 = year_month_day{2020y, January, 1d} - years{2}; + assert((ymd8 == year_month_day{2018y, January, 1d})); +} + + constexpr bool test() { day_test(); month_test(); @@ -415,10 +508,11 @@ constexpr bool test() { month_weekday_test(); month_weekday_last_test(); year_month_test(); + year_month_day_test(); return true; } int main() { test(); - static_assert(test()); + // static_assert(test()); } From 6bcfe9827fef705b286b8928e41e99f66785e336 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Mon, 6 Apr 2020 17:58:40 +0100 Subject: [PATCH 025/143] Fix _Civil_from_days() --- stl/inc/chrono | 2 +- tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index e8d8a7ef4d8..485efcf08b8 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1458,7 +1458,7 @@ namespace chrono { const unsigned _Doy = _Doe - (365 * _Yoe + _Yoe / 4 - _Yoe / 100); const unsigned _Mp = (5 * _Doy + 2) / 153; const unsigned _D = _Doy - (153 * _Mp + 2) / 5 + 1; - const unsigned _M = _Mp + (_Mp < 10 ? 3 : -9); + const unsigned _M = _Mp + (_Mp < 10 ? 3 : static_cast(-9)); return year_month_day(chrono::year{_Y + (_M <= 2)}, chrono::month{_M}, chrono::day{_D}); } constexpr days year_month_day::_Days_from_civil() const noexcept { diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 60e43753d49..7c1ce7c93a6 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -514,5 +514,5 @@ constexpr bool test() { int main() { test(); - // static_assert(test()); + static_assert(test()); } From 3febc0b3a9c6c93c6e58c43cfd9fa235cd7c97b6 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Mon, 6 Apr 2020 18:53:10 +0100 Subject: [PATCH 026/143] Counting is hard. --- .../std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 7c1ce7c93a6..ca3a8f61365 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -491,8 +491,8 @@ constexpr void year_month_day_test() { assert((ymd5 == year_month_day{2022y, January, 1d})); assert((years{2} + year_month_day{2020y, January, 1d} == ymd5)); - const auto ymd8 = year_month_day{2020y, January, 1d} - years{2}; - assert((ymd8 == year_month_day{2018y, January, 1d})); + const auto ymd6 = year_month_day{2020y, January, 1d} - years{2}; + assert((ymd6 == year_month_day{2018y, January, 1d})); } From 32929fcf268c05f8328c768e0135dad73179694a Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Mon, 6 Apr 2020 19:41:04 +0100 Subject: [PATCH 027/143] Add year_month_day_last_test() --- .../test.cpp | 71 +++++++++++++++++++ 1 file changed, 71 insertions(+) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index ca3a8f61365..3308c81bd23 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -495,6 +495,76 @@ constexpr void year_month_day_test() { assert((ymd6 == year_month_day{2018y, January, 1d})); } +constexpr void year_month_day_last_test() { + TRIVIAL_COPY_STANDARD_LAYOUT(year_month_day_last) + + year_month_day_last ymdl{2020y, month_day_last{February}}; + assert(ymdl.year() == 2020y); + assert(ymdl.month() == February); + assert((ymdl.month_day_last() == month_day_last{February})); + assert(ymdl.day() == 29d); + + ymdl += months{2}; + assert(ymdl.year() == 2020y); + assert(ymdl.month() == April); + assert((ymdl.month_day_last() == month_day_last{April})); + assert(ymdl.day() == 30d); + + ymdl -= months{2}; + assert(ymdl.year() == 2020y); + assert(ymdl.month() == February); + assert((ymdl.month_day_last() == month_day_last{February})); + assert(ymdl.day() == 29d); + + ymdl += years{2}; + assert(ymdl.year() == 2022y); + assert(ymdl.month() == February); + assert((ymdl.month_day_last() == month_day_last{February})); + assert(ymdl.day() == 28d); + + ymdl -= years{2}; + assert(ymdl.year() == 2020y); + assert(ymdl.month() == February); + assert((ymdl.month_day_last() == month_day_last{February})); + assert(ymdl.day() == 29d); + + assert((year_month_day_last{2020y, month_day_last{April}} == sys_days{days{18'382}})); + assert(static_cast(ymdl) == local_days{ymdl}); + + constexpr int y_min = static_cast(year::min()); + constexpr int y_max = static_cast(year::max()); + for (int iy = y_min; iy <= y_max; ++iy) { + for (unsigned m = 0; m <= 255; ++m) { + year y{iy}; + month_day_last mdl{month{m}}; + if (y.ok() && mdl.ok()) { + assert((year_month_day_last{y, mdl}.ok())); + } else { + assert((!year_month_day_last{y, mdl}.ok())); + } + } + } + + assert((ymdl == year_month_day_last{2020y, February / last})); + assert((ymdl < year_month_day_last{2021y, February / last})); + assert((ymdl < year_month_day_last{2020y, March / last})); + assert((year_month_day_last{2021y, February / last} > ymdl)); + assert((year_month_day_last{2020y, March / last} > ymdl)); + + const auto ymdl2 = ymdl + months{2}; + assert((ymdl2 == year_month_day_last{2020y, April / last})); + assert((ymdl2 == months{2} + ymdl)); + + const auto ymdl3 = ymdl - months{2}; + assert((ymdl3 == year_month_day_last{2019y, December / last})); + + const auto ymdl4 = ymdl + years{2}; + assert((ymdl4 == year_month_day_last{2022y, February / last})); + assert((ymdl4 == years{2} + ymdl)); + + const auto ymdl5 = ymdl - years{2}; + assert((ymdl5 == year_month_day_last{2018y, February / last})); +} constexpr bool test() { day_test(); @@ -509,6 +579,7 @@ constexpr bool test() { month_weekday_last_test(); year_month_test(); year_month_day_test(); + year_month_day_last_test(); return true; } From 25572e9fb33cda4668b2eee972ff0d4b05b3a5ca Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Tue, 7 Apr 2020 14:29:42 +0100 Subject: [PATCH 028/143] Add year_month_weekday_test() --- .../test.cpp | 109 +++++++++++++++--- 1 file changed, 94 insertions(+), 15 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 3308c81bd23..97c7c0d25fd 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -453,8 +453,8 @@ constexpr void year_month_day_test() { assert(static_cast(ymld) == local_days{}); - constexpr int y_min = static_cast(year::min()); - constexpr int y_max = static_cast(year::max()); + constexpr int y_min = static_cast(year::min()); + constexpr int y_max = static_cast(year::max()); // for (int iy = y_min; iy <= y_max; ++iy) { // for (auto um = 0u; um <= 255u; ++um) { @@ -531,19 +531,19 @@ constexpr void year_month_day_last_test() { assert((year_month_day_last{2020y, month_day_last{April}} == sys_days{days{18'382}})); assert(static_cast(ymdl) == local_days{ymdl}); - constexpr int y_min = static_cast(year::min()); - constexpr int y_max = static_cast(year::max()); - for (int iy = y_min; iy <= y_max; ++iy) { - for (unsigned m = 0; m <= 255; ++m) { - year y{iy}; - month_day_last mdl{month{m}}; - if (y.ok() && mdl.ok()) { - assert((year_month_day_last{y, mdl}.ok())); - } else { - assert((!year_month_day_last{y, mdl}.ok())); - } - } - } + // constexpr int y_min = static_cast(year::min()); + // constexpr int y_max = static_cast(year::max()); + // for (int iy = y_min; iy <= y_max; ++iy) { + // for (unsigned m = 0; m <= 255; ++m) { + // year y{iy}; + // month_day_last mdl{month{m}}; + // if (y.ok() && mdl.ok()) { + // assert((year_month_day_last{y, mdl}.ok())); + // } else { + // assert((!year_month_day_last{y, mdl}.ok())); + // } + // } + //} assert((ymdl == year_month_day_last{2020y, February / last})); assert((ymdl < year_month_day_last{2021y, February / last})); @@ -566,6 +566,84 @@ constexpr void year_month_day_last_test() { assert((ymdl5 == year_month_day_last{2018y, February / last})); } +constexpr void year_month_weekday_test() { + TRIVIAL_COPY_STANDARD_LAYOUT(year_month_weekday) + + year_month_weekday ymwd{2020y, April, Tuesday[2]}; + assert(ymwd.year() == 2020y); + assert(ymwd.month() == April); + assert(ymwd.weekday() == Tuesday); + assert(ymwd.index() == 2u); + assert((ymwd.weekday_indexed() == weekday_indexed{Tuesday, 2})); + + const year_month_weekday epoch{sys_days{}}; + assert(epoch.year() == 1970y); + assert(epoch.month() == January); + assert(epoch.weekday() == Thursday); + assert(epoch.index() == 1u); + assert((epoch.weekday_indexed() == weekday_indexed{Thursday, 1})); + + local_days ldp; + sys_days sys{ldp.time_since_epoch()}; + year_month_weekday ymlwd{ldp}; + assert((ymlwd == year_month_weekday{sys})); + + ymwd += months{2}; + assert(ymwd.year() == 2020y); + assert(ymwd.month() == June); + assert(ymwd.weekday() == Tuesday); + assert(ymwd.index() == 2u); + assert((ymwd.weekday_indexed() == weekday_indexed{Tuesday, 2})); + + ymwd -= months{2}; + assert(ymwd.year() == 2020y); + assert(ymwd.month() == April); + assert(ymwd.weekday() == Tuesday); + assert(ymwd.index() == 2u); + assert((ymwd.weekday_indexed() == weekday_indexed{Tuesday, 2})); + + ymwd += years{2}; + assert(ymwd.year() == 2022y); + assert(ymwd.month() == April); + assert(ymwd.weekday() == Tuesday); + assert(ymwd.index() == 2u); + assert((ymwd.weekday_indexed() == weekday_indexed{Tuesday, 2})); + + ymwd -= years{2}; + assert(ymwd.year() == 2020y); + assert(ymwd.month() == April); + assert(ymwd.weekday() == Tuesday); + assert(ymwd.index() == 2u); + assert((ymwd.weekday_indexed() == weekday_indexed{Tuesday, 2})); + + assert(static_cast(epoch) == sys_days{}); + year_month_weekday prev{1970y / January / Thursday[0]}; + assert(static_cast(prev) == (sys_days{} - days{7})); + assert(static_cast(ymwd) == local_days{ymwd}); + + + assert((year_month_weekday{2020y / April / Wednesday[5]}.ok())); + assert((!year_month_weekday{2020y / April / Tuesday[5]}.ok())); + + assert((ymwd == year_month_weekday{2020y, April, Tuesday[2]})); + + const auto ymwd2 = ymwd + months{2}; + assert((ymwd2 == year_month_weekday{2020y, June, Tuesday[2]})); + const auto ymwd3 = months{2} + ymwd; + assert(ymwd2 == ymwd3); + + const auto ymwd4 = ymwd - months{2}; + assert((ymwd4 == year_month_weekday{2020y, February, Tuesday[2]})); + + const auto ymwd5 = ymwd + years{2}; + assert((ymwd5 == year_month_weekday{2022y, April, Tuesday[2]})); + const auto ymwd6 = years{2} + ymwd; + assert(ymwd5 == ymwd6); + + const auto ymwd7 = ymwd - years{2}; + assert((ymwd7 == year_month_weekday{2018y, April, Tuesday[2]})); +} + constexpr bool test() { day_test(); month_test(); @@ -580,6 +658,7 @@ constexpr bool test() { year_month_test(); year_month_day_test(); year_month_day_last_test(); + year_month_weekday_test(); return true; } From 32506d5c5dfee871be88efc12025938c44c9a3ae Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Tue, 7 Apr 2020 15:05:54 +0100 Subject: [PATCH 029/143] Fix _Days_from_civil() --- stl/inc/chrono | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 485efcf08b8..20e915b4683 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1468,7 +1468,7 @@ namespace chrono { const unsigned _M = static_cast(_Month); const int _Era = (_Y >= 0 ? _Y : _Y - 399) / 400; const unsigned _Yoe = static_cast(_Y - _Era * 400); - const unsigned _Doy = (153 * (_M + (_M > 2 ? -3 : 9)) + 2) / 5 + static_cast(_Day) - 1; + const unsigned _Doy = (153 * (_M + (_M > 2 ? static_cast(-3) : 9)) + 2) / 5 + static_cast(_Day) - 1; const unsigned _Doe = _Yoe * 365 + _Yoe / 4 - _Yoe / 100 + _Doy; return days{_Era * 146097 + static_cast(_Doe) - 719468}; } From 0a8275f85d19cb924ae54daca16beea22b419fa9 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Tue, 7 Apr 2020 15:06:59 +0100 Subject: [PATCH 030/143] Add year_month_weekday_last_test() --- .../test.cpp | 57 ++++++++++++++++++- 1 file changed, 55 insertions(+), 2 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 97c7c0d25fd..41550118f6d 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -626,12 +626,12 @@ constexpr void year_month_weekday_test() { assert((!year_month_weekday{2020y / April / Tuesday[5]}.ok())); assert((ymwd == year_month_weekday{2020y, April, Tuesday[2]})); - + const auto ymwd2 = ymwd + months{2}; assert((ymwd2 == year_month_weekday{2020y, June, Tuesday[2]})); const auto ymwd3 = months{2} + ymwd; assert(ymwd2 == ymwd3); - + const auto ymwd4 = ymwd - months{2}; assert((ymwd4 == year_month_weekday{2020y, February, Tuesday[2]})); @@ -644,6 +644,58 @@ constexpr void year_month_weekday_test() { assert((ymwd7 == year_month_weekday{2018y, April, Tuesday[2]})); } +constexpr void year_month_weekday_last_test() { + TRIVIAL_COPY_STANDARD_LAYOUT(year_month_weekday_last) + + year_month_weekday_last ymwdl{2020y, January, Monday[last]}; + assert(ymwdl.year() == 2020y); + assert(ymwdl.month() == January); + assert(ymwdl.weekday() == Monday); + assert(ymwdl.weekday_last() == Monday[last]); + + ymwdl += months{2}; + assert(ymwdl.year() == 2020y); + assert(ymwdl.month() == March); + assert(ymwdl.weekday() == Monday); + assert(ymwdl.weekday_last() == Monday[last]); + + ymwdl -= months{2}; + assert(ymwdl.year() == 2020y); + assert(ymwdl.month() == January); + assert(ymwdl.weekday() == Monday); + assert(ymwdl.weekday_last() == Monday[last]); + + ymwdl += years{2}; + assert(ymwdl.year() == 2022y); + assert(ymwdl.month() == January); + assert(ymwdl.weekday() == Monday); + assert(ymwdl.weekday_last() == Monday[last]); + + ymwdl -= years{2}; + assert(ymwdl.year() == 2020y); + assert(ymwdl.month() == January); + assert(ymwdl.weekday() == Monday); + assert(ymwdl.weekday_last() == Monday[last]); + + assert((static_cast(ymwdl) == sys_days{days{18'288}})); + assert((static_cast(ymwdl) == local_days{ymwdl})); + + const auto ymwdl2 = ymwdl + months{2}; + assert((ymwdl2 == 2020y / March / Monday[last])); + const auto ymwdl3 = months{2} + ymwdl; + assert(ymwdl3 == ymwdl2); + + const auto ymwdl4 = ymwdl - months{2}; + assert(ymwdl4 == 2019y / November / Monday[last]); + + const auto ymwdl5 = ymwdl + years{2}; + assert(ymwdl5 == 2022y / January / Monday[last]); + const auto ymwdl6 = years{2} + ymwdl; + assert(ymwdl6 == ymwdl5); + const auto ymwdl7 = ymwdl - years{2}; + assert(ymwdl7 == 2018y / January / Monday[last]); +} + constexpr bool test() { day_test(); month_test(); @@ -659,6 +711,7 @@ constexpr bool test() { year_month_day_test(); year_month_day_last_test(); year_month_weekday_test(); + year_month_weekday_last_test(); return true; } From c661393fc1e479913f9bdb42d75a56feac2acf46 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Tue, 7 Apr 2020 16:07:02 +0100 Subject: [PATCH 031/143] Add syntax_test() --- .../test.cpp | 70 +++++++++++++++++++ 1 file changed, 70 insertions(+) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 41550118f6d..520ec81d872 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -12,6 +12,9 @@ using namespace std::chrono; static_assert(is_trivially_copyable_v, "chrono::" #TYPE " is not trivially copyable"); \ static_assert(is_standard_layout_v, "chrono::" #TYPE " is not standard layout"); +#define SYNTAX_ASSERT(TYPE, EXPR) \ +static_assert(is_same_v, "\""#EXPR "\" is not chrono::"#TYPE); + constexpr void day_test() { TRIVIAL_COPY_STANDARD_LAYOUT(day) @@ -695,6 +698,72 @@ constexpr void year_month_weekday_last_test() { const auto ymwdl7 = ymwdl - years{2}; assert(ymwdl7 == 2018y / January / Monday[last]); } +constexpr void syntax_test() { + SYNTAX_ASSERT(year_month, 2020y / January) + SYNTAX_ASSERT(year_month, 2020y / 1) + + SYNTAX_ASSERT(month_day, January / 1d) + SYNTAX_ASSERT(month_day, January / 1) + SYNTAX_ASSERT(month_day, 1 / 1d) + SYNTAX_ASSERT(month_day, 1d / January) + SYNTAX_ASSERT(month_day, 1d / 1) + + SYNTAX_ASSERT(month_day_last, January / last) + SYNTAX_ASSERT(month_day_last, 1 / last) + SYNTAX_ASSERT(month_day_last, last / January) + SYNTAX_ASSERT(month_day_last, last / 1) + + SYNTAX_ASSERT(month_weekday, January / Monday[1]) + SYNTAX_ASSERT(month_weekday, 1 / Monday[1]) + SYNTAX_ASSERT(month_weekday, Monday[1] / January) + SYNTAX_ASSERT(month_weekday, Monday[1] / 1) + + SYNTAX_ASSERT(month_weekday_last, January / Monday[last]) + SYNTAX_ASSERT(month_weekday_last, 1 / Monday[last]) + SYNTAX_ASSERT(month_weekday_last, Monday[last] / 1) + SYNTAX_ASSERT(month_weekday_last, Monday[last] / January) + + SYNTAX_ASSERT(year_month_day, 2020y / January / 1d) + SYNTAX_ASSERT(year_month_day, 2020y / January / 1) + constexpr auto md = January / 1; + SYNTAX_ASSERT(year_month_day, 2020y / md) + SYNTAX_ASSERT(year_month_day, 2020 / md) + SYNTAX_ASSERT(year_month_day, January / 1 / 2020y) + SYNTAX_ASSERT(year_month_day, January / 1 / 2020) + SYNTAX_ASSERT(year_month_day, 1d / January / 2020y) + SYNTAX_ASSERT(year_month_day, 1d / January / 2020) + SYNTAX_ASSERT(year_month_day, 1d / 1 / 2020) + SYNTAX_ASSERT(year_month_day, 1d / 1 / 2020y) + + SYNTAX_ASSERT(year_month_day_last, 2020y / January / last) + constexpr auto mdl = January / last; + SYNTAX_ASSERT(year_month_day_last, 2020y / mdl) + SYNTAX_ASSERT(year_month_day_last, 2020 / mdl) + SYNTAX_ASSERT(year_month_day_last, last / January / 2020y) + SYNTAX_ASSERT(year_month_day_last, January / last / 2020) + + SYNTAX_ASSERT(year_month_weekday, 2020y / January / Monday[1]) + constexpr auto mwd = January / Monday[1]; + SYNTAX_ASSERT(year_month_weekday, 2020y / mwd) + SYNTAX_ASSERT(year_month_weekday, 2020 / mwd) + SYNTAX_ASSERT(year_month_weekday, January / Monday[1] / 2020y) + SYNTAX_ASSERT(year_month_weekday, January / Monday[1] / 2020) + SYNTAX_ASSERT(year_month_weekday, Monday[1] / January / 2020y) + SYNTAX_ASSERT(year_month_weekday, Monday[1] / January / 2020) + + SYNTAX_ASSERT(year_month_weekday_last, 2020y / January / Monday[last]) + constexpr auto mwdl = January / Monday[last]; + SYNTAX_ASSERT(year_month_weekday_last, 2020y / mwdl) + SYNTAX_ASSERT(year_month_weekday_last, 2020 / mwdl) + SYNTAX_ASSERT(year_month_weekday_last, January / Monday[last] / 2020y) + SYNTAX_ASSERT(year_month_weekday_last, January / Monday[last] / 2020) + SYNTAX_ASSERT(year_month_weekday_last, 1 / Monday[last] / 2020) + SYNTAX_ASSERT(year_month_weekday_last, 1 / Monday[last] / 2020y) + SYNTAX_ASSERT(year_month_weekday_last, Monday[last] / 1 / 2020y) + SYNTAX_ASSERT(year_month_weekday_last, Monday[last] / 1 / 2020) + SYNTAX_ASSERT(year_month_weekday_last, Monday[last] / January / 2020) + SYNTAX_ASSERT(year_month_weekday_last, Monday[last] / January / 2020y) +} constexpr bool test() { day_test(); @@ -712,6 +781,7 @@ constexpr bool test() { year_month_day_last_test(); year_month_weekday_test(); year_month_weekday_last_test(); + syntax_test(); return true; } From 129aaa0eddd092a2a41f9177c5cddaebac3fb84e Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Tue, 7 Apr 2020 16:18:44 +0100 Subject: [PATCH 032/143] Remove commented out #pragma --- stl/inc/chrono | 1 - 1 file changed, 1 deletion(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 20e915b4683..de7f0b8d420 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -21,7 +21,6 @@ #pragma pack(push, _CRT_PACKING) #pragma warning(push, _STL_WARNING_LEVEL) #pragma warning(disable : _STL_DISABLED_WARNINGS) -// #pragma warning(disable : 4308) // needed for constexpr date arithmetic _STL_DISABLE_CLANG_WARNINGS #pragma push_macro("new") #undef new From ce491f1ef27486f47baa92fbd9e1465525a6da11 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Wed, 8 Apr 2020 14:35:06 +0100 Subject: [PATCH 033/143] _NODISCARD --- stl/inc/chrono | 205 +++++++++++++++++++++++++------------------------ 1 file changed, 103 insertions(+), 102 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index de7f0b8d420..9c57be5e07c 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -683,8 +683,8 @@ namespace chrono { constexpr day& operator+=(const days& _Days) noexcept; constexpr day& operator-=(const days& _Days) noexcept; - constexpr explicit operator unsigned() const noexcept; - constexpr bool ok() const noexcept; + _NODISCARD constexpr explicit operator unsigned() const noexcept; + _NODISCARD constexpr bool ok() const noexcept; }; class month { @@ -702,8 +702,8 @@ namespace chrono { constexpr month& operator+=(const months& _Months) noexcept; constexpr month& operator-=(const months& _Months) noexcept; - constexpr explicit operator unsigned() const noexcept; - constexpr bool ok() const noexcept; + _NODISCARD constexpr explicit operator unsigned() const noexcept; + _NODISCARD constexpr bool ok() const noexcept; }; class year { @@ -724,14 +724,14 @@ namespace chrono { constexpr year operator+() const noexcept; constexpr year operator-() const noexcept; - constexpr bool is_leap() const noexcept; + _NODISCARD constexpr bool is_leap() const noexcept; - constexpr explicit operator int() const noexcept; + _NODISCARD constexpr explicit operator int() const noexcept; - constexpr bool ok() const noexcept; + _NODISCARD constexpr bool ok() const noexcept; - static constexpr year(min)() noexcept; - static constexpr year(max)() noexcept; + _NODISCARD static constexpr year(min)() noexcept; + _NODISCARD static constexpr year(max)() noexcept; }; class weekday { @@ -754,12 +754,12 @@ namespace chrono { constexpr weekday& operator+=(const days& _Days) noexcept; constexpr weekday& operator-=(const days& _Days) noexcept; - constexpr unsigned c_encoding() const noexcept; - constexpr unsigned iso_encoding() const noexcept; - constexpr bool ok() const noexcept; + _NODISCARD constexpr unsigned c_encoding() const noexcept; + _NODISCARD constexpr unsigned iso_encoding() const noexcept; + _NODISCARD constexpr bool ok() const noexcept; - constexpr class weekday_indexed operator[](unsigned _Index) const noexcept; - constexpr class weekday_last operator[](last_spec) const noexcept; + _NODISCARD constexpr class weekday_indexed operator[](unsigned _Index) const noexcept; + _NODISCARD constexpr class weekday_last operator[](last_spec) const noexcept; }; class weekday_indexed { @@ -770,9 +770,9 @@ namespace chrono { weekday_indexed() = default; constexpr weekday_indexed(const chrono::weekday& _Wd, unsigned _Idx) noexcept; - constexpr chrono::weekday weekday() const noexcept; - constexpr unsigned index() const noexcept; - constexpr bool ok() const noexcept; + _NODISCARD constexpr chrono::weekday weekday() const noexcept; + _NODISCARD constexpr unsigned index() const noexcept; + _NODISCARD constexpr bool ok() const noexcept; }; class weekday_last { @@ -781,8 +781,8 @@ namespace chrono { public: constexpr explicit weekday_last(const chrono::weekday& _Wd) noexcept; - constexpr chrono::weekday weekday() const noexcept; - constexpr bool ok() const noexcept; + _NODISCARD constexpr chrono::weekday weekday() const noexcept; + _NODISCARD constexpr bool ok() const noexcept; }; class month_day { @@ -793,9 +793,9 @@ namespace chrono { month_day() = default; constexpr month_day(const chrono::month& _M, const chrono::day& _D) noexcept; - constexpr chrono::month month() const noexcept; - constexpr chrono::day day() const noexcept; - constexpr bool ok() const noexcept; + _NODISCARD constexpr chrono::month month() const noexcept; + _NODISCARD constexpr chrono::day day() const noexcept; + _NODISCARD constexpr bool ok() const noexcept; }; class month_day_last { @@ -804,8 +804,8 @@ namespace chrono { public: constexpr explicit month_day_last(const chrono::month& _M) noexcept; - constexpr chrono::month month() const noexcept; - constexpr bool ok() const noexcept; + _NODISCARD constexpr chrono::month month() const noexcept; + _NODISCARD constexpr bool ok() const noexcept; }; class month_weekday { @@ -815,10 +815,10 @@ namespace chrono { public: constexpr month_weekday(const chrono::month& _M, const chrono::weekday_indexed& _Wdi) noexcept; - constexpr chrono::month month() const noexcept; - constexpr chrono::weekday_indexed weekday_indexed() const noexcept; + _NODISCARD constexpr chrono::month month() const noexcept; + _NODISCARD constexpr chrono::weekday_indexed weekday_indexed() const noexcept; - constexpr bool ok() const noexcept; + _NODISCARD constexpr bool ok() const noexcept; }; class month_weekday_last { @@ -828,9 +828,9 @@ namespace chrono { public: constexpr month_weekday_last(const chrono::month& _M, const chrono::weekday_last& _Wdl) noexcept; - constexpr chrono::month month() const noexcept; - constexpr chrono::weekday_last weekday_last() const noexcept; - constexpr bool ok() const noexcept; + _NODISCARD constexpr chrono::month month() const noexcept; + _NODISCARD constexpr chrono::weekday_last weekday_last() const noexcept; + _NODISCARD constexpr bool ok() const noexcept; }; class year_month { @@ -841,15 +841,15 @@ namespace chrono { year_month() = default; constexpr year_month(const chrono::year& _Y, const chrono::month& _M) noexcept; - constexpr chrono::year year() const noexcept; - constexpr chrono::month month() const noexcept; + _NODISCARD constexpr chrono::year year() const noexcept; + _NODISCARD constexpr chrono::month month() const noexcept; constexpr year_month& operator+=(const months& _Months) noexcept; constexpr year_month& operator-=(const months& _Months) noexcept; constexpr year_month& operator+=(const years& _Years) noexcept; constexpr year_month& operator-=(const years& _Years) noexcept; - constexpr bool ok() const noexcept; + _NODISCARD constexpr bool ok() const noexcept; }; class year_month_day { @@ -871,13 +871,13 @@ namespace chrono { constexpr year_month_day& operator+=(const years& _Years) noexcept; constexpr year_month_day& operator-=(const years& _Years) noexcept; - constexpr chrono::year year() const noexcept; - constexpr chrono::month month() const noexcept; - constexpr chrono::day day() const noexcept; + _NODISCARD constexpr chrono::year year() const noexcept; + _NODISCARD constexpr chrono::month month() const noexcept; + _NODISCARD constexpr chrono::day day() const noexcept; - constexpr operator sys_days() const noexcept; - constexpr explicit operator local_days() const noexcept; - constexpr bool ok() const noexcept; + _NODISCARD constexpr operator sys_days() const noexcept; + _NODISCARD constexpr explicit operator local_days() const noexcept; + _NODISCARD constexpr bool ok() const noexcept; }; class year_month_day_last { @@ -892,14 +892,14 @@ namespace chrono { constexpr year_month_day_last& operator+=(const years& _Years) noexcept; constexpr year_month_day_last& operator-=(const years& _Years) noexcept; - constexpr chrono::year year() const noexcept; - constexpr chrono::month month() const noexcept; - constexpr chrono::month_day_last month_day_last() const noexcept; - constexpr chrono::day day() const noexcept; + _NODISCARD constexpr chrono::year year() const noexcept; + _NODISCARD constexpr chrono::month month() const noexcept; + _NODISCARD constexpr chrono::month_day_last month_day_last() const noexcept; + _NODISCARD constexpr chrono::day day() const noexcept; - constexpr operator sys_days() const noexcept; - constexpr explicit operator local_days() const noexcept; - constexpr bool ok() const noexcept; + _NODISCARD constexpr operator sys_days() const noexcept; + _NODISCARD constexpr explicit operator local_days() const noexcept; + _NODISCARD constexpr bool ok() const noexcept; }; class year_month_weekday { @@ -920,15 +920,15 @@ namespace chrono { constexpr year_month_weekday& operator+=(const years& _Years) noexcept; constexpr year_month_weekday& operator-=(const years& _Years) noexcept; - constexpr chrono::year year() const noexcept; - constexpr chrono::month month() const noexcept; - constexpr chrono::weekday weekday() const noexcept; - constexpr unsigned index() const noexcept; - constexpr chrono::weekday_indexed weekday_indexed() const noexcept; + _NODISCARD constexpr chrono::year year() const noexcept; + _NODISCARD constexpr chrono::month month() const noexcept; + _NODISCARD constexpr chrono::weekday weekday() const noexcept; + _NODISCARD constexpr unsigned index() const noexcept; + _NODISCARD constexpr chrono::weekday_indexed weekday_indexed() const noexcept; - constexpr operator sys_days() const noexcept; - constexpr explicit operator local_days() const noexcept; - constexpr bool ok() const noexcept; + _NODISCARD constexpr operator sys_days() const noexcept; + _NODISCARD constexpr explicit operator local_days() const noexcept; + _NODISCARD constexpr bool ok() const noexcept; }; class year_month_weekday_last { @@ -945,56 +945,56 @@ namespace chrono { constexpr year_month_weekday_last& operator+=(const years& _Years) noexcept; constexpr year_month_weekday_last& operator-=(const years& _Years) noexcept; - constexpr chrono::year year() const noexcept; - constexpr chrono::month month() const noexcept; - constexpr chrono::weekday weekday() const noexcept; - constexpr chrono::weekday_last weekday_last() const noexcept; + _NODISCARD constexpr chrono::year year() const noexcept; + _NODISCARD constexpr chrono::month month() const noexcept; + _NODISCARD constexpr chrono::weekday weekday() const noexcept; + _NODISCARD constexpr chrono::weekday_last weekday_last() const noexcept; - constexpr operator sys_days() const noexcept; - constexpr explicit operator local_days() const noexcept; - constexpr bool ok() const noexcept; + _NODISCARD constexpr operator sys_days() const noexcept; + _NODISCARD constexpr explicit operator local_days() const noexcept; + _NODISCARD constexpr bool ok() const noexcept; }; - constexpr year_month operator/(const year& _Year, const month& _Month) noexcept; - constexpr year_month operator/(const year& _Year, int _Month) noexcept; - constexpr month_day operator/(const month& _Month, const day& _Day) noexcept; - constexpr month_day operator/(const month& _Month, int _Day) noexcept; - constexpr month_day operator/(int _Month, const day& _Day) noexcept; - constexpr month_day operator/(const day& _Day, const month& _Month) noexcept; - constexpr month_day operator/(const day& _Day, int _Month) noexcept; - constexpr month_day_last operator/(const month& _Month, last_spec) noexcept; - constexpr month_day_last operator/(int _Month, last_spec) noexcept; - constexpr month_day_last operator/(last_spec, const month& _Month) noexcept; - constexpr month_day_last operator/(last_spec, int _Month) noexcept; - constexpr month_weekday operator/(const month& _Month, const weekday_indexed& _Wdi) noexcept; - constexpr month_weekday operator/(int _Month, const weekday_indexed& _Wdi) noexcept; - constexpr month_weekday operator/(const weekday_indexed& _Wdi, const month& _Month) noexcept; - constexpr month_weekday operator/(const weekday_indexed& _Wdi, int _Month) noexcept; - constexpr month_weekday_last operator/(const month& _Month, const weekday_last& _Wdl) noexcept; - constexpr month_weekday_last operator/(int _Month, const weekday_last& _Wdl) noexcept; - constexpr month_weekday_last operator/(const weekday_last& _Wdl, const month& _Month) noexcept; - constexpr month_weekday_last operator/(const weekday_last& _Wdl, int _Month) noexcept; - constexpr year_month_day operator/(const year_month& _Ym, const day& _Day) noexcept; - constexpr year_month_day operator/(const year_month& _Ym, int _Day) noexcept; - constexpr year_month_day operator/(const year& _Year, const month_day& _Md) noexcept; - constexpr year_month_day operator/(int _Year, const month_day& _Md) noexcept; - constexpr year_month_day operator/(const month_day& _Md, const year& _Year) noexcept; - constexpr year_month_day operator/(const month_day& _Md, int _Year) noexcept; - constexpr year_month_day_last operator/(const year_month& _Ym, last_spec) noexcept; - constexpr year_month_day_last operator/(const year& _Year, const month_day_last& _Mdl) noexcept; - constexpr year_month_day_last operator/(int _Year, const month_day_last& _Mdl) noexcept; - constexpr year_month_day_last operator/(const month_day_last& _Mdl, const year& _Year) noexcept; - constexpr year_month_day_last operator/(const month_day_last& _Mdl, int _Year) noexcept; - constexpr year_month_weekday operator/(const year_month& _Ym, const weekday_indexed& _Wdi) noexcept; - constexpr year_month_weekday operator/(const year& _Year, const month_weekday& _Mwd) noexcept; - constexpr year_month_weekday operator/(int _Year, const month_weekday& _Mwd) noexcept; - constexpr year_month_weekday operator/(const month_weekday& _Mwd, const year& _Year) noexcept; - constexpr year_month_weekday operator/(const month_weekday& _Mwd, int _Year) noexcept; - constexpr year_month_weekday_last operator/(const year_month& ym, const weekday_last& _Wdl) noexcept; - constexpr year_month_weekday_last operator/(const year& _Year, const month_weekday_last& mwdl) noexcept; - constexpr year_month_weekday_last operator/(int _Year, const month_weekday_last& mwdl) noexcept; - constexpr year_month_weekday_last operator/(const month_weekday_last& mwdl, const year& _Year) noexcept; - constexpr year_month_weekday_last operator/(const month_weekday_last& mwdl, int _Year) noexcept; + _NODISCARD constexpr year_month operator/(const year& _Year, const month& _Month) noexcept; + _NODISCARD constexpr year_month operator/(const year& _Year, int _Month) noexcept; + _NODISCARD constexpr month_day operator/(const month& _Month, const day& _Day) noexcept; + _NODISCARD constexpr month_day operator/(const month& _Month, int _Day) noexcept; + _NODISCARD constexpr month_day operator/(int _Month, const day& _Day) noexcept; + _NODISCARD constexpr month_day operator/(const day& _Day, const month& _Month) noexcept; + _NODISCARD constexpr month_day operator/(const day& _Day, int _Month) noexcept; + _NODISCARD constexpr month_day_last operator/(const month& _Month, last_spec) noexcept; + _NODISCARD constexpr month_day_last operator/(int _Month, last_spec) noexcept; + _NODISCARD constexpr month_day_last operator/(last_spec, const month& _Month) noexcept; + _NODISCARD constexpr month_day_last operator/(last_spec, int _Month) noexcept; + _NODISCARD constexpr month_weekday operator/(const month& _Month, const weekday_indexed& _Wdi) noexcept; + _NODISCARD constexpr month_weekday operator/(int _Month, const weekday_indexed& _Wdi) noexcept; + _NODISCARD constexpr month_weekday operator/(const weekday_indexed& _Wdi, const month& _Month) noexcept; + _NODISCARD constexpr month_weekday operator/(const weekday_indexed& _Wdi, int _Month) noexcept; + _NODISCARD constexpr month_weekday_last operator/(const month& _Month, const weekday_last& _Wdl) noexcept; + _NODISCARD constexpr month_weekday_last operator/(int _Month, const weekday_last& _Wdl) noexcept; + _NODISCARD constexpr month_weekday_last operator/(const weekday_last& _Wdl, const month& _Month) noexcept; + _NODISCARD constexpr month_weekday_last operator/(const weekday_last& _Wdl, int _Month) noexcept; + _NODISCARD constexpr year_month_day operator/(const year_month& _Ym, const day& _Day) noexcept; + _NODISCARD constexpr year_month_day operator/(const year_month& _Ym, int _Day) noexcept; + _NODISCARD constexpr year_month_day operator/(const year& _Year, const month_day& _Md) noexcept; + _NODISCARD constexpr year_month_day operator/(int _Year, const month_day& _Md) noexcept; + _NODISCARD constexpr year_month_day operator/(const month_day& _Md, const year& _Year) noexcept; + _NODISCARD constexpr year_month_day operator/(const month_day& _Md, int _Year) noexcept; + _NODISCARD constexpr year_month_day_last operator/(const year_month& _Ym, last_spec) noexcept; + _NODISCARD constexpr year_month_day_last operator/(const year& _Year, const month_day_last& _Mdl) noexcept; + _NODISCARD constexpr year_month_day_last operator/(int _Year, const month_day_last& _Mdl) noexcept; + _NODISCARD constexpr year_month_day_last operator/(const month_day_last& _Mdl, const year& _Year) noexcept; + _NODISCARD constexpr year_month_day_last operator/(const month_day_last& _Mdl, int _Year) noexcept; + _NODISCARD constexpr year_month_weekday operator/(const year_month& _Ym, const weekday_indexed& _Wdi) noexcept; + _NODISCARD constexpr year_month_weekday operator/(const year& _Year, const month_weekday& _Mwd) noexcept; + _NODISCARD constexpr year_month_weekday operator/(int _Year, const month_weekday& _Mwd) noexcept; + _NODISCARD constexpr year_month_weekday operator/(const month_weekday& _Mwd, const year& _Year) noexcept; + _NODISCARD constexpr year_month_weekday operator/(const month_weekday& _Mwd, int _Year) noexcept; + _NODISCARD constexpr year_month_weekday_last operator/(const year_month& ym, const weekday_last& _Wdl) noexcept; + _NODISCARD constexpr year_month_weekday_last operator/(const year& _Year, const month_weekday_last& mwdl) noexcept; + _NODISCARD constexpr year_month_weekday_last operator/(int _Year, const month_weekday_last& mwdl) noexcept; + _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& mwdl, const year& _Year) noexcept; + _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& mwdl, int _Year) noexcept; // day constexpr day::day(unsigned _Val) noexcept : _Day{static_cast(_Val)} {} @@ -1467,7 +1467,8 @@ namespace chrono { const unsigned _M = static_cast(_Month); const int _Era = (_Y >= 0 ? _Y : _Y - 399) / 400; const unsigned _Yoe = static_cast(_Y - _Era * 400); - const unsigned _Doy = (153 * (_M + (_M > 2 ? static_cast(-3) : 9)) + 2) / 5 + static_cast(_Day) - 1; + const unsigned _Doy = + (153 * (_M + (_M > 2 ? static_cast(-3) : 9)) + 2) / 5 + static_cast(_Day) - 1; const unsigned _Doe = _Yoe * 365 + _Yoe / 4 - _Yoe / 100 + _Doy; return days{_Era * 146097 + static_cast(_Doe) - 719468}; } From 69da9ab8c901b3b4e3a0f4aeade1cfdc80db97e9 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Wed, 8 Apr 2020 14:40:04 +0100 Subject: [PATCH 034/143] _NODISCARD privates and remove unneeded friends --- stl/inc/chrono | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 9c57be5e07c..7ac4687184b 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -736,9 +736,7 @@ namespace chrono { class weekday { unsigned char _Weekday; - static constexpr unsigned _Weekday_from_days(int _Tp) noexcept; - friend constexpr bool operator==(const weekday& _Left, const weekday& _Right) noexcept; - friend constexpr weekday operator+(const weekday& _Left, const days& _Right) noexcept; + _NODISCARD static constexpr unsigned _Weekday_from_days(int _Tp) noexcept; public: weekday() = default; @@ -856,8 +854,8 @@ namespace chrono { chrono::year _Year; chrono::month _Month; chrono::day _Day; - static constexpr year_month_day _Civil_from_days(int _Tp) noexcept; - constexpr days _Days_from_civil() const noexcept; + _NODISCARD static constexpr year_month_day _Civil_from_days(int _Tp) noexcept; + _NODISCARD constexpr days _Days_from_civil() const noexcept; public: year_month_day() = default; @@ -906,7 +904,7 @@ namespace chrono { chrono::year _Year; chrono::month _Month; chrono::weekday_indexed _Weekday_index; - static constexpr year_month_weekday _Ymwd_from_days(days _Dp) noexcept; + _NODISCARD static constexpr year_month_weekday _Ymwd_from_days(days _Dp) noexcept; public: year_month_weekday() = default; @@ -1213,11 +1211,11 @@ namespace chrono { } constexpr bool operator==(const weekday& _Left, const weekday& _Right) noexcept { - return _Left._Weekday == _Right._Weekday; + return _Left.c_encoding() == _Right.c_encoding(); } constexpr weekday operator+(const weekday& _Left, const days& _Right) noexcept { - const auto _Wd = static_cast(_Left._Weekday) + _Right.count(); + const auto _Wd = static_cast(_Left.c_encoding()) + _Right.count(); const auto _Div = (_Wd >= 0 ? _Wd : _Wd - 6) / 7; return weekday{static_cast(_Wd - _Div * 7)}; } From 421eb2d8c34134fc6232d06e7e7c930069bb31af Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Wed, 8 Apr 2020 17:51:37 +0100 Subject: [PATCH 035/143] Split test --- tests/std/test.lst | 1 + .../test.cpp | 152 ------------------ .../env.lst | 4 + .../test.cpp | 145 +++++++++++++++++ 4 files changed, 150 insertions(+), 152 deletions(-) create mode 100644 tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/env.lst create mode 100644 tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.cpp diff --git a/tests/std/test.lst b/tests/std/test.lst index 220bc04d1be..31465751970 100644 --- a/tests/std/test.lst +++ b/tests/std/test.lst @@ -206,6 +206,7 @@ tests\P0220R1_searchers tests\P0220R1_string_view tests\P0325R4_to_array tests\P0355R7_calendars_and_time_zones_dates +tests\P0355R7_calendars_and_time_zones_dates_literals tests\P0355R7_calendars_and_time_zones_time_point_arithmetic tests\P0356R5_bind_front tests\P0357R3_supporting_incomplete_types_in_reference_wrapper diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 520ec81d872..2d269a0a1c0 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -8,16 +8,7 @@ using namespace std; using namespace std::chrono; -#define TRIVIAL_COPY_STANDARD_LAYOUT(TYPE) \ - static_assert(is_trivially_copyable_v, "chrono::" #TYPE " is not trivially copyable"); \ - static_assert(is_standard_layout_v, "chrono::" #TYPE " is not standard layout"); - -#define SYNTAX_ASSERT(TYPE, EXPR) \ -static_assert(is_same_v, "\""#EXPR "\" is not chrono::"#TYPE); - constexpr void day_test() { - TRIVIAL_COPY_STANDARD_LAYOUT(day) - day d1{0u}; assert(static_cast(d1) == 0); assert(++d1 == day{1}); @@ -53,12 +44,9 @@ constexpr void day_test() { const auto d6 = 0d; assert(d1 == d6); - static_assert(is_same_v, "0d is not chrono::day"); - static_assert(is_same_v, "d6 is not chrono::day"); } constexpr void month_test() { - TRIVIAL_COPY_STANDARD_LAYOUT(month) month m1{1u}; assert(static_cast(m1) == 1); @@ -97,36 +85,9 @@ constexpr void month_test() { months diff = m1 - m2; assert(diff == months{11}); - - static_assert(is_same_v); - static_assert(is_same_v); - static_assert(is_same_v); - static_assert(is_same_v); - static_assert(is_same_v); - static_assert(is_same_v); - static_assert(is_same_v); - static_assert(is_same_v); - static_assert(is_same_v); - static_assert(is_same_v); - static_assert(is_same_v); - static_assert(is_same_v); - assert(month{1} == January); - assert(month{2} == February); - assert(month{3} == March); - assert(month{4} == April); - assert(month{5} == May); - assert(month{6} == June); - assert(month{7} == July); - assert(month{8} == August); - assert(month{9} == September); - assert(month{10} == October); - assert(month{11} == November); - assert(month{12} == December); } constexpr void year_test() { - TRIVIAL_COPY_STANDARD_LAYOUT(year) - year y1{1}; assert(static_cast(y1) == 1); assert(++y1 == year{2}); @@ -170,15 +131,9 @@ constexpr void year_test() { year y3 = y2 - years{4}; assert(y3 == year{1}); - - const auto y4 = 2020y; - static_assert(is_same_v, "0y is not chrono::year"); - static_assert(is_same_v, "y4 is not chrono::year"); } constexpr void weekday_test() { - TRIVIAL_COPY_STANDARD_LAYOUT(weekday) - assert(weekday{7} == weekday{0}); assert(weekday{sys_days{}} == weekday{4}); assert(weekday{local_days{}} == sys_days{local_days{}.time_since_epoch()}); @@ -208,31 +163,11 @@ constexpr void weekday_test() { assert(!weekday{i}.ok()); } } - static_assert(is_same_v); - static_assert(is_same_v); - assert(weekday{1} + days{6} == weekday{0}); assert(weekday{0} - weekday{1} == days{6}); - - static_assert(is_same_v); - static_assert(is_same_v); - static_assert(is_same_v); - static_assert(is_same_v); - static_assert(is_same_v); - static_assert(is_same_v); - static_assert(is_same_v); - assert(weekday{0} == Sunday); - assert(weekday{1} == Monday); - assert(weekday{2} == Tuesday); - assert(weekday{3} == Wednesday); - assert(weekday{4} == Thursday); - assert(weekday{5} == Friday); - assert(weekday{6} == Saturday); } constexpr void weekday_indexed_test() { - TRIVIAL_COPY_STANDARD_LAYOUT(weekday_indexed) - weekday_indexed wdi1{Monday, 2}; assert(wdi1.weekday() == Monday); assert(wdi1.index() == 2); @@ -257,8 +192,6 @@ constexpr void weekday_indexed_test() { } constexpr void weekday_last_test() { - TRIVIAL_COPY_STANDARD_LAYOUT(weekday_last) - assert(weekday_last{Monday}.ok()); assert(Monday[last].ok()); assert(Monday[last].weekday() == Monday); @@ -267,8 +200,6 @@ constexpr void weekday_last_test() { } constexpr void month_day_test() { - TRIVIAL_COPY_STANDARD_LAYOUT(month_day) - month_day md{January, 1d}; assert(md.month() == January); assert(md.day() == 1d); @@ -299,8 +230,6 @@ constexpr void month_day_test() { } constexpr void month_day_last_test() { - TRIVIAL_COPY_STANDARD_LAYOUT(month_day_last) - assert(month_day_last{February}.month() == February); const auto mdl = January / last; static_assert(is_same_v, "mdl is not const chrono::month_day_last"); @@ -318,8 +247,6 @@ constexpr void month_day_last_test() { } constexpr void month_weekday_test() { - TRIVIAL_COPY_STANDARD_LAYOUT(month_weekday) - const month_weekday mwd1{January, Monday[2]}; assert(mwd1.month() == January); assert(mwd1.weekday_indexed().weekday() == Monday); @@ -344,8 +271,6 @@ constexpr void month_weekday_test() { } constexpr void month_weekday_last_test() { - TRIVIAL_COPY_STANDARD_LAYOUT(month_weekday_last) - month_weekday_last mwdl{January, Monday[last]}; assert(mwdl.month() == January); assert(mwdl.weekday_last().weekday() == Monday); @@ -353,8 +278,6 @@ constexpr void month_weekday_last_test() { } constexpr void year_month_test() { - TRIVIAL_COPY_STANDARD_LAYOUT(year_month) - year_month ym{2020y, January}; assert(ym.year() == 2020y); assert(ym.month() == January); @@ -407,8 +330,6 @@ constexpr void year_month_test() { } constexpr void year_month_day_test() { - TRIVIAL_COPY_STANDARD_LAYOUT(year_month_day) - year_month_day ymd1{year{2020}, month{1}, day{1}}; assert(ymd1.year() == 2020y); assert(ymd1.month() == January); @@ -499,8 +420,6 @@ constexpr void year_month_day_test() { } constexpr void year_month_day_last_test() { - TRIVIAL_COPY_STANDARD_LAYOUT(year_month_day_last) - year_month_day_last ymdl{2020y, month_day_last{February}}; assert(ymdl.year() == 2020y); assert(ymdl.month() == February); @@ -570,8 +489,6 @@ constexpr void year_month_day_last_test() { } constexpr void year_month_weekday_test() { - TRIVIAL_COPY_STANDARD_LAYOUT(year_month_weekday) - year_month_weekday ymwd{2020y, April, Tuesday[2]}; assert(ymwd.year() == 2020y); assert(ymwd.month() == April); @@ -648,8 +565,6 @@ constexpr void year_month_weekday_test() { } constexpr void year_month_weekday_last_test() { - TRIVIAL_COPY_STANDARD_LAYOUT(year_month_weekday_last) - year_month_weekday_last ymwdl{2020y, January, Monday[last]}; assert(ymwdl.year() == 2020y); assert(ymwdl.month() == January); @@ -698,72 +613,6 @@ constexpr void year_month_weekday_last_test() { const auto ymwdl7 = ymwdl - years{2}; assert(ymwdl7 == 2018y / January / Monday[last]); } -constexpr void syntax_test() { - SYNTAX_ASSERT(year_month, 2020y / January) - SYNTAX_ASSERT(year_month, 2020y / 1) - - SYNTAX_ASSERT(month_day, January / 1d) - SYNTAX_ASSERT(month_day, January / 1) - SYNTAX_ASSERT(month_day, 1 / 1d) - SYNTAX_ASSERT(month_day, 1d / January) - SYNTAX_ASSERT(month_day, 1d / 1) - - SYNTAX_ASSERT(month_day_last, January / last) - SYNTAX_ASSERT(month_day_last, 1 / last) - SYNTAX_ASSERT(month_day_last, last / January) - SYNTAX_ASSERT(month_day_last, last / 1) - - SYNTAX_ASSERT(month_weekday, January / Monday[1]) - SYNTAX_ASSERT(month_weekday, 1 / Monday[1]) - SYNTAX_ASSERT(month_weekday, Monday[1] / January) - SYNTAX_ASSERT(month_weekday, Monday[1] / 1) - - SYNTAX_ASSERT(month_weekday_last, January / Monday[last]) - SYNTAX_ASSERT(month_weekday_last, 1 / Monday[last]) - SYNTAX_ASSERT(month_weekday_last, Monday[last] / 1) - SYNTAX_ASSERT(month_weekday_last, Monday[last] / January) - - SYNTAX_ASSERT(year_month_day, 2020y / January / 1d) - SYNTAX_ASSERT(year_month_day, 2020y / January / 1) - constexpr auto md = January / 1; - SYNTAX_ASSERT(year_month_day, 2020y / md) - SYNTAX_ASSERT(year_month_day, 2020 / md) - SYNTAX_ASSERT(year_month_day, January / 1 / 2020y) - SYNTAX_ASSERT(year_month_day, January / 1 / 2020) - SYNTAX_ASSERT(year_month_day, 1d / January / 2020y) - SYNTAX_ASSERT(year_month_day, 1d / January / 2020) - SYNTAX_ASSERT(year_month_day, 1d / 1 / 2020) - SYNTAX_ASSERT(year_month_day, 1d / 1 / 2020y) - - SYNTAX_ASSERT(year_month_day_last, 2020y / January / last) - constexpr auto mdl = January / last; - SYNTAX_ASSERT(year_month_day_last, 2020y / mdl) - SYNTAX_ASSERT(year_month_day_last, 2020 / mdl) - SYNTAX_ASSERT(year_month_day_last, last / January / 2020y) - SYNTAX_ASSERT(year_month_day_last, January / last / 2020) - - SYNTAX_ASSERT(year_month_weekday, 2020y / January / Monday[1]) - constexpr auto mwd = January / Monday[1]; - SYNTAX_ASSERT(year_month_weekday, 2020y / mwd) - SYNTAX_ASSERT(year_month_weekday, 2020 / mwd) - SYNTAX_ASSERT(year_month_weekday, January / Monday[1] / 2020y) - SYNTAX_ASSERT(year_month_weekday, January / Monday[1] / 2020) - SYNTAX_ASSERT(year_month_weekday, Monday[1] / January / 2020y) - SYNTAX_ASSERT(year_month_weekday, Monday[1] / January / 2020) - - SYNTAX_ASSERT(year_month_weekday_last, 2020y / January / Monday[last]) - constexpr auto mwdl = January / Monday[last]; - SYNTAX_ASSERT(year_month_weekday_last, 2020y / mwdl) - SYNTAX_ASSERT(year_month_weekday_last, 2020 / mwdl) - SYNTAX_ASSERT(year_month_weekday_last, January / Monday[last] / 2020y) - SYNTAX_ASSERT(year_month_weekday_last, January / Monday[last] / 2020) - SYNTAX_ASSERT(year_month_weekday_last, 1 / Monday[last] / 2020) - SYNTAX_ASSERT(year_month_weekday_last, 1 / Monday[last] / 2020y) - SYNTAX_ASSERT(year_month_weekday_last, Monday[last] / 1 / 2020y) - SYNTAX_ASSERT(year_month_weekday_last, Monday[last] / 1 / 2020) - SYNTAX_ASSERT(year_month_weekday_last, Monday[last] / January / 2020) - SYNTAX_ASSERT(year_month_weekday_last, Monday[last] / January / 2020y) -} constexpr bool test() { day_test(); @@ -781,7 +630,6 @@ constexpr bool test() { year_month_day_last_test(); year_month_weekday_test(); year_month_weekday_last_test(); - syntax_test(); return true; } diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/env.lst b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/env.lst new file mode 100644 index 00000000000..642f530ffad --- /dev/null +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/env.lst @@ -0,0 +1,4 @@ +# Copyright (c) Microsoft Corporation. +# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +RUNALL_INCLUDE ..\usual_latest_matrix.lst diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.cpp new file mode 100644 index 00000000000..74f0c4aba2d --- /dev/null +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.cpp @@ -0,0 +1,145 @@ +// Copyright (c) Microsoft Corporation. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +#include +#include + +using namespace std; +using namespace std::chrono; + +int main() {} // COMPILE-ONLY + +#define TRIVIAL_COPY_STANDARD_LAYOUT(TYPE) \ + static_assert(is_trivially_copyable_v, "chrono::" #TYPE " is not trivially copyable"); \ + static_assert(is_standard_layout_v, "chrono::" #TYPE " is not standard layout"); + +TRIVIAL_COPY_STANDARD_LAYOUT(day) +TRIVIAL_COPY_STANDARD_LAYOUT(month) +TRIVIAL_COPY_STANDARD_LAYOUT(year) +TRIVIAL_COPY_STANDARD_LAYOUT(weekday) +TRIVIAL_COPY_STANDARD_LAYOUT(weekday_indexed) +TRIVIAL_COPY_STANDARD_LAYOUT(weekday_last) +TRIVIAL_COPY_STANDARD_LAYOUT(month_day) +TRIVIAL_COPY_STANDARD_LAYOUT(month_day_last) +TRIVIAL_COPY_STANDARD_LAYOUT(month_weekday) +TRIVIAL_COPY_STANDARD_LAYOUT(month_weekday_last) +TRIVIAL_COPY_STANDARD_LAYOUT(year_month) +TRIVIAL_COPY_STANDARD_LAYOUT(year_month_day) +TRIVIAL_COPY_STANDARD_LAYOUT(year_month_day_last) +TRIVIAL_COPY_STANDARD_LAYOUT(year_month_weekday) +TRIVIAL_COPY_STANDARD_LAYOUT(year_month_weekday_last) + +#define TYPE_ASSERT(TYPE, EXPR) \ + static_assert(is_same_v>, #EXPR " is not chrono::" #TYPE); + +TYPE_ASSERT(day, 0d) +TYPE_ASSERT(year, 0y) +TYPE_ASSERT(month, January) +TYPE_ASSERT(month, February) +TYPE_ASSERT(month, March) +TYPE_ASSERT(month, April) +TYPE_ASSERT(month, May) +TYPE_ASSERT(month, June) +TYPE_ASSERT(month, July) +TYPE_ASSERT(month, August) +TYPE_ASSERT(month, September) +TYPE_ASSERT(month, October) +TYPE_ASSERT(month, November) +TYPE_ASSERT(month, December) +TYPE_ASSERT(weekday, Sunday) +TYPE_ASSERT(weekday, Monday) +TYPE_ASSERT(weekday, Tuesday) +TYPE_ASSERT(weekday, Wednesday) +TYPE_ASSERT(weekday, Thursday) +TYPE_ASSERT(weekday, Friday) +TYPE_ASSERT(weekday, Saturday) +TYPE_ASSERT(weekday_indexed, declval()[1]) +TYPE_ASSERT(weekday_last, declval()[last]) + +TYPE_ASSERT(year_month, 2020y / January) +TYPE_ASSERT(year_month, 2020y / 1) + +TYPE_ASSERT(month_day, January / 1d) +TYPE_ASSERT(month_day, January / 1) +TYPE_ASSERT(month_day, 1 / 1d) +TYPE_ASSERT(month_day, 1d / January) +TYPE_ASSERT(month_day, 1d / 1) + +TYPE_ASSERT(month_day_last, January / last) +TYPE_ASSERT(month_day_last, 1 / last) +TYPE_ASSERT(month_day_last, last / January) +TYPE_ASSERT(month_day_last, last / 1) + +TYPE_ASSERT(month_weekday, January / Monday[1]) +TYPE_ASSERT(month_weekday, 1 / Monday[1]) +TYPE_ASSERT(month_weekday, Monday[1] / January) +TYPE_ASSERT(month_weekday, Monday[1] / 1) + +TYPE_ASSERT(month_weekday_last, January / Monday[last]) +TYPE_ASSERT(month_weekday_last, 1 / Monday[last]) +TYPE_ASSERT(month_weekday_last, Monday[last] / 1) +TYPE_ASSERT(month_weekday_last, Monday[last] / January) + +TYPE_ASSERT(year_month_day, 2020y / January / 1d) +TYPE_ASSERT(year_month_day, 2020y / January / 1) +constexpr auto md = January / 1; +TYPE_ASSERT(year_month_day, 2020y / md) +TYPE_ASSERT(year_month_day, 2020 / md) +TYPE_ASSERT(year_month_day, January / 1 / 2020y) +TYPE_ASSERT(year_month_day, January / 1 / 2020) +TYPE_ASSERT(year_month_day, 1d / January / 2020y) +TYPE_ASSERT(year_month_day, 1d / January / 2020) +TYPE_ASSERT(year_month_day, 1d / 1 / 2020) +TYPE_ASSERT(year_month_day, 1d / 1 / 2020y) + +TYPE_ASSERT(year_month_day_last, 2020y / January / last) +constexpr auto mdl = January / last; +TYPE_ASSERT(year_month_day_last, 2020y / mdl) +TYPE_ASSERT(year_month_day_last, 2020 / mdl) +TYPE_ASSERT(year_month_day_last, last / January / 2020y) +TYPE_ASSERT(year_month_day_last, January / last / 2020) + +TYPE_ASSERT(year_month_weekday, 2020y / January / Monday[1]) +constexpr auto mwd = January / Monday[1]; +TYPE_ASSERT(year_month_weekday, 2020y / mwd) +TYPE_ASSERT(year_month_weekday, 2020 / mwd) +TYPE_ASSERT(year_month_weekday, January / Monday[1] / 2020y) +TYPE_ASSERT(year_month_weekday, January / Monday[1] / 2020) +TYPE_ASSERT(year_month_weekday, Monday[1] / January / 2020y) +TYPE_ASSERT(year_month_weekday, Monday[1] / January / 2020) + +TYPE_ASSERT(year_month_weekday_last, 2020y / January / Monday[last]) +constexpr auto mwdl = January / Monday[last]; +TYPE_ASSERT(year_month_weekday_last, 2020y / mwdl) +TYPE_ASSERT(year_month_weekday_last, 2020 / mwdl) +TYPE_ASSERT(year_month_weekday_last, January / Monday[last] / 2020y) +TYPE_ASSERT(year_month_weekday_last, January / Monday[last] / 2020) +TYPE_ASSERT(year_month_weekday_last, 1 / Monday[last] / 2020) +TYPE_ASSERT(year_month_weekday_last, 1 / Monday[last] / 2020y) +TYPE_ASSERT(year_month_weekday_last, Monday[last] / 1 / 2020y) +TYPE_ASSERT(year_month_weekday_last, Monday[last] / 1 / 2020) +TYPE_ASSERT(year_month_weekday_last, Monday[last] / January / 2020) +TYPE_ASSERT(year_month_weekday_last, Monday[last] / January / 2020y) + + +#define VALUE_ASSERT(VALUE, EXPECTED) static_assert(VALUE == EXPECTED, "chrono::" #VALUE " is not " #EXPECTED); +VALUE_ASSERT(month{1}, January) +VALUE_ASSERT(month{2}, February) +VALUE_ASSERT(month{3}, March) +VALUE_ASSERT(month{4}, April) +VALUE_ASSERT(month{5}, May) +VALUE_ASSERT(month{6}, June) +VALUE_ASSERT(month{7}, July) +VALUE_ASSERT(month{8}, August) +VALUE_ASSERT(month{9}, September) +VALUE_ASSERT(month{10}, October) +VALUE_ASSERT(month{11}, November) +VALUE_ASSERT(month{12}, December) + +VALUE_ASSERT(weekday{0}, Sunday) +VALUE_ASSERT(weekday{1}, Monday) +VALUE_ASSERT(weekday{2}, Tuesday) +VALUE_ASSERT(weekday{3}, Wednesday) +VALUE_ASSERT(weekday{4}, Thursday) +VALUE_ASSERT(weekday{5}, Friday) +VALUE_ASSERT(weekday{6}, Saturday) From 00bbbb7589bf51302b44b3af53a336bc16ed3673 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Fri, 10 Apr 2020 17:00:32 +0100 Subject: [PATCH 036/143] Remove moved over test --- tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 2d269a0a1c0..d170d0826f5 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -231,8 +231,6 @@ constexpr void month_day_test() { constexpr void month_day_last_test() { assert(month_day_last{February}.month() == February); - const auto mdl = January / last; - static_assert(is_same_v, "mdl is not const chrono::month_day_last"); unsigned i = 0; assert(!month_day_last{month{i++}}.ok()); From 849be1d0e4e1a12f9cc8627138e9919a44013296 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Fri, 10 Apr 2020 17:33:52 +0100 Subject: [PATCH 037/143] Constants and literals pt1 (and fix year_month test) --- .../test.cpp | 183 +++++++++--------- 1 file changed, 89 insertions(+), 94 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index d170d0826f5..921690a2c5d 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -10,26 +10,27 @@ using namespace std::chrono; constexpr void day_test() { day d1{0u}; - assert(static_cast(d1) == 0); - assert(++d1 == day{1}); - assert(d1++ == day{1}); - assert(d1 == day{2}); + assert(static_cast(d1) == 0u); + assert(d1 == 0d); + assert(++d1 == 1d); + assert(d1++ == 1d); + assert(d1 == 2d); - assert(--d1 == day{1}); - assert(d1-- == day{1}); - assert(d1 == day{0}); + assert(--d1 == 1d); + assert(d1-- == 1d); + assert(d1 == 0d); d1 += days{2}; - assert(d1 == day{2}); + assert(d1 == 2d); d1 -= days{2}; - assert(d1 == day{0}); + assert(d1 == 0d); day d2{0u}; assert(d1 == d2++); assert(d1 < d2); assert(d2 > d1); - day d3{0}; + day d3{0u}; assert(!d3.ok()); ++d3; for (int i = 1; i <= 31; ++i, ++d3) { @@ -37,31 +38,27 @@ constexpr void day_test() { } assert(!d3.ok()); - const day d4{2}; - const day d5{10}; - const days diff = d5 - d4; + const days diff = 10d - 2d; assert(diff == days{8}); - - const auto d6 = 0d; - assert(d1 == d6); } constexpr void month_test() { month m1{1u}; - assert(static_cast(m1) == 1); - assert(++m1 == month{2}); - assert(m1++ == month{2}); - assert(m1 == month{3}); + assert(static_cast(m1) == 1u); + assert(m1 == January); + assert(++m1 == February); + assert(m1++ == February); + assert(m1 == March); - assert(--m1 == month{2}); - assert(m1-- == month{2}); - assert(m1 == month{1}); + assert(--m1 == February); + assert(m1-- == February); + assert(m1 == January); m1 += months{2}; - assert(m1 == month{3}); + assert(m1 == March); m1 -= months{2}; - assert(m1 == month{1}); + assert(m1 == January); for (unsigned i = 0; i <= 255; ++i) { if (i >= 1 && i <= 12) { @@ -71,46 +68,47 @@ constexpr void month_test() { } } - month m2{1u}; - assert(m1 == m2++); - assert(m2 > m1); - assert(m1 < m2); + assert(February > m1); + assert(m1 < February); - month m3 = m2 + months{11}; - assert(m3 == month{1}); - m3 = months{11} + m2; - assert(m3 == month{1}); - month m4 = m2 - months{2}; - assert(m4 == month{12}); + month m2 = February + months{11}; + assert(m2 == January); + m2 = months{11} + February; + assert(m2 == January); + month m3 = February - months{2}; + assert(m3 == December); - months diff = m1 - m2; + months diff = January - February; assert(diff == months{11}); } constexpr void year_test() { year y1{1}; assert(static_cast(y1) == 1); - assert(++y1 == year{2}); - assert(y1++ == year{2}); - assert(y1 == year{3}); + assert(y1 == 1y); + assert(++y1 == 2y); + assert(y1++ == 2y); + assert(y1 == 3y); - assert(--y1 == year{2}); - assert(y1-- == year{2}); - assert(y1 == year{1}); + assert(--y1 == 2y); + assert(y1-- == 2y); + assert(y1 == 1y); y1 += years{2}; - assert(y1 == year{3}); + assert(y1 == 3y); y1 -= years{2}; - assert(y1 == year{1}); + assert(y1 == 1y); - assert(+y1 == year{1}); - assert(-y1 == year{-1}); + assert(+y1 == 1y); + assert(-y1 == -1y); constexpr int y_min = -32767; constexpr int y_max = 32767; assert(year::min() == year{y_min}); assert(year::max() == year{y_max}); + assert(!year{y_min - 1}.ok()); + assert(!year{y_max + 1}.ok()); for (int i = y_min; i <= y_max; i++) { assert(year{i}.ok()); if (i % 4 == 0 && (i % 100 != 0 || i % 400 == 0)) { @@ -119,42 +117,40 @@ constexpr void year_test() { assert(!year{i}.is_leap()); } } - year y2{1}; - assert(y1 == y2++); - assert(y1 < y2); - assert(y2 > y1); + assert(y1 < 2y); + assert(2y > y1); - y2 = y1 + years{4}; - assert(y2 == year{5}); + year y2 = y1 + years{4}; + assert(y2 == 5y); y2 = years{4} + y1; - assert(y2 == year{5}); + assert(y2 == 5y); year y3 = y2 - years{4}; - assert(y3 == year{1}); + assert(y3 == 1y); } constexpr void weekday_test() { - assert(weekday{7} == weekday{0}); - assert(weekday{sys_days{}} == weekday{4}); + assert(weekday{7} == Sunday); + assert(weekday{sys_days{}} == Thursday); assert(weekday{local_days{}} == sys_days{local_days{}.time_since_epoch()}); weekday wd{0u}; - assert(wd == weekday{0}); - assert(++wd == weekday{1}); - assert(wd++ == weekday{1}); - assert(wd == weekday{2}); + assert(wd == Sunday); + assert(++wd == Monday); + assert(wd++ == Monday); + assert(wd == Tuesday); - assert(--wd == weekday{1}); - assert(wd-- == weekday{1}); - assert(wd == weekday{0}); + assert(--wd == Monday); + assert(wd-- == Monday); + assert(wd == Sunday); wd += days{2}; - assert(wd == weekday{2}); + assert(wd == Tuesday); wd -= days{3}; - assert(wd == weekday{6}); + assert(wd == Saturday); - assert(weekday{0}.c_encoding() == 0u); - assert(weekday{0}.iso_encoding() == 7u); + assert(Sunday.c_encoding() == 0u); + assert(Sunday.iso_encoding() == 7u); for (unsigned i = 0; i <= 255; ++i) { if (i <= 7) { @@ -163,8 +159,8 @@ constexpr void weekday_test() { assert(!weekday{i}.ok()); } } - assert(weekday{1} + days{6} == weekday{0}); - assert(weekday{0} - weekday{1} == days{6}); + assert(Monday + days{6} == Sunday); + assert(Sunday - Monday == days{6}); } constexpr void weekday_indexed_test() { @@ -230,22 +226,22 @@ constexpr void month_day_test() { } constexpr void month_day_last_test() { - assert(month_day_last{February}.month() == February); + assert((February / last).month() == February); unsigned i = 0; - assert(!month_day_last{month{i++}}.ok()); + assert(!(month{i++} / last).ok()); for (; i <= 12; ++i) { - assert(month_day_last{month{i}}.ok()); + assert((month{i} / last).ok()); } - assert(!month_day_last{month{i}}.ok()); + assert(!(month{i} / last).ok()); - assert(month_day_last{January} == month_day_last{January}); - assert(month_day_last{January} < month_day_last{February}); - assert(month_day_last{December} > month_day_last{February}); + assert(January / last == January / last); + assert(January / last < February / last); + assert(December / last > February / last); } constexpr void month_weekday_test() { - const month_weekday mwd1{January, Monday[2]}; + const auto mwd1 = January / Monday[2]; assert(mwd1.month() == January); assert(mwd1.weekday_indexed().weekday() == Monday); assert(mwd1.weekday_indexed().index() == 2); @@ -265,18 +261,18 @@ constexpr void month_weekday_test() { // } //} - assert((month_weekday{January, Monday[2]} == month_weekday{January, Monday[2]})); + assert(January / Monday[2] == January / Monday[2]); } constexpr void month_weekday_last_test() { - month_weekday_last mwdl{January, Monday[last]}; + const auto mwdl = January / Monday[last]; assert(mwdl.month() == January); assert(mwdl.weekday_last().weekday() == Monday); - assert((mwdl == month_weekday_last{January, Monday[last]})); + assert(mwdl == January / Monday[last]); } constexpr void year_month_test() { - year_month ym{2020y, January}; + auto ym = 2020y / January; assert(ym.year() == 2020y); assert(ym.month() == January); @@ -307,24 +303,23 @@ constexpr void year_month_test() { // } //} - assert((year_month{2020y, April} == year_month{2020y, April})); - assert((year_month{2019y, April} < year_month{2020y, April})); - assert((year_month{2020y, March} < year_month{2020y, April})); - assert((year_month{2020y, April} > year_month{2019y, April})); - assert((year_month{2020y, April} > year_month{2020y, March})); - - assert((ym + months{2} == year_month{2020y, March})); - assert((year_month{2020y, March} == ym + months{2})); + assert(2020y / April == 2020y / April); + assert(2019y / April < 2020y / April); + assert(2020y / March < 2020y / April); + assert(2020y / April > 2019y / April); + assert(2020y / April > 2020y / March); - assert((ym - months{2} == year_month{2019y, November})); + assert(ym + months{2} == 2020y / March); + assert(months{2} + ym == 2020y / March); - assert((ym - year_month{2019y, January} == months{12})); + assert(ym - months{2} == 2019y / November); - assert((ym + years{2} == year_month{2022y, January})); - assert((year_month{2022y, January} == ym + years{2})); + assert(ym - 2019y / January == months{12}); + assert(ym + years{2} == 2022y / January); + assert(years{2} + ym == 2022y / January); - assert((ym - years{2} == year_month{2018y, January})); + assert(ym - years{2} == 2018y / January); } constexpr void year_month_day_test() { From bf31ef7234934fdb10054f5a0f6ec2741f76eb25 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Fri, 10 Apr 2020 18:21:10 +0100 Subject: [PATCH 038/143] Constants and literals pt2 --- .../test.cpp | 202 ++++++------------ 1 file changed, 69 insertions(+), 133 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 921690a2c5d..b850f6373f6 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -323,7 +323,7 @@ constexpr void year_month_test() { } constexpr void year_month_day_test() { - year_month_day ymd1{year{2020}, month{1}, day{1}}; + year_month_day ymd1{2020y / January / 1d}; assert(ymd1.year() == 2020y); assert(ymd1.month() == January); assert(ymd1.day() == 1d); @@ -363,10 +363,10 @@ constexpr void year_month_day_test() { assert(ymd1.month() == January); assert(ymd1.day() == 1d); - assert((year_month_day{2020y, April, 06d} == sys_days{days{18'358}})); - assert(year_month_day{sys_days{2017y / January / 0}} == 2016y / December / 31); - assert(year_month_day{sys_days{2017y / January / 31}} == 2017y / January / 31); - assert(year_month_day{sys_days{2017y / January / 32}} == 2017y / February / 1); + assert(2020y / April / 06d == sys_days{days{18'358}}); + assert(sys_days{2017y / January / 0} == 2016y / December / 31); + assert(sys_days{2017y / January / 31} == 2017y / January / 31); + assert(sys_days{2017y / January / 32} == 2017y / February / 1); assert(static_cast(ymld) == local_days{}); @@ -388,62 +388,50 @@ constexpr void year_month_day_test() { // } //} - assert((year_month_day{2020y, January, 1d} == year_month_day{2020y, January, 1d})); - assert((year_month_day{2019y, January, 1d} < year_month_day{2020y, January, 1d})); - assert((year_month_day{2020y, January, 1d} < year_month_day{2020y, February, 1d})); - assert((year_month_day{2020y, January, 1d} < year_month_day{2020y, January, 2d})); - assert((year_month_day{2020y, January, 1d} > year_month_day{2019y, January, 1d})); - assert((year_month_day{2020y, February, 1d} > year_month_day{2020y, January, 1d})); - assert((year_month_day{2020y, January, 2d} > year_month_day{2020y, January, 1d})); + assert(2020y / January / 1d == 2020y / January / 1d); + assert(2019y / January / 1d < 2020y / January / 1d); + assert(2020y / January / 1d < 2020y / February / 1d); + assert(2020y / January / 1d < 2020y / January / 2d); + assert(2020y / January / 1d > 2019y / January / 1d); + assert(2020y / February / 1d > 2020y / January / 1d); + assert(2020y / January / 2d > 2020y / January / 1d); - const auto ymd3 = year_month_day{2019y, December, 31d} + months{2}; - assert((ymd3 == year_month_day{2020y, February, 31d})); + const auto ymd3 = 2019y / December / 31d + months{2}; + assert(ymd3 == 2020y / February / 31d); assert(!ymd3.ok()); - assert((months{2} + year_month_day{2019y, December, 31d} == ymd3)); + assert(months{2} + 2019y / December / 31d == ymd3); - const auto ymd4 = year_month_day{2020y, January, 1d} - months{2}; - assert((ymd4 == year_month_day{2019y, November, 1d})); - const auto ymd5 = year_month_day{2020y, January, 1d} + years{2}; - assert((ymd5 == year_month_day{2022y, January, 1d})); - assert((years{2} + year_month_day{2020y, January, 1d} == ymd5)); + assert(2020y / January / 1d - months{2} == 2019y / November / 1d); - const auto ymd6 = year_month_day{2020y, January, 1d} - years{2}; - assert((ymd6 == year_month_day{2018y, January, 1d})); + assert(2020y / January / 1d + years{2} == 2022y / January / 1d); + assert(years{2} + 2020y / January / 1d == 2022y / January / 1d); + + assert(2020y / January / 1d - years{2} == 2018y / January / 1d); } constexpr void year_month_day_last_test() { - year_month_day_last ymdl{2020y, month_day_last{February}}; + auto ymdl = 2020y / February / last; + assert(ymdl == 2020y / February / last); + assert(ymdl == 2020y / February / 29d); assert(ymdl.year() == 2020y); assert(ymdl.month() == February); - assert((ymdl.month_day_last() == month_day_last{February})); + assert(ymdl.month_day_last() == February / last); assert(ymdl.day() == 29d); ymdl += months{2}; - assert(ymdl.year() == 2020y); - assert(ymdl.month() == April); - assert((ymdl.month_day_last() == month_day_last{April})); - assert(ymdl.day() == 30d); + assert(ymdl == 2020y / April / 30d); ymdl -= months{2}; - assert(ymdl.year() == 2020y); - assert(ymdl.month() == February); - assert((ymdl.month_day_last() == month_day_last{February})); - assert(ymdl.day() == 29d); + assert(ymdl == 2020y / February / 29d); ymdl += years{2}; - assert(ymdl.year() == 2022y); - assert(ymdl.month() == February); - assert((ymdl.month_day_last() == month_day_last{February})); - assert(ymdl.day() == 28d); + assert(ymdl == 2022y / February / 28d); ymdl -= years{2}; - assert(ymdl.year() == 2020y); - assert(ymdl.month() == February); - assert((ymdl.month_day_last() == month_day_last{February})); - assert(ymdl.day() == 29d); + assert(ymdl == 2020y / February / 29d); - assert((year_month_day_last{2020y, month_day_last{April}} == sys_days{days{18'382}})); + assert(2020y / April / last == sys_days{days{18'382}}); assert(static_cast(ymdl) == local_days{ymdl}); // constexpr int y_min = static_cast(year::min()); @@ -460,41 +448,33 @@ constexpr void year_month_day_last_test() { // } //} - assert((ymdl == year_month_day_last{2020y, February / last})); - assert((ymdl < year_month_day_last{2021y, February / last})); - assert((ymdl < year_month_day_last{2020y, March / last})); - assert((year_month_day_last{2021y, February / last} > ymdl)); - assert((year_month_day_last{2020y, March / last} > ymdl)); + assert(ymdl < 2021y / February / last); + assert(ymdl < 2020y / March / last); + assert(2021y / February / last > ymdl); + assert(2020y / March / last > ymdl); - const auto ymdl2 = ymdl + months{2}; - assert((ymdl2 == year_month_day_last{2020y, April / last})); - assert((ymdl2 == months{2} + ymdl)); + assert(ymdl + months{2} == 2020y / April / last); + assert(months{2} + ymdl == 2020y / April / last); - const auto ymdl3 = ymdl - months{2}; - assert((ymdl3 == year_month_day_last{2019y, December / last})); + assert(ymdl - months{2} == 2019y / December / last); - const auto ymdl4 = ymdl + years{2}; - assert((ymdl4 == year_month_day_last{2022y, February / last})); - assert((ymdl4 == years{2} + ymdl)); + assert(ymdl + years{2} == 2022y / February / last); + assert(years{2} + ymdl == 2022y / February / last); - const auto ymdl5 = ymdl - years{2}; - assert((ymdl5 == year_month_day_last{2018y, February / last})); + assert(ymdl - years{2} == 2018y / February / last); } constexpr void year_month_weekday_test() { - year_month_weekday ymwd{2020y, April, Tuesday[2]}; + auto ymwd = 2020y / April / Tuesday[2]; + assert(ymwd == 2020y / April / Tuesday[2]); assert(ymwd.year() == 2020y); assert(ymwd.month() == April); assert(ymwd.weekday() == Tuesday); assert(ymwd.index() == 2u); - assert((ymwd.weekday_indexed() == weekday_indexed{Tuesday, 2})); + assert(ymwd.weekday_indexed() == Tuesday[2]); const year_month_weekday epoch{sys_days{}}; - assert(epoch.year() == 1970y); - assert(epoch.month() == January); - assert(epoch.weekday() == Thursday); - assert(epoch.index() == 1u); - assert((epoch.weekday_indexed() == weekday_indexed{Thursday, 1})); + assert(epoch == 1970y / January / Thursday[1]); local_days ldp; sys_days sys{ldp.time_since_epoch()}; @@ -502,109 +482,65 @@ constexpr void year_month_weekday_test() { assert((ymlwd == year_month_weekday{sys})); ymwd += months{2}; - assert(ymwd.year() == 2020y); - assert(ymwd.month() == June); - assert(ymwd.weekday() == Tuesday); - assert(ymwd.index() == 2u); - assert((ymwd.weekday_indexed() == weekday_indexed{Tuesday, 2})); - + assert(ymwd == 2020y / June / Tuesday[2]); ymwd -= months{2}; - assert(ymwd.year() == 2020y); - assert(ymwd.month() == April); - assert(ymwd.weekday() == Tuesday); - assert(ymwd.index() == 2u); - assert((ymwd.weekday_indexed() == weekday_indexed{Tuesday, 2})); + assert(ymwd == 2020y / April / Tuesday[2]); ymwd += years{2}; - assert(ymwd.year() == 2022y); - assert(ymwd.month() == April); - assert(ymwd.weekday() == Tuesday); - assert(ymwd.index() == 2u); - assert((ymwd.weekday_indexed() == weekday_indexed{Tuesday, 2})); - + assert(ymwd == 2022y / April / Tuesday[2]); ymwd -= years{2}; - assert(ymwd.year() == 2020y); - assert(ymwd.month() == April); - assert(ymwd.weekday() == Tuesday); - assert(ymwd.index() == 2u); - assert((ymwd.weekday_indexed() == weekday_indexed{Tuesday, 2})); + assert(ymwd == 2020y / April / Tuesday[2]); assert(static_cast(epoch) == sys_days{}); - year_month_weekday prev{1970y / January / Thursday[0]}; + const auto prev = 1970y / January / Thursday[0]; assert(static_cast(prev) == (sys_days{} - days{7})); assert(static_cast(ymwd) == local_days{ymwd}); - assert((year_month_weekday{2020y / April / Wednesday[5]}.ok())); - assert((!year_month_weekday{2020y / April / Tuesday[5]}.ok())); - - assert((ymwd == year_month_weekday{2020y, April, Tuesday[2]})); + assert((2020y / April / Wednesday[5]).ok()); + assert(!(2020y / April / Tuesday[5]).ok()); - const auto ymwd2 = ymwd + months{2}; - assert((ymwd2 == year_month_weekday{2020y, June, Tuesday[2]})); - const auto ymwd3 = months{2} + ymwd; - assert(ymwd2 == ymwd3); + assert(ymwd + months{2} == 2020y / June / Tuesday[2]); + assert(months{2} + ymwd == 2020y / June / Tuesday[2]); - const auto ymwd4 = ymwd - months{2}; - assert((ymwd4 == year_month_weekday{2020y, February, Tuesday[2]})); + assert(ymwd - months{2} == 2020y / February / Tuesday[2]); - const auto ymwd5 = ymwd + years{2}; - assert((ymwd5 == year_month_weekday{2022y, April, Tuesday[2]})); - const auto ymwd6 = years{2} + ymwd; - assert(ymwd5 == ymwd6); + assert(ymwd + years{2} == 2022y / April / Tuesday[2]); + assert(years{2} + ymwd == 2022y / April / Tuesday[2]); - const auto ymwd7 = ymwd - years{2}; - assert((ymwd7 == year_month_weekday{2018y, April, Tuesday[2]})); + assert(ymwd - years{2} == 2018y / April / Tuesday[2]); } constexpr void year_month_weekday_last_test() { - year_month_weekday_last ymwdl{2020y, January, Monday[last]}; + auto ymwdl = 2020y / January / Monday[last]; + assert(ymwdl == 2020y / January / Monday[last]); assert(ymwdl.year() == 2020y); assert(ymwdl.month() == January); assert(ymwdl.weekday() == Monday); assert(ymwdl.weekday_last() == Monday[last]); ymwdl += months{2}; - assert(ymwdl.year() == 2020y); - assert(ymwdl.month() == March); - assert(ymwdl.weekday() == Monday); - assert(ymwdl.weekday_last() == Monday[last]); - + assert(ymwdl == 2020y / March / Monday[last]); ymwdl -= months{2}; - assert(ymwdl.year() == 2020y); - assert(ymwdl.month() == January); - assert(ymwdl.weekday() == Monday); - assert(ymwdl.weekday_last() == Monday[last]); + assert(ymwdl == 2020y / January / Monday[last]); ymwdl += years{2}; - assert(ymwdl.year() == 2022y); - assert(ymwdl.month() == January); - assert(ymwdl.weekday() == Monday); - assert(ymwdl.weekday_last() == Monday[last]); - + assert(ymwdl == 2022y / January / Monday[last]); ymwdl -= years{2}; - assert(ymwdl.year() == 2020y); - assert(ymwdl.month() == January); - assert(ymwdl.weekday() == Monday); - assert(ymwdl.weekday_last() == Monday[last]); + assert(ymwdl == 2020y / January / Monday[last]); assert((static_cast(ymwdl) == sys_days{days{18'288}})); assert((static_cast(ymwdl) == local_days{ymwdl})); - const auto ymwdl2 = ymwdl + months{2}; - assert((ymwdl2 == 2020y / March / Monday[last])); - const auto ymwdl3 = months{2} + ymwdl; - assert(ymwdl3 == ymwdl2); + assert(ymwdl + months{2} == 2020y / March / Monday[last]); + assert(months{2} + ymwdl == 2020y / March / Monday[last]); + + assert(ymwdl - months{2} == 2019y / November / Monday[last]); - const auto ymwdl4 = ymwdl - months{2}; - assert(ymwdl4 == 2019y / November / Monday[last]); + assert(ymwdl + years{2} == 2022y / January / Monday[last]); + assert(years{2} + ymwdl == 2022y / January / Monday[last]); - const auto ymwdl5 = ymwdl + years{2}; - assert(ymwdl5 == 2022y / January / Monday[last]); - const auto ymwdl6 = years{2} + ymwdl; - assert(ymwdl6 == ymwdl5); - const auto ymwdl7 = ymwdl - years{2}; - assert(ymwdl7 == 2018y / January / Monday[last]); + assert(ymwdl - years{2} == 2018y / January / Monday[last]); } constexpr bool test() { From d9601f1ddb8108ed821758b49f66743e6e683236 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Fri, 10 Apr 2020 18:28:59 +0100 Subject: [PATCH 039/143] Consistency --- .../test.cpp | 138 ++++++++---------- 1 file changed, 64 insertions(+), 74 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index b850f6373f6..0fb62250e2e 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -9,56 +9,53 @@ using namespace std; using namespace std::chrono; constexpr void day_test() { - day d1{0u}; - assert(static_cast(d1) == 0u); - assert(d1 == 0d); - assert(++d1 == 1d); - assert(d1++ == 1d); - assert(d1 == 2d); - - assert(--d1 == 1d); - assert(d1-- == 1d); - assert(d1 == 0d); - - d1 += days{2}; - assert(d1 == 2d); - d1 -= days{2}; - assert(d1 == 0d); + day d{0u}; + assert(static_cast(d) == 0u); + assert(d == 0d); + assert(++d == 1d); + assert(d++ == 1d); + assert(d == 2d); + + assert(--d == 1d); + assert(d-- == 1d); + assert(d == 0d); + + d += days{2}; + assert(d == 2d); + d -= days{2}; + assert(d == 0d); + + assert(d < 2d); + assert(2d > d); day d2{0u}; - assert(d1 == d2++); - assert(d1 < d2); - assert(d2 > d1); - - day d3{0u}; - assert(!d3.ok()); - ++d3; - for (int i = 1; i <= 31; ++i, ++d3) { - assert(d3.ok()); + assert(!d2.ok()); + ++d2; + for (int i = 1; i <= 31; ++i, ++d2) { + assert(d2.ok()); } - assert(!d3.ok()); + assert(!d2.ok()); - const days diff = 10d - 2d; - assert(diff == days{8}); + assert(10d - 2d == days{8}); } constexpr void month_test() { - month m1{1u}; - assert(static_cast(m1) == 1u); - assert(m1 == January); - assert(++m1 == February); - assert(m1++ == February); - assert(m1 == March); + month m{1u}; + assert(static_cast(m) == 1u); + assert(m == January); + assert(++m == February); + assert(m++ == February); + assert(m == March); - assert(--m1 == February); - assert(m1-- == February); - assert(m1 == January); + assert(--m == February); + assert(m-- == February); + assert(m == January); - m1 += months{2}; - assert(m1 == March); - m1 -= months{2}; - assert(m1 == January); + m += months{2}; + assert(m == March); + m -= months{2}; + assert(m == January); for (unsigned i = 0; i <= 255; ++i) { if (i >= 1 && i <= 12) { @@ -68,39 +65,35 @@ constexpr void month_test() { } } - assert(February > m1); - assert(m1 < February); + assert(February > m); + assert(m < February); - month m2 = February + months{11}; - assert(m2 == January); - m2 = months{11} + February; - assert(m2 == January); - month m3 = February - months{2}; - assert(m3 == December); + assert(February + months{11} == January); + assert(months{11} + February == January); + assert(February - months{2} == December); - months diff = January - February; - assert(diff == months{11}); + assert(January - February == months{11}); } constexpr void year_test() { - year y1{1}; - assert(static_cast(y1) == 1); - assert(y1 == 1y); - assert(++y1 == 2y); - assert(y1++ == 2y); - assert(y1 == 3y); + year y{1}; + assert(static_cast(y) == 1); + assert(y == 1y); + assert(++y == 2y); + assert(y++ == 2y); + assert(y == 3y); - assert(--y1 == 2y); - assert(y1-- == 2y); - assert(y1 == 1y); + assert(--y == 2y); + assert(y-- == 2y); + assert(y == 1y); - y1 += years{2}; - assert(y1 == 3y); - y1 -= years{2}; - assert(y1 == 1y); + y += years{2}; + assert(y == 3y); + y -= years{2}; + assert(y == 1y); - assert(+y1 == 1y); - assert(-y1 == -1y); + assert(+y == 1y); + assert(-y == -1y); constexpr int y_min = -32767; constexpr int y_max = 32767; @@ -117,16 +110,13 @@ constexpr void year_test() { assert(!year{i}.is_leap()); } } - assert(y1 < 2y); - assert(2y > y1); + assert(y < 2y); + assert(2y > y); - year y2 = y1 + years{4}; - assert(y2 == 5y); - y2 = years{4} + y1; - assert(y2 == 5y); + assert(y + years{4} == 5y); + assert(years{4} + y == 5y); - year y3 = y2 - years{4}; - assert(y3 == 1y); + assert(y - years{4} == -3y); } constexpr void weekday_test() { @@ -534,7 +524,7 @@ constexpr void year_month_weekday_last_test() { assert(ymwdl + months{2} == 2020y / March / Monday[last]); assert(months{2} + ymwdl == 2020y / March / Monday[last]); - + assert(ymwdl - months{2} == 2019y / November / Monday[last]); assert(ymwdl + years{2} == 2022y / January / Monday[last]); From 38899f9b86528b9c737b1a0a9f6de3fe8d6747a9 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sun, 12 Apr 2020 11:26:57 +0100 Subject: [PATCH 040/143] Add last_spec --- .../P0355R7_calendars_and_time_zones_dates_literals/test.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.cpp index 74f0c4aba2d..a41d135f14a 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.cpp @@ -53,6 +53,7 @@ TYPE_ASSERT(weekday, Wednesday) TYPE_ASSERT(weekday, Thursday) TYPE_ASSERT(weekday, Friday) TYPE_ASSERT(weekday, Saturday) +TYPE_ASSERT(last_spec, last) TYPE_ASSERT(weekday_indexed, declval()[1]) TYPE_ASSERT(weekday_last, declval()[last]) From 9f2e44ebcaf1d2e466a1fdc4c4cb42f6aea9d100 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sun, 12 Apr 2020 13:34:01 +0100 Subject: [PATCH 041/143] Add duration and time_point alias tests --- tests/std/test.lst | 2 +- .../env.lst | 0 .../test.cpp | 58 +++++++++++++++++++ .../test.cpp | 31 ---------- 4 files changed, 59 insertions(+), 32 deletions(-) rename tests/std/tests/{P0355R7_calendars_and_time_zones_time_point_arithmetic => P0355R7_calendars_and_time_zones_time_point_and_durations}/env.lst (100%) create mode 100644 tests/std/tests/P0355R7_calendars_and_time_zones_time_point_and_durations/test.cpp delete mode 100644 tests/std/tests/P0355R7_calendars_and_time_zones_time_point_arithmetic/test.cpp diff --git a/tests/std/test.lst b/tests/std/test.lst index 31465751970..ebc5aeadc32 100644 --- a/tests/std/test.lst +++ b/tests/std/test.lst @@ -207,7 +207,7 @@ tests\P0220R1_string_view tests\P0325R4_to_array tests\P0355R7_calendars_and_time_zones_dates tests\P0355R7_calendars_and_time_zones_dates_literals -tests\P0355R7_calendars_and_time_zones_time_point_arithmetic +tests\P0355R7_calendars_and_time_zones_time_point_and_durations tests\P0356R5_bind_front tests\P0357R3_supporting_incomplete_types_in_reference_wrapper tests\P0414R2_shared_ptr_for_arrays diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_arithmetic/env.lst b/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_and_durations/env.lst similarity index 100% rename from tests/std/tests/P0355R7_calendars_and_time_zones_time_point_arithmetic/env.lst rename to tests/std/tests/P0355R7_calendars_and_time_zones_time_point_and_durations/env.lst diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_and_durations/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_and_durations/test.cpp new file mode 100644 index 00000000000..eca7153d714 --- /dev/null +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_and_durations/test.cpp @@ -0,0 +1,58 @@ +// Copyright (c) Microsoft Corporation. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +#include +#include +#include +#include + +using namespace std; +using namespace std::chrono; + +#define DURATION_TEST(TYPE, BITS, ...) \ + static_assert( \ + is_integral_v && is_signed_v, "chrono::" #TYPE "::rep is not a signed integral type."); \ + static_assert( \ + numeric_limits::digits >= BITS, "chrono::" #TYPE "::rep is not at least " #BITS " bits."); \ + static_assert(is_same_v, "chrono::" #TYPE "::period is not " #__VA_ARGS__ "."); + +DURATION_TEST(days, 25, ratio_multiply, hours::period>) +DURATION_TEST(weeks, 22, ratio_multiply, days::period>) +DURATION_TEST(months, 20, ratio_divide>) +DURATION_TEST(years, 17, ratio_multiply, days::period>) + +// clang-format off +static_assert(is_same_v>, + "sys_seconds is not time_point."); +static_assert(is_same_v>, + "sys_days is not time_point."); + +static_assert( is_same_v>, + "local_seconds is not time_point."); +static_assert(is_same_v>, + "local_days is not time_point."); +// clang-format on + +constexpr bool test() { + steady_clock::time_point tp1; + auto tp2 = tp1++; + assert(tp1.time_since_epoch().count() == 1); + assert(tp2.time_since_epoch().count() == 0); + tp2 = ++tp1; + assert(tp1.time_since_epoch().count() == 2); + assert(tp2.time_since_epoch().count() == 2); + + tp2 = tp1--; + assert(tp1.time_since_epoch().count() == 1); + assert(tp2.time_since_epoch().count() == 2); + tp2 = --tp1; + assert(tp1.time_since_epoch().count() == 0); + assert(tp2.time_since_epoch().count() == 0); + + return true; +} + +int main() { + test(); + static_assert(test()); +} diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_arithmetic/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_arithmetic/test.cpp deleted file mode 100644 index 2cdb4f46eb8..00000000000 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_arithmetic/test.cpp +++ /dev/null @@ -1,31 +0,0 @@ -// Copyright (c) Microsoft Corporation. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception - -#include -#include - -using namespace std::chrono; - -constexpr bool test() { - steady_clock::time_point tp1; - auto tp2 = tp1++; - assert(tp1.time_since_epoch().count() == 1); - assert(tp2.time_since_epoch().count() == 0); - tp2 = ++tp1; - assert(tp1.time_since_epoch().count() == 2); - assert(tp2.time_since_epoch().count() == 2); - - tp2 = tp1--; - assert(tp1.time_since_epoch().count() == 1); - assert(tp2.time_since_epoch().count() == 2); - tp2 = --tp1; - assert(tp1.time_since_epoch().count() == 0); - assert(tp2.time_since_epoch().count() == 0); - - return true; -} - -int main() { - test(); - static_assert(test()); -} From c96c780e67dcb0eb1bfd2980e7089e533d79f6ae Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sun, 12 Apr 2020 13:50:45 +0100 Subject: [PATCH 042/143] Whitespace --- .../test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_and_durations/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_and_durations/test.cpp index eca7153d714..cc71ed5f1a6 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_and_durations/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_and_durations/test.cpp @@ -22,7 +22,7 @@ DURATION_TEST(months, 20, ratio_divide>) DURATION_TEST(years, 17, ratio_multiply, days::period>) // clang-format off -static_assert(is_same_v>, +static_assert(is_same_v>, "sys_seconds is not time_point."); static_assert(is_same_v>, "sys_days is not time_point."); From dc45a4d947ada01ae6d5a2e1324abf33dde08028 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Mon, 13 Apr 2020 16:33:28 +0100 Subject: [PATCH 043/143] Ain't got no alibi --- stl/inc/chrono | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 7ac4687184b..6eee0e6b8e8 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -988,11 +988,11 @@ namespace chrono { _NODISCARD constexpr year_month_weekday operator/(int _Year, const month_weekday& _Mwd) noexcept; _NODISCARD constexpr year_month_weekday operator/(const month_weekday& _Mwd, const year& _Year) noexcept; _NODISCARD constexpr year_month_weekday operator/(const month_weekday& _Mwd, int _Year) noexcept; - _NODISCARD constexpr year_month_weekday_last operator/(const year_month& ym, const weekday_last& _Wdl) noexcept; - _NODISCARD constexpr year_month_weekday_last operator/(const year& _Year, const month_weekday_last& mwdl) noexcept; - _NODISCARD constexpr year_month_weekday_last operator/(int _Year, const month_weekday_last& mwdl) noexcept; - _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& mwdl, const year& _Year) noexcept; - _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& mwdl, int _Year) noexcept; + _NODISCARD constexpr year_month_weekday_last operator/(const year_month& _Ym, const weekday_last& _Wdl) noexcept; + _NODISCARD constexpr year_month_weekday_last operator/(const year& _Year, const month_weekday_last& _Mwdl) noexcept; + _NODISCARD constexpr year_month_weekday_last operator/(int _Year, const month_weekday_last& _Mwdl) noexcept; + _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, const year& _Year) noexcept; + _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, int _Year) noexcept; // day constexpr day::day(unsigned _Val) noexcept : _Day{static_cast(_Val)} {} From 53151164d5c4e0c0b100e27a1ff58b77d005d46c Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Tue, 14 Apr 2020 16:06:16 +0100 Subject: [PATCH 044/143] Comment out unused variables --- .../std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 0fb62250e2e..8d6cc886a71 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -360,8 +360,8 @@ constexpr void year_month_day_test() { assert(static_cast(ymld) == local_days{}); - constexpr int y_min = static_cast(year::min()); - constexpr int y_max = static_cast(year::max()); + // constexpr int y_min = static_cast(year::min()); + // constexpr int y_max = static_cast(year::max()); // for (int iy = y_min; iy <= y_max; ++iy) { // for (auto um = 0u; um <= 255u; ++um) { From 7d77939807c53a7d2c426a0befabceae41f43457 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Tue, 14 Apr 2020 16:13:07 +0100 Subject: [PATCH 045/143] Newlines --- tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 8d6cc886a71..3a667dbabc0 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -102,6 +102,7 @@ constexpr void year_test() { assert(!year{y_min - 1}.ok()); assert(!year{y_max + 1}.ok()); + for (int i = y_min; i <= y_max; i++) { assert(year{i}.ok()); if (i % 4 == 0 && (i % 100 != 0 || i % 400 == 0)) { @@ -110,6 +111,7 @@ constexpr void year_test() { assert(!year{i}.is_leap()); } } + assert(y < 2y); assert(2y > y); From 028270d74773ccad4d6f31e5cf94163f5b612880 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Tue, 14 Apr 2020 19:34:34 +0100 Subject: [PATCH 046/143] Move day --- stl/inc/chrono | 114 ++++++++++++++++++++++--------------------------- 1 file changed, 50 insertions(+), 64 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 2091bccfe98..7002f551886 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -678,20 +678,60 @@ namespace chrono { public: day() = default; - constexpr explicit day(unsigned _Val) noexcept; - - constexpr day& operator++() noexcept; - constexpr day operator++(int) noexcept; - constexpr day& operator--() noexcept; - constexpr day operator--(int) noexcept; + constexpr explicit day(unsigned _Val) noexcept : _Day{static_cast(_Val)} {} + + constexpr day& operator++() noexcept { + ++_Day; + return *this; + } + constexpr day operator++(int) noexcept { + return day{_Day++}; + } + constexpr day& operator--() noexcept { + --_Day; + return *this; + } + constexpr day operator--(int) noexcept { + return day{_Day--}; + } - constexpr day& operator+=(const days& _Days) noexcept; - constexpr day& operator-=(const days& _Days) noexcept; + constexpr day& operator+=(const days& _Days) noexcept { + _Day += static_cast(_Days.count()); + return *this; + } + constexpr day& operator-=(const days& _Days) noexcept { + _Day -= static_cast(_Days.count()); + return *this; + } - _NODISCARD constexpr explicit operator unsigned() const noexcept; - _NODISCARD constexpr bool ok() const noexcept; + _NODISCARD constexpr explicit operator unsigned() const noexcept { + return _Day; + } + _NODISCARD constexpr bool ok() const noexcept { + return _Day >= 1 && _Day <= 31; + } }; + constexpr bool operator==(const day& _Left, const day& _Right) noexcept { + return static_cast(_Left) == static_cast(_Right); + } + constexpr strong_ordering operator<=>(const day& _Left, const day& _Right) noexcept { + return static_cast(_Left) <=> static_cast(_Right); + } + + constexpr day operator+(const day& _Left, const days& _Right) noexcept { + return day{static_cast(_Left) + _Right.count()}; + } + constexpr day operator+(const days& _Left, const day& _Right) noexcept { + return _Right + _Left; + } + constexpr day operator-(const day& _Left, const days& _Right) noexcept { + return day{static_cast(_Left) - _Right.count()}; + } + constexpr days operator-(const day& _Left, const day& _Right) noexcept { + return days{static_cast(static_cast(_Left)) - static_cast(static_cast(_Right))}; + } + class month { unsigned char _Month; @@ -999,60 +1039,6 @@ namespace chrono { _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, const year& _Year) noexcept; _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, int _Year) noexcept; - // day - constexpr day::day(unsigned _Val) noexcept : _Day{static_cast(_Val)} {} - - constexpr day& day::operator++() noexcept { - ++_Day; - return *this; - } - constexpr day day::operator++(int) noexcept { - return day{_Day++}; - } - constexpr day& day::operator--() noexcept { - --_Day; - return *this; - } - constexpr day day::operator--(int) noexcept { - return day{_Day--}; - } - - constexpr day::operator unsigned() const noexcept { - return _Day; - } - constexpr bool day::ok() const noexcept { - return _Day >= 1 && _Day <= 31; - } - - constexpr bool operator==(const day& _Left, const day& _Right) noexcept { - return static_cast(_Left) == static_cast(_Right); - } - constexpr strong_ordering operator<=>(const day& _Left, const day& _Right) noexcept { - return static_cast(_Left) <=> static_cast(_Right); - } - - constexpr day operator+(const day& _Left, const days& _Right) noexcept { - return day{static_cast(_Left) + _Right.count()}; - } - constexpr day operator+(const days& _Left, const day& _Right) noexcept { - return _Right + _Left; - } - constexpr day operator-(const day& _Left, const days& _Right) noexcept { - return day{static_cast(_Left) - _Right.count()}; - } - constexpr days operator-(const day& _Left, const day& _Right) noexcept { - return days{static_cast(static_cast(_Left)) - static_cast(static_cast(_Right))}; - } - - constexpr day& day::operator+=(const days& _Days) noexcept { - *this = *this + _Days; - return *this; - } - constexpr day& day::operator-=(const days& _Days) noexcept { - *this = *this - _Days; - return *this; - } - // month constexpr month::month(unsigned _Val) noexcept : _Month{static_cast(_Val)} {} From dc1cc2e6e945e3e247b65ec5eecbfb908e3c9337 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Tue, 14 Apr 2020 19:41:53 +0100 Subject: [PATCH 047/143] Move month and year --- stl/inc/chrono | 277 ++++++++++++++++++++++--------------------------- 1 file changed, 123 insertions(+), 154 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 7002f551886..e6a172c5a83 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -737,47 +737,147 @@ namespace chrono { public: month() = default; - constexpr explicit month(unsigned _Val) noexcept; + constexpr explicit month(unsigned _Val) noexcept : _Month{static_cast(_Val)} {} - constexpr month& operator++() noexcept; - constexpr month operator++(int) noexcept; - constexpr month& operator--() noexcept; - constexpr month operator--(int) noexcept; + constexpr month& operator++() noexcept { + *this += months{1}; + return *this; + } + constexpr month operator++(int) noexcept { + month _Temp{*this}; + ++(*this); + return _Temp; + } + constexpr month& operator--() noexcept { + *this -= months{1}; + return *this; + } + constexpr month operator--(int) noexcept { + month _Temp{*this}; + --(*this); + return _Temp; + } constexpr month& operator+=(const months& _Months) noexcept; constexpr month& operator-=(const months& _Months) noexcept; - _NODISCARD constexpr explicit operator unsigned() const noexcept; - _NODISCARD constexpr bool ok() const noexcept; + _NODISCARD constexpr explicit operator unsigned() const noexcept { + return static_cast(_Month); + } + _NODISCARD constexpr bool ok() const noexcept { + return _Month >= 1 && _Month <= 12; + } }; + constexpr bool operator==(const month& _Left, const month& _Right) noexcept { + return static_cast(_Left) == static_cast(_Right); + } + constexpr strong_ordering operator<=>(const month& _Left, const month& _Right) noexcept { + return static_cast(_Left) <=> static_cast(_Right); + } + + constexpr month operator+(const month& _Left, const months& _Right) noexcept { + const auto _M = static_cast(static_cast(_Left)) + (_Right.count() - 1); + const auto _Div = (_M >= 0 ? _M : _M - 11) / 12; + return month{static_cast(_M - _Div * 12 + 1)}; + } + constexpr month operator+(const months& _Left, const month& _Right) noexcept { + return _Right + _Left; + } + constexpr month operator-(const month& _Left, const months& _Right) noexcept { + return _Left + -_Right; + } + constexpr months operator-(const month& _Left, const month& _Right) noexcept { + const auto _M = static_cast(_Left) - static_cast(_Right); + return months{_M <= 11 ? _M : _M + 12}; + } + + constexpr month& month::operator+=(const months& _Months) noexcept { + *this = *this + _Months; + return *this; + } + constexpr month& month::operator-=(const months& _Months) noexcept { + *this = *this - _Months; + return *this; + } + class year { short _Year; public: year() = default; - constexpr explicit year(int _Val) noexcept; + constexpr explicit year(int _Val) noexcept : _Year{static_cast(_Val)} {} - constexpr year& operator++() noexcept; - constexpr year operator++(int) noexcept; - constexpr year& operator--() noexcept; - constexpr year operator--(int) noexcept; + constexpr year& operator++() noexcept { + ++_Year; + return *this; + } + constexpr year operator++(int) noexcept { + return year{_Year++}; + } + constexpr year& operator--() noexcept { + --_Year; + return *this; + } + constexpr year operator--(int) noexcept { + return year{_Year--}; + } - constexpr year& operator+=(const years& _Years) noexcept; - constexpr year& operator-=(const years& _Years) noexcept; + constexpr year& operator+=(const years& _Years) noexcept { + _Year += static_cast(_Years.count()); + return *this; + } + constexpr year& operator-=(const years& _Years) noexcept { + _Year -= static_cast(_Years.count()); + return *this; + } + + constexpr year operator+() const noexcept { + return *this; + } + constexpr year operator-() const noexcept { + return year{-_Year}; + } - constexpr year operator+() const noexcept; - constexpr year operator-() const noexcept; + _NODISCARD constexpr bool is_leap() const noexcept { + return _Year % 4 == 0 && (_Year % 100 != 0 || _Year % 400 == 0); + } - _NODISCARD constexpr bool is_leap() const noexcept; + _NODISCARD constexpr explicit operator int() const noexcept { + return static_cast(_Year); + } - _NODISCARD constexpr explicit operator int() const noexcept; + _NODISCARD constexpr bool ok() const noexcept { + return (min)()._Year <= _Year && _Year <= (max)()._Year; + } - _NODISCARD constexpr bool ok() const noexcept; + _NODISCARD static constexpr year(min)() noexcept { + return year{-32767}; + } + _NODISCARD static constexpr year(max)() noexcept { + return year{32767}; + } + }; - _NODISCARD static constexpr year(min)() noexcept; - _NODISCARD static constexpr year(max)() noexcept; - }; + constexpr bool operator==(const year& _Left, const year& _Right) noexcept { + return static_cast(_Left) == static_cast(_Right); + } + constexpr strong_ordering operator<=>(const year& _Left, const year& _Right) noexcept { + return static_cast(_Left) <=> static_cast(_Right); + } + + constexpr year operator+(const year& _Left, const years& _Right) noexcept { + return year{static_cast(_Left) + _Right.count()}; + } + constexpr year operator+(const years& _Left, const year& _Right) noexcept { + return _Right + _Left; + } + constexpr year operator-(const year& _Left, const years& _Right) noexcept { + return _Left + -_Right; + } + constexpr years operator-(const year& _Left, const year& _Right) noexcept { + return years{static_cast(_Left) - static_cast(_Right)}; + } class weekday { unsigned char _Weekday; @@ -1039,138 +1139,7 @@ namespace chrono { _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, const year& _Year) noexcept; _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, int _Year) noexcept; - // month - constexpr month::month(unsigned _Val) noexcept : _Month{static_cast(_Val)} {} - - constexpr month& month::operator++() noexcept { - *this += months{1}; - return *this; - } - constexpr month month::operator++(int) noexcept { - month _Temp{*this}; - ++(*this); - return _Temp; - } - constexpr month& month::operator--() noexcept { - *this -= months{1}; - return *this; - } - constexpr month month::operator--(int) noexcept { - month _Temp{*this}; - --(*this); - return _Temp; - } - constexpr month::operator unsigned() const noexcept { - return static_cast(_Month); - } - constexpr bool month::ok() const noexcept { - return _Month >= 1 && _Month <= 12; - } - - constexpr bool operator==(const month& _Left, const month& _Right) noexcept { - return static_cast(_Left) == static_cast(_Right); - } - constexpr strong_ordering operator<=>(const month& _Left, const month& _Right) noexcept { - return static_cast(_Left) <=> static_cast(_Right); - } - - constexpr month operator+(const month& _Left, const months& _Right) noexcept { - const auto _M = static_cast(static_cast(_Left)) + (_Right.count() - 1); - const auto _Div = (_M >= 0 ? _M : _M - 11) / 12; - return month{static_cast(_M - _Div * 12 + 1)}; - } - constexpr month operator+(const months& _Left, const month& _Right) noexcept { - return _Right + _Left; - } - constexpr month operator-(const month& _Left, const months& _Right) noexcept { - return _Left + -_Right; - } - constexpr months operator-(const month& _Left, const month& _Right) noexcept { - const auto _M = static_cast(_Left) - static_cast(_Right); - return months{_M <= 11 ? _M : _M + 12}; - } - - constexpr month& month::operator+=(const months& _Months) noexcept { - *this = *this + _Months; - return *this; - } - constexpr month& month::operator-=(const months& _Months) noexcept { - *this = *this - _Months; - return *this; - } - - // year - constexpr year::year(int _Val) noexcept : _Year{static_cast(_Val)} {} - - constexpr year& year::operator++() noexcept { - ++_Year; - return *this; - } - constexpr year year::operator++(int) noexcept { - return year{_Year++}; - } - constexpr year& year::operator--() noexcept { - --_Year; - return *this; - } - constexpr year year::operator--(int) noexcept { - return year{_Year--}; - } - - constexpr year year::operator+() const noexcept { - return *this; - } - constexpr year year::operator-() const noexcept { - return year{-_Year}; - } - - constexpr bool year::is_leap() const noexcept { - return _Year % 4 == 0 && (_Year % 100 != 0 || _Year % 400 == 0); - } - - constexpr year::operator int() const noexcept { - return static_cast(_Year); - } - constexpr bool year::ok() const noexcept { - return (min)()._Year <= _Year && _Year <= (max)()._Year; - } - - constexpr year(year::min)() noexcept { - return year{-32767}; - } - constexpr year(year::max)() noexcept { - return year{32767}; - } - - constexpr bool operator==(const year& _Left, const year& _Right) noexcept { - return static_cast(_Left) == static_cast(_Right); - } - constexpr strong_ordering operator<=>(const year& _Left, const year& _Right) noexcept { - return static_cast(_Left) <=> static_cast(_Right); - } - - constexpr year operator+(const year& _Left, const years& _Right) noexcept { - return year{static_cast(_Left) + _Right.count()}; - } - constexpr year operator+(const years& _Left, const year& _Right) noexcept { - return _Right + _Left; - } - constexpr year operator-(const year& _Left, const years& _Right) noexcept { - return _Left + -_Right; - } - constexpr years operator-(const year& _Left, const year& _Right) noexcept { - return years{static_cast(_Left) - static_cast(_Right)}; - } - - constexpr year& year::operator+=(const years& _Years) noexcept { - *this = *this + _Years; - return *this; - } - constexpr year& year::operator-=(const years& _Years) noexcept { - *this = *this - _Years; - return *this; - } - + // weekday // courtesy of Howard Hinnant // https://howardhinnant.github.io/date_algorithms.html#weekday_from_days From 3997cbee93da576faa013bebfadc63f87994c19a Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Tue, 14 Apr 2020 19:50:41 +0100 Subject: [PATCH 048/143] Move weekday_* --- stl/inc/chrono | 230 ++++++++++++++++++++++--------------------------- 1 file changed, 102 insertions(+), 128 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index e6a172c5a83..525149f3e2b 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -679,7 +679,7 @@ namespace chrono { public: day() = default; constexpr explicit day(unsigned _Val) noexcept : _Day{static_cast(_Val)} {} - + constexpr day& operator++() noexcept { ++_Day; return *this; @@ -857,7 +857,7 @@ namespace chrono { _NODISCARD static constexpr year(max)() noexcept { return year{32767}; } - }; + }; constexpr bool operator==(const year& _Left, const year& _Right) noexcept { return static_cast(_Left) == static_cast(_Right); @@ -881,53 +881,134 @@ namespace chrono { class weekday { unsigned char _Weekday; - _NODISCARD static constexpr unsigned _Weekday_from_days(int _Tp) noexcept; + + // courtesy of Howard Hinnant + // https://howardhinnant.github.io/date_algorithms.html#weekday_from_days + _NODISCARD static constexpr unsigned _Weekday_from_days(int _Tp) noexcept { + return static_cast(_Tp >= -4 ? (_Tp + 4) % 7 : (_Tp + 5) % 7 + 6); + } public: weekday() = default; - constexpr explicit weekday(unsigned _Val) noexcept; - constexpr weekday(const sys_days& _Sys_day) noexcept; - constexpr explicit weekday(const local_days& _Local_day) noexcept; - - constexpr weekday& operator++() noexcept; - constexpr weekday operator++(int) noexcept; - constexpr weekday& operator--() noexcept; - constexpr weekday operator--(int) noexcept; + constexpr explicit weekday(unsigned _Val) noexcept + : _Weekday{static_cast(_Val == 7 ? 0 : _Val)} {} + constexpr weekday(const sys_days& _Sys_day) noexcept + : _Weekday{static_cast(_Weekday_from_days(_Sys_day.time_since_epoch().count()))} {} + constexpr explicit weekday(const local_days& _Local_day) noexcept + : _Weekday{static_cast(_Weekday_from_days(_Local_day.time_since_epoch().count()))} {} + + constexpr weekday& operator++() noexcept { + return *this += days{1}; + } + constexpr weekday operator++(int) noexcept { + weekday _Temp{*this}; + ++(*this); + return _Temp; + } + constexpr weekday& operator--() noexcept { + return *this -= days{1}; + } + constexpr weekday operator--(int) noexcept { + weekday _Temp{*this}; + --(*this); + return _Temp; + } constexpr weekday& operator+=(const days& _Days) noexcept; constexpr weekday& operator-=(const days& _Days) noexcept; - _NODISCARD constexpr unsigned c_encoding() const noexcept; - _NODISCARD constexpr unsigned iso_encoding() const noexcept; - _NODISCARD constexpr bool ok() const noexcept; + _NODISCARD constexpr unsigned c_encoding() const noexcept { + return _Weekday; + } + _NODISCARD constexpr unsigned iso_encoding() const noexcept { + return _Weekday == 0u ? 7u : _Weekday; + } + _NODISCARD constexpr bool ok() const noexcept { + return _Weekday <= 6; + } _NODISCARD constexpr class weekday_indexed operator[](unsigned _Index) const noexcept; _NODISCARD constexpr class weekday_last operator[](last_spec) const noexcept; }; + constexpr bool operator==(const weekday& _Left, const weekday& _Right) noexcept { + return _Left.c_encoding() == _Right.c_encoding(); + } + + constexpr weekday operator+(const weekday& _Left, const days& _Right) noexcept { + const auto _Wd = static_cast(_Left.c_encoding()) + _Right.count(); + const auto _Div = (_Wd >= 0 ? _Wd : _Wd - 6) / 7; + return weekday{static_cast(_Wd - _Div * 7)}; + } + constexpr weekday operator+(const days& _Left, const weekday& _Right) noexcept { + return _Right + _Left; + } + constexpr weekday operator-(const weekday& _Left, const days& _Right) noexcept { + return _Left + -_Right; + } + constexpr days operator-(const weekday& _Left, const weekday& _Right) noexcept { + const auto _Wd = _Left.c_encoding() - _Right.c_encoding(); + const auto _Wk = _Wd <= 6 ? _Wd : _Wd + 7; + return days{_Wk}; + } + + constexpr weekday& weekday::operator+=(const days& _Days) noexcept { + return *this = *this + _Days; + } + constexpr weekday& weekday::operator-=(const days& _Days) noexcept { + return *this = *this - _Days; + } + class weekday_indexed { chrono::weekday _Weekday; unsigned char _Index; public: weekday_indexed() = default; - constexpr weekday_indexed(const chrono::weekday& _Wd, unsigned _Idx) noexcept; + constexpr weekday_indexed(const chrono::weekday& _Wd, unsigned _Idx) noexcept + : _Weekday{_Wd}, _Index{static_cast(_Idx)} {} - _NODISCARD constexpr chrono::weekday weekday() const noexcept; - _NODISCARD constexpr unsigned index() const noexcept; - _NODISCARD constexpr bool ok() const noexcept; + _NODISCARD constexpr chrono::weekday weekday() const noexcept { + return _Weekday; + } + _NODISCARD constexpr unsigned index() const noexcept { + return _Index; + } + _NODISCARD constexpr bool ok() const noexcept { + return _Weekday.ok() && 1 <= _Index && _Index <= 5; + } }; + constexpr bool operator==(const weekday_indexed& _Left, const weekday_indexed& _Right) noexcept { + return _Left.weekday() == _Right.weekday() && _Left.index() == _Right.index(); + } + class weekday_last { chrono::weekday _Weekday; public: - constexpr explicit weekday_last(const chrono::weekday& _Wd) noexcept; + constexpr explicit weekday_last(const chrono::weekday& _Wd) noexcept : _Weekday{_Wd} {} - _NODISCARD constexpr chrono::weekday weekday() const noexcept; - _NODISCARD constexpr bool ok() const noexcept; + _NODISCARD constexpr chrono::weekday weekday() const noexcept { + return _Weekday; + } + _NODISCARD constexpr bool ok() const noexcept { + return _Weekday.ok(); + } }; + constexpr bool operator==(const weekday_last& _Left, const weekday_last& _Right) noexcept { + return _Left.weekday() == _Right.weekday(); + } + + // weekday + constexpr weekday_indexed weekday::operator[](unsigned _Index) const noexcept { + return {*this, _Index}; + } + constexpr weekday_last weekday::operator[](last_spec) const noexcept { + return weekday_last{*this}; + } + class month_day { chrono::month _Month; chrono::day _Day; @@ -1139,113 +1220,6 @@ namespace chrono { _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, const year& _Year) noexcept; _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, int _Year) noexcept; - - // weekday - // courtesy of Howard Hinnant - // https://howardhinnant.github.io/date_algorithms.html#weekday_from_days - constexpr unsigned weekday::_Weekday_from_days(int _Tp) noexcept { - return static_cast(_Tp >= -4 ? (_Tp + 4) % 7 : (_Tp + 5) % 7 + 6); - } - constexpr weekday::weekday(unsigned _Val) noexcept : _Weekday{static_cast(_Val == 7 ? 0 : _Val)} {} - constexpr weekday::weekday(const sys_days& _Sys_day) noexcept - : _Weekday{static_cast(_Weekday_from_days(_Sys_day.time_since_epoch().count()))} {} - constexpr weekday::weekday(const local_days& _Local_day) noexcept - : _Weekday{static_cast(_Weekday_from_days(_Local_day.time_since_epoch().count()))} {} - - - constexpr unsigned weekday::c_encoding() const noexcept { - return _Weekday; - } - constexpr unsigned weekday::iso_encoding() const noexcept { - return _Weekday == 0u ? 7u : _Weekday; - } - constexpr bool weekday::ok() const noexcept { - return _Weekday <= 6; - } - - constexpr weekday_indexed weekday::operator[](unsigned _Index) const noexcept { - return {*this, _Index}; - } - constexpr weekday_last weekday::operator[](last_spec) const noexcept { - return weekday_last{*this}; - } - - constexpr bool operator==(const weekday& _Left, const weekday& _Right) noexcept { - return _Left.c_encoding() == _Right.c_encoding(); - } - - constexpr weekday operator+(const weekday& _Left, const days& _Right) noexcept { - const auto _Wd = static_cast(_Left.c_encoding()) + _Right.count(); - const auto _Div = (_Wd >= 0 ? _Wd : _Wd - 6) / 7; - return weekday{static_cast(_Wd - _Div * 7)}; - } - constexpr weekday operator+(const days& _Left, const weekday& _Right) noexcept { - return _Right + _Left; - } - constexpr weekday operator-(const weekday& _Left, const days& _Right) noexcept { - return _Left + -_Right; - } - constexpr days operator-(const weekday& _Left, const weekday& _Right) noexcept { - const auto _Wd = _Left.c_encoding() - _Right.c_encoding(); - const auto _Wk = _Wd <= 6 ? _Wd : _Wd + 7; - return days{_Wk}; - } - - constexpr weekday& weekday::operator++() noexcept { - return *this += days{1}; - } - constexpr weekday weekday::operator++(int) noexcept { - weekday _Temp{*this}; - ++(*this); - return _Temp; - } - constexpr weekday& weekday::operator--() noexcept { - return *this -= days{1}; - } - constexpr weekday weekday::operator--(int) noexcept { - weekday _Temp{*this}; - --(*this); - return _Temp; - } - - constexpr weekday& weekday::operator+=(const days& _Days) noexcept { - return *this = *this + _Days; - } - constexpr weekday& weekday::operator-=(const days& _Days) noexcept { - return *this = *this - _Days; - } - - // weekday_indexed - constexpr weekday_indexed::weekday_indexed(const chrono::weekday& _Wd, unsigned _Idx) noexcept - : _Weekday{_Wd}, _Index{static_cast(_Idx)} {} - - constexpr chrono::weekday weekday_indexed::weekday() const noexcept { - return _Weekday; - } - constexpr unsigned weekday_indexed::index() const noexcept { - return _Index; - } - constexpr bool weekday_indexed::ok() const noexcept { - return _Weekday.ok() && 1 <= _Index && _Index <= 5; - } - constexpr bool operator==(const weekday_indexed& _Left, const weekday_indexed& _Right) noexcept { - return _Left.weekday() == _Right.weekday() && _Left.index() == _Right.index(); - } - - // weekday_last - constexpr weekday_last::weekday_last(const chrono::weekday& _Wd) noexcept : _Weekday{_Wd} {} - - constexpr chrono::weekday weekday_last::weekday() const noexcept { - return _Weekday; - } - constexpr bool weekday_last::ok() const noexcept { - return _Weekday.ok(); - } - - constexpr bool operator==(const weekday_last& _Left, const weekday_last& _Right) noexcept { - return _Left.weekday() == _Right.weekday(); - } - // month_day constexpr month_day::month_day(const chrono::month& _M, const chrono::day& _D) noexcept : _Month{_M}, _Day{_D} {} From 92ed0d59153fe3379151f643a69a9adf62e1af30 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Tue, 14 Apr 2020 20:01:53 +0100 Subject: [PATCH 049/143] Move month_* --- stl/inc/chrono | 170 +++++++++++++++++++++---------------------------- 1 file changed, 71 insertions(+), 99 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 525149f3e2b..ddec3a12fab 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1015,48 +1015,104 @@ namespace chrono { public: month_day() = default; - constexpr month_day(const chrono::month& _M, const chrono::day& _D) noexcept; + constexpr month_day(const chrono::month& _M, const chrono::day& _D) noexcept : _Month{_M}, _Day{_D} {} - _NODISCARD constexpr chrono::month month() const noexcept; - _NODISCARD constexpr chrono::day day() const noexcept; - _NODISCARD constexpr bool ok() const noexcept; + _NODISCARD constexpr chrono::month month() const noexcept { + return _Month; + } + _NODISCARD constexpr chrono::day day() const noexcept { + return _Day; + } + _NODISCARD constexpr bool ok() const noexcept { + if (!_Month.ok() || !_Day.ok()) + return false; + const auto _D = static_cast(_Day); + const auto _M = static_cast(_Month); + if (_M == 2 && _D > 29) + return false; + if (_M == 4 || _M == 6 || _M == 9 || _M == 11) + return _D <= 30; + return true; + } }; + constexpr bool operator==(const month_day& _Left, const month_day& _Right) noexcept { + return _Left.month() == _Right.month() && _Left.day() == _Right.day(); + } + constexpr strong_ordering operator<=>(const month_day& _Left, const month_day& _Right) noexcept { + if (auto _Comp = _Left.month() <=> _Right.month(); _Comp != 0) + return _Comp; + return _Left.day() <=> _Right.day(); + } + class month_day_last { chrono::month _Month; public: - constexpr explicit month_day_last(const chrono::month& _M) noexcept; + constexpr explicit month_day_last(const chrono::month& _M) noexcept : _Month{_M} {} - _NODISCARD constexpr chrono::month month() const noexcept; - _NODISCARD constexpr bool ok() const noexcept; + _NODISCARD constexpr chrono::month month() const noexcept { + return _Month; + } + _NODISCARD constexpr bool ok() const noexcept { + return _Month.ok(); + } }; + constexpr bool operator==(const month_day_last& _Left, const month_day_last& _Right) { + return _Left.month() == _Right.month(); + } + constexpr strong_ordering operator<=>(const month_day_last& _Left, const month_day_last& _Right) { + return _Left.month() <=> _Right.month(); + } + class month_weekday { chrono::month _Month; chrono::weekday_indexed _Weekday_index; public: - constexpr month_weekday(const chrono::month& _M, const chrono::weekday_indexed& _Wdi) noexcept; + constexpr month_weekday(const chrono::month& _M, const chrono::weekday_indexed& _Wdi) noexcept + : _Month{_M}, _Weekday_index{_Wdi} {} - _NODISCARD constexpr chrono::month month() const noexcept; - _NODISCARD constexpr chrono::weekday_indexed weekday_indexed() const noexcept; + _NODISCARD constexpr chrono::month month() const noexcept { + return _Month; + } + _NODISCARD constexpr chrono::weekday_indexed weekday_indexed() const noexcept { + return _Weekday_index; + } - _NODISCARD constexpr bool ok() const noexcept; + _NODISCARD constexpr bool ok() const noexcept { + return _Month.ok() && _Weekday_index.ok(); + } }; + constexpr bool operator==(const month_weekday& _Left, const month_weekday& _Right) { + return _Left.month() == _Right.month() && _Left.weekday_indexed() == _Right.weekday_indexed(); + } + class month_weekday_last { chrono::month _Month; chrono::weekday_last _Weekday_last; public: - constexpr month_weekday_last(const chrono::month& _M, const chrono::weekday_last& _Wdl) noexcept; + constexpr month_weekday_last(const chrono::month& _M, const chrono::weekday_last& _Wdl) noexcept + : _Month{_M}, _Weekday_last{_Wdl} {} - _NODISCARD constexpr chrono::month month() const noexcept; - _NODISCARD constexpr chrono::weekday_last weekday_last() const noexcept; - _NODISCARD constexpr bool ok() const noexcept; + _NODISCARD constexpr chrono::month month() const noexcept { + return _Month; + } + _NODISCARD constexpr chrono::weekday_last weekday_last() const noexcept { + return _Weekday_last; + } + _NODISCARD constexpr bool ok() const noexcept { + return _Month.ok() && _Weekday_last.ok(); + } }; + constexpr bool operator==(const month_weekday_last& _Left, const month_weekday_last& _Right) noexcept { + return _Left.month() == _Right.month() && _Left.weekday_last() == _Right.weekday_last(); + } + class year_month { chrono::year _Year; chrono::month _Month; @@ -1220,90 +1276,6 @@ namespace chrono { _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, const year& _Year) noexcept; _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, int _Year) noexcept; - // month_day - constexpr month_day::month_day(const chrono::month& _M, const chrono::day& _D) noexcept : _Month{_M}, _Day{_D} {} - - constexpr chrono::month month_day::month() const noexcept { - return _Month; - } - constexpr chrono::day month_day::day() const noexcept { - return _Day; - } - constexpr bool month_day::ok() const noexcept { - if (!_Month.ok() || !_Day.ok()) - return false; - const auto _D = static_cast(_Day); - const auto _M = static_cast(_Month); - if (_M == 2 && _D > 29) - return false; - if (_M == 4 || _M == 6 || _M == 9 || _M == 11) - return _D <= 30; - return true; - } - - constexpr bool operator==(const month_day& _Left, const month_day& _Right) noexcept { - return _Left.month() == _Right.month() && _Left.day() == _Right.day(); - } - constexpr strong_ordering operator<=>(const month_day& _Left, const month_day& _Right) noexcept { - if (auto _Comp = _Left.month() <=> _Right.month(); _Comp != 0) - return _Comp; - return _Left.day() <=> _Right.day(); - } - - // month_day_last - constexpr month_day_last::month_day_last(const chrono::month& _M) noexcept : _Month{_M} {} - - constexpr chrono::month month_day_last::month() const noexcept { - return _Month; - } - constexpr bool month_day_last::ok() const noexcept { - return _Month.ok(); - } - - constexpr bool operator==(const month_day_last& _Left, const month_day_last& _Right) { - return _Left.month() == _Right.month(); - } - constexpr strong_ordering operator<=>(const month_day_last& _Left, const month_day_last& _Right) { - return _Left.month() <=> _Right.month(); - } - - // month_weekday - constexpr month_weekday::month_weekday(const chrono::month& _M, const chrono::weekday_indexed& _Wdi) noexcept - : _Month{_M}, _Weekday_index{_Wdi} {} - - constexpr chrono::month month_weekday::month() const noexcept { - return _Month; - } - constexpr chrono::weekday_indexed month_weekday::weekday_indexed() const noexcept { - return _Weekday_index; - } - - constexpr bool month_weekday::ok() const noexcept { - return _Month.ok() && _Weekday_index.ok(); - } - - constexpr bool operator==(const month_weekday& _Left, const month_weekday& _Right) { - return _Left.month() == _Right.month() && _Left.weekday_indexed() == _Right.weekday_indexed(); - } - - // month_weekday_last - constexpr month_weekday_last::month_weekday_last(const chrono::month& _M, const chrono::weekday_last& _Wdl) noexcept - : _Month{_M}, _Weekday_last{_Wdl} {} - - constexpr chrono::month month_weekday_last::month() const noexcept { - return _Month; - } - constexpr chrono::weekday_last month_weekday_last::weekday_last() const noexcept { - return _Weekday_last; - } - constexpr bool month_weekday_last::ok() const noexcept { - return _Month.ok() && _Weekday_last.ok(); - } - - constexpr bool operator==(const month_weekday_last& _Left, const month_weekday_last& _Right) noexcept { - return _Left.month() == _Right.month() && _Left.weekday_last() == _Right.weekday_last(); - } - // year_month constexpr year_month::year_month(const chrono::year& _Y, const chrono::month& _M) noexcept : _Year{_Y}, _Month{_M} {} From caf2bf4365ed0b0e4127a2a19b1a6d1c513bf655 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Wed, 15 Apr 2020 14:11:46 +0100 Subject: [PATCH 050/143] Move year_month --- stl/inc/chrono | 143 +++++++++++++++++++++++-------------------------- 1 file changed, 67 insertions(+), 76 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index ddec3a12fab..25137b139bf 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1119,19 +1119,82 @@ namespace chrono { public: year_month() = default; - constexpr year_month(const chrono::year& _Y, const chrono::month& _M) noexcept; + constexpr year_month(const chrono::year& _Y, const chrono::month& _M) noexcept : _Year{_Y}, _Month{_M} {} - _NODISCARD constexpr chrono::year year() const noexcept; - _NODISCARD constexpr chrono::month month() const noexcept; + _NODISCARD constexpr chrono::year year() const noexcept { + return _Year; + } + _NODISCARD constexpr chrono::month month() const noexcept { + return _Month; + } constexpr year_month& operator+=(const months& _Months) noexcept; constexpr year_month& operator-=(const months& _Months) noexcept; constexpr year_month& operator+=(const years& _Years) noexcept; constexpr year_month& operator-=(const years& _Years) noexcept; - _NODISCARD constexpr bool ok() const noexcept; + _NODISCARD constexpr bool ok() const noexcept { + return _Year.ok() && _Month.ok(); + } }; + constexpr bool operator==(const year_month& _Left, const year_month& _Right) noexcept { + return _Left.year() == _Right.year() && _Left.month() == _Right.month(); + } + constexpr strong_ordering operator<=>(const year_month& _Left, const year_month& _Right) noexcept { + if (auto _Comp = _Left.year() <=> _Right.year(); _Comp != 0) + return _Comp; + return _Left.month() <=> _Right.month(); + } + + constexpr year_month operator+(const year_month& _Left, const months& _Right) noexcept { + const auto _M = static_cast(static_cast(_Left.month())) + (_Right.count() - 1); + const auto _Div = (_M >= 0 ? _M : _M - 11) / 12; + return year_month{_Left.year() + years{_Div}, month{static_cast(_M - _Div * 12 + 1)}}; + } + constexpr year_month operator+(const months& _Left, const year_month& _Right) noexcept { + return _Right + _Left; + } + + constexpr year_month operator-(const year_month& _Left, const months& _Right) noexcept { + return _Left + -_Right; + } + + constexpr months operator-(const year_month& _Left, const year_month& _Right) noexcept { + return _Left.year() - _Right.year() + + months{static_cast(static_cast(_Left.month())) + - static_cast(static_cast(_Right.month()))}; + } + + constexpr year_month operator+(const year_month& _Left, const years& _Right) noexcept { + return {year{_Left.year() + _Right}, _Left.month()}; + } + + constexpr year_month operator+(const years& _Left, const year_month& _Right) noexcept { + return _Right + _Left; + } + + constexpr year_month operator-(const year_month& _Left, const years& _Right) noexcept { + return _Left + -_Right; + } + + constexpr year_month& year_month::operator+=(const months& _Months) noexcept { + *this = *this + _Months; + return *this; + } + constexpr year_month& year_month::operator-=(const months& _Months) noexcept { + *this = *this - _Months; + return *this; + } + constexpr year_month& year_month::operator+=(const years& _Years) noexcept { + *this = *this + _Years; + return *this; + } + constexpr year_month& year_month::operator-=(const years& _Years) noexcept { + *this = *this - _Years; + return *this; + } + class year_month_day { chrono::year _Year; chrono::month _Month; @@ -1276,78 +1339,6 @@ namespace chrono { _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, const year& _Year) noexcept; _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, int _Year) noexcept; - // year_month - constexpr year_month::year_month(const chrono::year& _Y, const chrono::month& _M) noexcept - : _Year{_Y}, _Month{_M} {} - - constexpr chrono::year year_month::year() const noexcept { - return _Year; - } - constexpr chrono::month year_month::month() const noexcept { - return _Month; - } - - constexpr bool year_month::ok() const noexcept { - return _Year.ok() && _Month.ok(); - } - - constexpr bool operator==(const year_month& _Left, const year_month& _Right) noexcept { - return _Left.year() == _Right.year() && _Left.month() == _Right.month(); - } - constexpr strong_ordering operator<=>(const year_month& _Left, const year_month& _Right) noexcept { - if (auto _Comp = _Left.year() <=> _Right.year(); _Comp != 0) - return _Comp; - return _Left.month() <=> _Right.month(); - } - - constexpr year_month operator+(const year_month& _Left, const months& _Right) noexcept { - const auto _M = static_cast(static_cast(_Left.month())) + (_Right.count() - 1); - const auto _Div = (_M >= 0 ? _M : _M - 11) / 12; - return year_month{_Left.year() + years{_Div}, month{static_cast(_M - _Div * 12 + 1)}}; - } - constexpr year_month operator+(const months& _Left, const year_month& _Right) noexcept { - return _Right + _Left; - } - - constexpr year_month operator-(const year_month& _Left, const months& _Right) noexcept { - return _Left + -_Right; - } - - constexpr months operator-(const year_month& _Left, const year_month& _Right) noexcept { - return _Left.year() - _Right.year() - + months{static_cast(static_cast(_Left.month())) - - static_cast(static_cast(_Right.month()))}; - } - - constexpr year_month operator+(const year_month& _Left, const years& _Right) noexcept { - return (_Left.year() + _Right) / _Left.month(); - } - - constexpr year_month operator+(const years& _Left, const year_month& _Right) noexcept { - return _Right + _Left; - } - - constexpr year_month operator-(const year_month& _Left, const years& _Right) noexcept { - return _Left + -_Right; - } - - constexpr year_month& year_month::operator+=(const months& _Months) noexcept { - *this = *this + _Months; - return *this; - } - constexpr year_month& year_month::operator-=(const months& _Months) noexcept { - *this = *this - _Months; - return *this; - } - constexpr year_month& year_month::operator+=(const years& _Years) noexcept { - *this = *this + _Years; - return *this; - } - constexpr year_month& year_month::operator-=(const years& _Years) noexcept { - *this = *this - _Years; - return *this; - } - // year_month_day // Thanks again to Howard https://howardhinnant.github.io/date_algorithms.html#civil_from_days constexpr year_month_day year_month_day::_Civil_from_days(int _Tp) noexcept { From 8ec02ed5f34b148150e8eefc9fde679eb0d43823 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Wed, 15 Apr 2020 14:40:37 +0100 Subject: [PATCH 051/143] Move year_month_day --- stl/inc/chrono | 238 ++++++++++++++++++++++++------------------------- 1 file changed, 115 insertions(+), 123 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 25137b139bf..b6fe6b358ac 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1195,34 +1195,134 @@ namespace chrono { return *this; } + constexpr inline day _Last_day(const year& _Year, const month& _Month) { + constexpr day _Days[] = { + day{31}, day{28}, day{31}, day{30}, day{31}, day{30}, day{31}, day{31}, day{30}, day{31}, day{30}, day{31}}; + return _Month == month{2} && _Year.is_leap() ? _Days[static_cast(_Month) - 1] + days{1} + : _Days[static_cast(_Month) - 1]; + } class year_month_day { chrono::year _Year; chrono::month _Month; chrono::day _Day; - _NODISCARD static constexpr year_month_day _Civil_from_days(int _Tp) noexcept; - _NODISCARD constexpr days _Days_from_civil() const noexcept; + _NODISCARD static constexpr year_month_day _Civil_from_days(int _Tp) noexcept { + static_assert(_STD numeric_limits::digits >= 18); + static_assert(_STD numeric_limits::digits >= 20); + const int _Z = _Tp + 719468; + const int _Era = (_Z >= 0 ? _Z : _Z - 146096) / 146097; + const unsigned _Doe = static_cast(_Z - _Era * 146097); + const unsigned _Yoe = (_Doe - _Doe / 1460 + _Doe / 36524 - _Doe / 146096) / 365; + const int _Y = static_cast(_Yoe) + _Era * 400; + const unsigned _Doy = _Doe - (365 * _Yoe + _Yoe / 4 - _Yoe / 100); + const unsigned _Mp = (5 * _Doy + 2) / 153; + const unsigned _D = _Doy - (153 * _Mp + 2) / 5 + 1; + const unsigned _M = _Mp + (_Mp < 10 ? 3 : static_cast(-9)); + return year_month_day(chrono::year{_Y + (_M <= 2)}, chrono::month{_M}, chrono::day{_D}); + } + _NODISCARD constexpr days _Days_from_civil() const noexcept { + static_assert(_STD numeric_limits::digits >= 18); + static_assert(_STD numeric_limits::digits >= 20); + const int _Y = static_cast(_Year) - (_Month <= chrono::month{2}); + const unsigned _M = static_cast(_Month); + const int _Era = (_Y >= 0 ? _Y : _Y - 399) / 400; + const unsigned _Yoe = static_cast(_Y - _Era * 400); + const unsigned _Doy = + (153 * (_M + (_M > 2 ? static_cast(-3) : 9)) + 2) / 5 + static_cast(_Day) - 1; + const unsigned _Doe = _Yoe * 365 + _Yoe / 4 - _Yoe / 100 + _Doy; + return days{_Era * 146097 + static_cast(_Doe) - 719468}; + } public: year_month_day() = default; - constexpr year_month_day(const chrono::year& _Y, const chrono::month& _M, const chrono::day& _D) noexcept; + constexpr year_month_day(const chrono::year& _Y, const chrono::month& _M, const chrono::day& _D) noexcept + : _Year{_Y}, _Month{_M}, _Day{_D} {} constexpr year_month_day(const class year_month_day_last& _Ymdl) noexcept; - constexpr year_month_day(const sys_days& _Sys_days) noexcept; - constexpr explicit year_month_day(const local_days& _Local_days) noexcept; + constexpr year_month_day(const sys_days& _Sys_days) noexcept + : year_month_day{_Civil_from_days(_Sys_days.time_since_epoch().count())} {} + constexpr explicit year_month_day(const local_days& _Local_days) noexcept + : year_month_day{_Civil_from_days(_Local_days.time_since_epoch().count())} {} constexpr year_month_day& operator+=(const months& _Months) noexcept; constexpr year_month_day& operator-=(const months& _Months) noexcept; constexpr year_month_day& operator+=(const years& _Years) noexcept; constexpr year_month_day& operator-=(const years& _Years) noexcept; - _NODISCARD constexpr chrono::year year() const noexcept; - _NODISCARD constexpr chrono::month month() const noexcept; - _NODISCARD constexpr chrono::day day() const noexcept; + _NODISCARD constexpr chrono::year year() const noexcept { + return _Year; + } + _NODISCARD constexpr chrono::month month() const noexcept { + return _Month; + } + _NODISCARD constexpr chrono::day day() const noexcept { + return _Day; + } - _NODISCARD constexpr operator sys_days() const noexcept; - _NODISCARD constexpr explicit operator local_days() const noexcept; - _NODISCARD constexpr bool ok() const noexcept; + _NODISCARD constexpr operator sys_days() const noexcept { + return sys_days{_Days_from_civil()}; + } + _NODISCARD constexpr explicit operator local_days() const noexcept { + return chrono::local_days{static_cast(*this).time_since_epoch()}; + } + _NODISCARD constexpr bool ok() const noexcept { + if (!_Year.ok() || !_Month.ok()) + return false; + return _Day >= chrono::day{1} && _Day <= _Last_day(_Year, _Month); + } }; + constexpr bool operator==(const year_month_day& _Left, const year_month_day& _Right) noexcept { + return _Left.year() == _Right.year() && _Left.month() == _Right.month() && _Left.day() == _Right.day(); + } + constexpr strong_ordering operator<=>(const year_month_day& _Left, const year_month_day& _Right) noexcept { + if (auto _Comp = _Left.year() <=> _Right.year(); _Comp != 0) + return _Comp; + if (auto _Comp = _Left.month() <=> _Right.month(); _Comp != 0) + return _Comp; + return _Left.day() <=> _Right.day(); + } + + constexpr year_month_day operator+(const year_month_day& _Left, const months& _Right) noexcept { + const auto _Ym = year_month{_Left.year(), _Left.month()} + _Right; + return {_Ym.year(), _Ym.month(), _Left.day()}; + } + + constexpr year_month_day operator+(const months& _Left, const year_month_day& _Right) noexcept { + return _Right + _Left; + } + + constexpr year_month_day operator-(const year_month_day& _Left, const months& _Right) noexcept { + return _Left + (-_Right); + } + + constexpr year_month_day operator+(const year_month_day& _Left, const years& _Right) noexcept { + return {_Left.year() + _Right, _Left.month(), _Left.day()}; + } + + constexpr year_month_day operator+(const years& _Left, const year_month_day& _Right) noexcept { + return _Right + _Left; + } + + constexpr year_month_day operator-(const year_month_day& _Left, const years& _Right) noexcept { + return _Left + (-_Right); + } + + constexpr year_month_day& year_month_day::operator+=(const months& _Months) noexcept { + *this = *this + _Months; + return *this; + } + constexpr year_month_day& year_month_day::operator-=(const months& _Months) noexcept { + *this = *this - _Months; + return *this; + } + constexpr year_month_day& year_month_day::operator+=(const years& _Years) noexcept { + *this = *this + _Years; + return *this; + } + constexpr year_month_day& year_month_day::operator-=(const years& _Years) noexcept { + *this = *this - _Years; + return *this; + } + class year_month_day_last { chrono::year _Year; chrono::month_day_last _Month_day_last; @@ -1245,6 +1345,10 @@ namespace chrono { _NODISCARD constexpr bool ok() const noexcept; }; + // year + constexpr year_month_day::year_month_day(const year_month_day_last& _Ymdl) noexcept + : _Year{_Ymdl.year()}, _Month{_Ymdl.month()}, _Day{_Ymdl.day()} {} + class year_month_weekday { chrono::year _Year; chrono::month _Month; @@ -1339,118 +1443,6 @@ namespace chrono { _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, const year& _Year) noexcept; _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, int _Year) noexcept; - // year_month_day - // Thanks again to Howard https://howardhinnant.github.io/date_algorithms.html#civil_from_days - constexpr year_month_day year_month_day::_Civil_from_days(int _Tp) noexcept { - static_assert(_STD numeric_limits::digits >= 18); - static_assert(_STD numeric_limits::digits >= 20); - const int _Z = _Tp + 719468; - const int _Era = (_Z >= 0 ? _Z : _Z - 146096) / 146097; - const unsigned _Doe = static_cast(_Z - _Era * 146097); - const unsigned _Yoe = (_Doe - _Doe / 1460 + _Doe / 36524 - _Doe / 146096) / 365; - const int _Y = static_cast(_Yoe) + _Era * 400; - const unsigned _Doy = _Doe - (365 * _Yoe + _Yoe / 4 - _Yoe / 100); - const unsigned _Mp = (5 * _Doy + 2) / 153; - const unsigned _D = _Doy - (153 * _Mp + 2) / 5 + 1; - const unsigned _M = _Mp + (_Mp < 10 ? 3 : static_cast(-9)); - return year_month_day(chrono::year{_Y + (_M <= 2)}, chrono::month{_M}, chrono::day{_D}); - } - constexpr days year_month_day::_Days_from_civil() const noexcept { - static_assert(_STD numeric_limits::digits >= 18); - static_assert(_STD numeric_limits::digits >= 20); - const int _Y = static_cast(_Year) - (_Month <= chrono::month{2}); - const unsigned _M = static_cast(_Month); - const int _Era = (_Y >= 0 ? _Y : _Y - 399) / 400; - const unsigned _Yoe = static_cast(_Y - _Era * 400); - const unsigned _Doy = - (153 * (_M + (_M > 2 ? static_cast(-3) : 9)) + 2) / 5 + static_cast(_Day) - 1; - const unsigned _Doe = _Yoe * 365 + _Yoe / 4 - _Yoe / 100 + _Doy; - return days{_Era * 146097 + static_cast(_Doe) - 719468}; - } - - constexpr year_month_day::year_month_day( - const chrono::year& _Y, const chrono::month& _M, const chrono::day& _D) noexcept - : _Year{_Y}, _Month{_M}, _Day{_D} {} - constexpr year_month_day::year_month_day(const year_month_day_last& _Ymdl) noexcept - : _Year{_Ymdl.year()}, _Month{_Ymdl.month()}, _Day{_Ymdl.day()} {} - constexpr year_month_day::year_month_day(const sys_days& _Sys_days) noexcept - : year_month_day{_Civil_from_days(_Sys_days.time_since_epoch().count())} {} - constexpr year_month_day::year_month_day(const local_days& _Local_days) noexcept - : year_month_day{_Civil_from_days(_Local_days.time_since_epoch().count())} {} - - constexpr chrono::year year_month_day::year() const noexcept { - return _Year; - } - constexpr chrono::month year_month_day::month() const noexcept { - return _Month; - } - constexpr chrono::day year_month_day::day() const noexcept { - return _Day; - } - - constexpr year_month_day::operator sys_days() const noexcept { - return sys_days{_Days_from_civil()}; - } - constexpr year_month_day::operator local_days() const noexcept { - return _STD chrono::local_days{static_cast(*this).time_since_epoch()}; - } - constexpr bool year_month_day::ok() const noexcept { - if (!_Year.ok() || !_Month.ok()) - return false; - return _Day >= chrono::day{1} && _Day <= (_Year / _Month / last).day(); - } - - constexpr bool operator==(const year_month_day& _Left, const year_month_day& _Right) noexcept { - return _Left.year() == _Right.year() && _Left.month() == _Right.month() && _Left.day() == _Right.day(); - } - constexpr strong_ordering operator<=>(const year_month_day& _Left, const year_month_day& _Right) noexcept { - if (auto _Comp = _Left.year() <=> _Right.year(); _Comp != 0) - return _Comp; - if (auto _Comp = _Left.month() <=> _Right.month(); _Comp != 0) - return _Comp; - return _Left.day() <=> _Right.day(); - } - - constexpr year_month_day operator+(const year_month_day& _Left, const months& _Right) noexcept { - return year_month{_Left.year() / _Left.month() + _Right} / _Left.day(); - } - - constexpr year_month_day operator+(const months& _Left, const year_month_day& _Right) noexcept { - return _Right + _Left; - } - - constexpr year_month_day operator-(const year_month_day& _Left, const months& _Right) noexcept { - return _Left + (-_Right); - } - - constexpr year_month_day operator+(const year_month_day& _Left, const years& _Right) noexcept { - return year{_Left.year() + _Right} / _Left.month() / _Left.day(); - } - - constexpr year_month_day operator+(const years& _Left, const year_month_day& _Right) noexcept { - return _Right + _Left; - } - - constexpr year_month_day operator-(const year_month_day& _Left, const years& _Right) noexcept { - return _Left + (-_Right); - } - - constexpr year_month_day& year_month_day::operator+=(const months& _Months) noexcept { - *this = *this + _Months; - return *this; - } - constexpr year_month_day& year_month_day::operator-=(const months& _Months) noexcept { - *this = *this - _Months; - return *this; - } - constexpr year_month_day& year_month_day::operator+=(const years& _Years) noexcept { - *this = *this + _Years; - return *this; - } - constexpr year_month_day& year_month_day::operator-=(const years& _Years) noexcept { - *this = *this - _Years; - return *this; - } // year_month_day_last constexpr year_month_day_last::year_month_day_last( From c35767a1f7ed234afdc2421014fe6a73ac6f989c Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Wed, 15 Apr 2020 14:49:48 +0100 Subject: [PATCH 052/143] Move year_month_day_last --- stl/inc/chrono | 163 +++++++++++++++++++++---------------------------- 1 file changed, 71 insertions(+), 92 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index b6fe6b358ac..85e9b3bca94 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1328,23 +1328,86 @@ namespace chrono { chrono::month_day_last _Month_day_last; public: - constexpr year_month_day_last(const chrono::year& _Y, const chrono::month_day_last& _Mdl) noexcept; + constexpr year_month_day_last(const chrono::year& _Y, const chrono::month_day_last& _Mdl) noexcept + : _Year{_Y}, _Month_day_last{_Mdl} {} constexpr year_month_day_last& operator+=(const months& _Months) noexcept; constexpr year_month_day_last& operator-=(const months& _Months) noexcept; constexpr year_month_day_last& operator+=(const years& _Years) noexcept; constexpr year_month_day_last& operator-=(const years& _Years) noexcept; - _NODISCARD constexpr chrono::year year() const noexcept; - _NODISCARD constexpr chrono::month month() const noexcept; - _NODISCARD constexpr chrono::month_day_last month_day_last() const noexcept; - _NODISCARD constexpr chrono::day day() const noexcept; + _NODISCARD constexpr chrono::year year() const noexcept { + return _Year; + } + _NODISCARD constexpr chrono::month month() const noexcept { + return _Month_day_last.month(); + } + _NODISCARD constexpr chrono::month_day_last month_day_last() const noexcept { + return _Month_day_last; + } + _NODISCARD constexpr chrono::day day() const noexcept { + return _Last_day(year(), month()); + } - _NODISCARD constexpr operator sys_days() const noexcept; - _NODISCARD constexpr explicit operator local_days() const noexcept; - _NODISCARD constexpr bool ok() const noexcept; + _NODISCARD constexpr operator sys_days() const noexcept { + return sys_days{year_month_day{year(), month(), day()}}; + } + _NODISCARD constexpr explicit operator local_days() const noexcept { + return _STD chrono::local_days{static_cast(*this).time_since_epoch()}; + } + _NODISCARD constexpr bool ok() const noexcept { + return _Year.ok() && _Month_day_last.ok(); + } }; + constexpr bool operator==(const year_month_day_last& _Left, const year_month_day_last& _Right) noexcept { + return _Left.year() == _Right.year() && _Left.month_day_last() == _Right.month_day_last(); + } + constexpr strong_ordering operator<=>( + const year_month_day_last& _Left, const year_month_day_last& _Right) noexcept { + if (auto _Comp = _Left.year() <=> _Right.year(); _Comp != 0) + return _Comp; + return _Left.month_day_last() <=> _Right.month_day_last(); + } + + constexpr year_month_day_last operator+(const year_month_day_last& _Left, const months& _Right) noexcept { + const auto _Ym = year_month{_Left.year(), _Left.month()} + _Right; + return {_Ym.year(), month_day_last{_Ym.month()}}; + } + constexpr year_month_day_last operator+(const months& _Left, const year_month_day_last& _Right) noexcept { + return _Right + _Left; + } + + constexpr year_month_day_last operator-(const year_month_day_last& _Left, const months& _Right) noexcept { + return _Left + (-_Right); + } + + constexpr year_month_day_last operator+(const year_month_day_last& _Left, const years& _Right) noexcept { + return {_Left.year() + _Right, _Left.month_day_last()}; + } + constexpr year_month_day_last operator+(const years& _Left, const year_month_day_last& _Right) noexcept { + return _Right + _Left; + } + constexpr year_month_day_last operator-(const year_month_day_last& _Left, const years& _Right) noexcept { + return _Left + (-_Right); + } + + constexpr year_month_day_last& year_month_day_last::operator+=(const months& _Months) noexcept { + *this = *this + _Months; + return *this; + } + constexpr year_month_day_last& year_month_day_last::operator-=(const months& _Months) noexcept { + *this = *this - _Months; + return *this; + } + constexpr year_month_day_last& year_month_day_last::operator+=(const years& _Years) noexcept { + *this = *this + _Years; + return *this; + } + constexpr year_month_day_last& year_month_day_last::operator-=(const years& _Years) noexcept { + *this = *this - _Years; + return *this; + } // year constexpr year_month_day::year_month_day(const year_month_day_last& _Ymdl) noexcept : _Year{_Ymdl.year()}, _Month{_Ymdl.month()}, _Day{_Ymdl.day()} {} @@ -1444,90 +1507,6 @@ namespace chrono { _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, int _Year) noexcept; - // year_month_day_last - constexpr year_month_day_last::year_month_day_last( - const chrono::year& _Y, const chrono::month_day_last& _Mdl) noexcept - : _Year{_Y}, _Month_day_last{_Mdl} {} - - constexpr chrono::year year_month_day_last::year() const noexcept { - return _Year; - } - constexpr chrono::month year_month_day_last::month() const noexcept { - return _Month_day_last.month(); - } - constexpr chrono::month_day_last year_month_day_last::month_day_last() const noexcept { - return _Month_day_last; - } - constexpr chrono::day year_month_day_last::day() const noexcept { - // clang-format off - constexpr chrono::day _Days[] = { - chrono::day{31}, chrono::day{28}, chrono::day{31}, chrono::day{30}, - chrono::day{31}, chrono::day{30}, chrono::day{31}, chrono::day{31}, - chrono::day{30}, chrono::day{31}, chrono::day{30}, chrono::day{31}}; - // clang-format on - return month() == chrono::month{2} && _Year.is_leap() - ? _Days[static_cast(month()) - 1] + chrono::days{1} - : _Days[static_cast(month()) - 1]; - } - - constexpr year_month_day_last::operator sys_days() const noexcept { - return sys_days{year() / month() / day()}; - } - constexpr year_month_day_last::operator local_days() const noexcept { - return _STD chrono::local_days{static_cast(*this).time_since_epoch()}; - } - constexpr bool year_month_day_last::ok() const noexcept { - return _Year.ok() && _Month_day_last.ok(); - } - - constexpr bool operator==(const year_month_day_last& _Left, const year_month_day_last& _Right) noexcept { - return _Left.year() == _Right.year() && _Left.month_day_last() == _Right.month_day_last(); - } - constexpr strong_ordering operator<=>( - const year_month_day_last& _Left, const year_month_day_last& _Right) noexcept { - if (auto _Comp = _Left.year() <=> _Right.year(); _Comp != 0) - return _Comp; - return _Left.month_day_last() <=> _Right.month_day_last(); - } - - constexpr year_month_day_last operator+(const year_month_day_last& _Left, const months& _Right) noexcept { - return (_Left.year() / _Left.month() + _Right) / last; - } - constexpr year_month_day_last operator+(const months& _Left, const year_month_day_last& _Right) noexcept { - return _Right + _Left; - } - - constexpr year_month_day_last operator-(const year_month_day_last& _Left, const months& _Right) noexcept { - return _Left + (-_Right); - } - - constexpr year_month_day_last operator+(const year_month_day_last& _Left, const years& _Right) noexcept { - return {_Left.year() + _Right, _Left.month_day_last()}; - } - constexpr year_month_day_last operator+(const years& _Left, const year_month_day_last& _Right) noexcept { - return _Right + _Left; - } - constexpr year_month_day_last operator-(const year_month_day_last& _Left, const years& _Right) noexcept { - return _Left + (-_Right); - } - - constexpr year_month_day_last& year_month_day_last::operator+=(const months& _Months) noexcept { - *this = *this + _Months; - return *this; - } - constexpr year_month_day_last& year_month_day_last::operator-=(const months& _Months) noexcept { - *this = *this - _Months; - return *this; - } - constexpr year_month_day_last& year_month_day_last::operator+=(const years& _Years) noexcept { - *this = *this + _Years; - return *this; - } - constexpr year_month_day_last& year_month_day_last::operator-=(const years& _Years) noexcept { - *this = *this - _Years; - return *this; - } - // year_month_weekday constexpr year_month_weekday year_month_weekday::_Ymwd_from_days(days _Dp) noexcept { const chrono::year_month_day _Ymd = sys_days{_Dp}; From bd300ae7f8a2c9f9b26cb30e1f0359e88f27e054 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Wed, 15 Apr 2020 15:02:14 +0100 Subject: [PATCH 053/143] Move year_month_weekday --- stl/inc/chrono | 201 ++++++++++++++++++++++--------------------------- 1 file changed, 92 insertions(+), 109 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 85e9b3bca94..c77ee0e0021 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1416,31 +1416,111 @@ namespace chrono { chrono::year _Year; chrono::month _Month; chrono::weekday_indexed _Weekday_index; - _NODISCARD static constexpr year_month_weekday _Ymwd_from_days(days _Dp) noexcept; + + _NODISCARD static constexpr year_month_weekday _Ymwd_from_days(days _Dp) noexcept { + const chrono::year_month_day _Ymd = sys_days{_Dp}; + const chrono::weekday _Wd = sys_days{_Dp}; + const auto _Idx = ((static_cast(_Ymd.day()) - 1) / 7) + 1; + return {_Ymd.year(), _Ymd.month(), _Wd[_Idx]}; + } public: year_month_weekday() = default; constexpr year_month_weekday( - const chrono::year& _Y, const chrono::month& _M, const chrono::weekday_indexed& _Wdi) noexcept; - constexpr year_month_weekday(const sys_days& _Sys_days) noexcept; - constexpr explicit year_month_weekday(const local_days& _Local_days) noexcept; + const chrono::year& _Y, const chrono::month& _M, const chrono::weekday_indexed& _Wdi) noexcept + : _Year{_Y}, _Month{_M}, _Weekday_index{_Wdi} {} + constexpr year_month_weekday(const sys_days& _Sys_days) noexcept + : year_month_weekday{_Ymwd_from_days(_Sys_days.time_since_epoch())} {} + constexpr explicit year_month_weekday(const local_days& _Local_days) noexcept + : year_month_weekday{_Ymwd_from_days(_Local_days.time_since_epoch())} {} constexpr year_month_weekday& operator+=(const months& _Months) noexcept; constexpr year_month_weekday& operator-=(const months& _Months) noexcept; constexpr year_month_weekday& operator+=(const years& _Years) noexcept; constexpr year_month_weekday& operator-=(const years& _Years) noexcept; - _NODISCARD constexpr chrono::year year() const noexcept; - _NODISCARD constexpr chrono::month month() const noexcept; - _NODISCARD constexpr chrono::weekday weekday() const noexcept; - _NODISCARD constexpr unsigned index() const noexcept; - _NODISCARD constexpr chrono::weekday_indexed weekday_indexed() const noexcept; + _NODISCARD constexpr chrono::year year() const noexcept { + return _Year; + } + _NODISCARD constexpr chrono::month month() const noexcept { + return _Month; + } + _NODISCARD constexpr chrono::weekday weekday() const noexcept { + return _Weekday_index.weekday(); + } + _NODISCARD constexpr unsigned index() const noexcept { + return _Weekday_index.index(); + } + _NODISCARD constexpr chrono::weekday_indexed weekday_indexed() const noexcept { + return _Weekday_index; + } - _NODISCARD constexpr operator sys_days() const noexcept; - _NODISCARD constexpr explicit operator local_days() const noexcept; - _NODISCARD constexpr bool ok() const noexcept; + _NODISCARD constexpr operator sys_days() const noexcept { + const sys_days _First = year_month_day{_Year, _Month, day{1}}; + const days _Diff = weekday() - chrono::weekday{_First}; + const days _Days = _Diff + days{(index() - 1) * 7}; + return _First + _Days; + } + _NODISCARD constexpr explicit operator local_days() const noexcept { + return chrono::local_days{static_cast(*this).time_since_epoch()}; + } + _NODISCARD constexpr bool ok() const noexcept { + if (!_Year.ok() || !_Month.ok() || !_Weekday_index.ok()) + return false; + if (_Weekday_index.index() <= 4) + return true; + const sys_days _First = year_month_day{_Year, _Month, day{1}}; + const days _Diff = weekday() - chrono::weekday{_First}; + const days _Last = _Diff + days{29}; + return static_cast(_Last.count()) <= static_cast(_Last_day(_Year, _Month)); + } }; + constexpr bool operator==(const year_month_weekday& _Left, const year_month_weekday& _Right) noexcept { + return _Left.year() == _Right.year() && _Left.month() == _Right.month() + && _Left.weekday_indexed() == _Right.weekday_indexed(); + } + + constexpr year_month_weekday operator+(const year_month_weekday& _Left, const months& _Right) noexcept { + const auto _Ym = year_month{_Left.year(), _Left.month()} + _Right; + return {_Ym.year(), _Ym.month(), _Left.weekday_indexed()}; + } + constexpr year_month_weekday operator+(const months& _Left, const year_month_weekday& _Right) noexcept { + return _Right + _Left; + } + + constexpr year_month_weekday operator-(const year_month_weekday& _Left, const months& _Right) noexcept { + return _Left + (-_Right); + } + + constexpr year_month_weekday operator+(const year_month_weekday& _Left, const years& _Right) noexcept { + return year_month_weekday{_Left.year() + _Right, _Left.month(), _Left.weekday_indexed()}; + } + constexpr year_month_weekday operator+(const years& _Left, const year_month_weekday& _Right) noexcept { + return _Right + _Left; + } + + constexpr year_month_weekday operator-(const year_month_weekday& _Left, const years& _Right) noexcept { + return _Left + (-_Right); + } + + constexpr year_month_weekday& year_month_weekday::operator+=(const months& _Months) noexcept { + *this = *this + _Months; + return *this; + } + constexpr year_month_weekday& year_month_weekday::operator-=(const months& _Months) noexcept { + *this = *this - _Months; + return *this; + } + constexpr year_month_weekday& year_month_weekday::operator+=(const years& _Years) noexcept { + *this = *this + _Years; + return *this; + } + constexpr year_month_weekday& year_month_weekday::operator-=(const years& _Years) noexcept { + *this = *this - _Years; + return *this; + } + class year_month_weekday_last { chrono::year _Year; chrono::month _Month; @@ -1506,103 +1586,6 @@ namespace chrono { _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, const year& _Year) noexcept; _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, int _Year) noexcept; - - // year_month_weekday - constexpr year_month_weekday year_month_weekday::_Ymwd_from_days(days _Dp) noexcept { - const chrono::year_month_day _Ymd = sys_days{_Dp}; - const chrono::weekday _Wd = sys_days{_Dp}; - const auto _Idx = ((static_cast(_Ymd.day()) - 1) / 7) + 1; - return {_Ymd.year() / _Ymd.month() / _Wd[_Idx]}; - } - - constexpr std::chrono::year_month_weekday::year_month_weekday( - const chrono::year& _Y, const chrono::month& _M, const chrono::weekday_indexed& _Wdi) noexcept - : _Year{_Y}, _Month{_M}, _Weekday_index{_Wdi} {} - constexpr year_month_weekday::year_month_weekday(const sys_days& _Sys_days) noexcept - : year_month_weekday{_Ymwd_from_days(_Sys_days.time_since_epoch())} {} - constexpr year_month_weekday::year_month_weekday(const local_days& _Local_days) noexcept - : year_month_weekday{_Ymwd_from_days(_Local_days.time_since_epoch())} {} - - constexpr chrono::year year_month_weekday::year() const noexcept { - return _Year; - } - constexpr chrono::month year_month_weekday::month() const noexcept { - return _Month; - } - constexpr chrono::weekday year_month_weekday::weekday() const noexcept { - return _Weekday_index.weekday(); - } - constexpr unsigned year_month_weekday::index() const noexcept { - return _Weekday_index.index(); - } - constexpr chrono::weekday_indexed year_month_weekday::weekday_indexed() const noexcept { - return _Weekday_index; - } - - constexpr year_month_weekday::operator sys_days() const noexcept { - const sys_days _First{_Year / _Month / 1}; - const days _Diff = weekday() - chrono::weekday{_First}; - const days _Days = _Diff + days{(index() - 1) * 7}; - return _First + _Days; - } - constexpr year_month_weekday::operator local_days() const noexcept { - return _STD chrono::local_days{static_cast(*this).time_since_epoch()}; - } - - constexpr bool year_month_weekday::ok() const noexcept { - if (!_Year.ok() || !_Month.ok() || !_Weekday_index.ok()) - return false; - if (_Weekday_index.index() <= 4) - return true; - const sys_days _First = _Year / _Month / 1; - const days _Diff = weekday() - chrono::weekday{_First}; - const days _Last = _Diff + days{29}; - return static_cast(_Last.count()) <= static_cast((year() / month() / last).day()); - } - constexpr bool operator==(const year_month_weekday& _Left, const year_month_weekday& _Right) noexcept { - return _Left.year() == _Right.year() && _Left.month() == _Right.month() - && _Left.weekday_indexed() == _Right.weekday_indexed(); - } - - constexpr year_month_weekday operator+(const year_month_weekday& _Left, const months& _Right) noexcept { - return (_Left.year() / _Left.month() + _Right) / _Left.weekday_indexed(); - } - constexpr year_month_weekday operator+(const months& _Left, const year_month_weekday& _Right) noexcept { - return _Right + _Left; - } - - constexpr year_month_weekday operator-(const year_month_weekday& _Left, const months& _Right) noexcept { - return _Left + (-_Right); - } - - constexpr year_month_weekday operator+(const year_month_weekday& _Left, const years& _Right) noexcept { - return year_month_weekday{_Left.year() + _Right, _Left.month(), _Left.weekday_indexed()}; - } - constexpr year_month_weekday operator+(const years& _Left, const year_month_weekday& _Right) noexcept { - return _Right + _Left; - } - - constexpr year_month_weekday operator-(const year_month_weekday& _Left, const years& _Right) noexcept { - return _Left + (-_Right); - } - - constexpr year_month_weekday& year_month_weekday::operator+=(const months& _Months) noexcept { - *this = *this + _Months; - return *this; - } - constexpr year_month_weekday& year_month_weekday::operator-=(const months& _Months) noexcept { - *this = *this - _Months; - return *this; - } - constexpr year_month_weekday& year_month_weekday::operator+=(const years& _Years) noexcept { - *this = *this + _Years; - return *this; - } - constexpr year_month_weekday& year_month_weekday::operator-=(const years& _Years) noexcept { - *this = *this - _Years; - return *this; - } - // year_month_weekday_last constexpr year_month_weekday_last::year_month_weekday_last( const chrono::year& _Y, const chrono::month& _M, const chrono::weekday_last& _Wdl) noexcept From fc993a327417cd44e583ba4f67c156c57359bf4c Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Wed, 15 Apr 2020 15:08:23 +0100 Subject: [PATCH 054/143] Move year_month_weekday_last --- stl/inc/chrono | 149 +++++++++++++++++++++++-------------------------- 1 file changed, 69 insertions(+), 80 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index c77ee0e0021..d165f21b0df 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1528,93 +1528,40 @@ namespace chrono { public: constexpr year_month_weekday_last( - const chrono::year& _Y, const chrono::month& _M, const chrono::weekday_last& _Wdl) noexcept; + const chrono::year& _Y, const chrono::month& _M, const chrono::weekday_last& _Wdl) noexcept + : _Year{_Y}, _Month{_M}, _Weekday_last{_Wdl} {} constexpr year_month_weekday_last& operator+=(const months& _Months) noexcept; constexpr year_month_weekday_last& operator-=(const months& _Months) noexcept; constexpr year_month_weekday_last& operator+=(const years& _Years) noexcept; constexpr year_month_weekday_last& operator-=(const years& _Years) noexcept; - _NODISCARD constexpr chrono::year year() const noexcept; - _NODISCARD constexpr chrono::month month() const noexcept; - _NODISCARD constexpr chrono::weekday weekday() const noexcept; - _NODISCARD constexpr chrono::weekday_last weekday_last() const noexcept; - - _NODISCARD constexpr operator sys_days() const noexcept; - _NODISCARD constexpr explicit operator local_days() const noexcept; - _NODISCARD constexpr bool ok() const noexcept; - }; - - _NODISCARD constexpr year_month operator/(const year& _Year, const month& _Month) noexcept; - _NODISCARD constexpr year_month operator/(const year& _Year, int _Month) noexcept; - _NODISCARD constexpr month_day operator/(const month& _Month, const day& _Day) noexcept; - _NODISCARD constexpr month_day operator/(const month& _Month, int _Day) noexcept; - _NODISCARD constexpr month_day operator/(int _Month, const day& _Day) noexcept; - _NODISCARD constexpr month_day operator/(const day& _Day, const month& _Month) noexcept; - _NODISCARD constexpr month_day operator/(const day& _Day, int _Month) noexcept; - _NODISCARD constexpr month_day_last operator/(const month& _Month, last_spec) noexcept; - _NODISCARD constexpr month_day_last operator/(int _Month, last_spec) noexcept; - _NODISCARD constexpr month_day_last operator/(last_spec, const month& _Month) noexcept; - _NODISCARD constexpr month_day_last operator/(last_spec, int _Month) noexcept; - _NODISCARD constexpr month_weekday operator/(const month& _Month, const weekday_indexed& _Wdi) noexcept; - _NODISCARD constexpr month_weekday operator/(int _Month, const weekday_indexed& _Wdi) noexcept; - _NODISCARD constexpr month_weekday operator/(const weekday_indexed& _Wdi, const month& _Month) noexcept; - _NODISCARD constexpr month_weekday operator/(const weekday_indexed& _Wdi, int _Month) noexcept; - _NODISCARD constexpr month_weekday_last operator/(const month& _Month, const weekday_last& _Wdl) noexcept; - _NODISCARD constexpr month_weekday_last operator/(int _Month, const weekday_last& _Wdl) noexcept; - _NODISCARD constexpr month_weekday_last operator/(const weekday_last& _Wdl, const month& _Month) noexcept; - _NODISCARD constexpr month_weekday_last operator/(const weekday_last& _Wdl, int _Month) noexcept; - _NODISCARD constexpr year_month_day operator/(const year_month& _Ym, const day& _Day) noexcept; - _NODISCARD constexpr year_month_day operator/(const year_month& _Ym, int _Day) noexcept; - _NODISCARD constexpr year_month_day operator/(const year& _Year, const month_day& _Md) noexcept; - _NODISCARD constexpr year_month_day operator/(int _Year, const month_day& _Md) noexcept; - _NODISCARD constexpr year_month_day operator/(const month_day& _Md, const year& _Year) noexcept; - _NODISCARD constexpr year_month_day operator/(const month_day& _Md, int _Year) noexcept; - _NODISCARD constexpr year_month_day_last operator/(const year_month& _Ym, last_spec) noexcept; - _NODISCARD constexpr year_month_day_last operator/(const year& _Year, const month_day_last& _Mdl) noexcept; - _NODISCARD constexpr year_month_day_last operator/(int _Year, const month_day_last& _Mdl) noexcept; - _NODISCARD constexpr year_month_day_last operator/(const month_day_last& _Mdl, const year& _Year) noexcept; - _NODISCARD constexpr year_month_day_last operator/(const month_day_last& _Mdl, int _Year) noexcept; - _NODISCARD constexpr year_month_weekday operator/(const year_month& _Ym, const weekday_indexed& _Wdi) noexcept; - _NODISCARD constexpr year_month_weekday operator/(const year& _Year, const month_weekday& _Mwd) noexcept; - _NODISCARD constexpr year_month_weekday operator/(int _Year, const month_weekday& _Mwd) noexcept; - _NODISCARD constexpr year_month_weekday operator/(const month_weekday& _Mwd, const year& _Year) noexcept; - _NODISCARD constexpr year_month_weekday operator/(const month_weekday& _Mwd, int _Year) noexcept; - _NODISCARD constexpr year_month_weekday_last operator/(const year_month& _Ym, const weekday_last& _Wdl) noexcept; - _NODISCARD constexpr year_month_weekday_last operator/(const year& _Year, const month_weekday_last& _Mwdl) noexcept; - _NODISCARD constexpr year_month_weekday_last operator/(int _Year, const month_weekday_last& _Mwdl) noexcept; - _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, const year& _Year) noexcept; - _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, int _Year) noexcept; - - // year_month_weekday_last - constexpr year_month_weekday_last::year_month_weekday_last( - const chrono::year& _Y, const chrono::month& _M, const chrono::weekday_last& _Wdl) noexcept - : _Year{_Y}, _Month{_M}, _Weekday_last{_Wdl} {} + _NODISCARD constexpr chrono::year year() const noexcept { + return _Year; + } + _NODISCARD constexpr chrono::month month() const noexcept { + return _Month; + } + _NODISCARD constexpr chrono::weekday weekday() const noexcept { + return _Weekday_last.weekday(); + } - constexpr chrono::year year_month_weekday_last::year() const noexcept { - return _Year; - } - constexpr chrono::month year_month_weekday_last::month() const noexcept { - return _Month; - } - constexpr chrono::weekday year_month_weekday_last::weekday() const noexcept { - return _Weekday_last.weekday(); - } - constexpr chrono::weekday_last year_month_weekday_last::weekday_last() const noexcept { - return _Weekday_last; - } + _NODISCARD constexpr chrono::weekday_last weekday_last() const noexcept { + return _Weekday_last; + } - constexpr year_month_weekday_last::operator sys_days() const noexcept { - const sys_days _Last{_Year / _Month / last}; - const auto _Diff = chrono::weekday{_Last} - weekday(); - return _Last - _Diff; - } - constexpr year_month_weekday_last::operator local_days() const noexcept { - return _STD chrono::local_days{static_cast(*this).time_since_epoch()}; - } - constexpr bool year_month_weekday_last::ok() const noexcept { - return _Year.ok() && _Month.ok() && _Weekday_last.ok(); - } + _NODISCARD constexpr operator sys_days() const noexcept { + const sys_days _Last = year_month_day_last{_Year, month_day_last{_Month}}; + const auto _Diff = chrono::weekday{_Last} - weekday(); + return _Last - _Diff; + } + _NODISCARD constexpr explicit operator local_days() const noexcept { + return chrono::local_days{static_cast(*this).time_since_epoch()}; + } + _NODISCARD constexpr bool ok() const noexcept { + return _Year.ok() && _Month.ok() && _Weekday_last.ok(); + } + }; constexpr bool operator==(const year_month_weekday_last& _Left, const year_month_weekday_last& _Right) noexcept { return _Left.year() == _Right.year() && _Left.month() == _Right.month() @@ -1622,7 +1569,8 @@ namespace chrono { } constexpr year_month_weekday_last operator+(const year_month_weekday_last& _Left, const months& _Right) noexcept { - return (_Left.year() / _Left.month() + _Right) / _Left.weekday_last(); + const auto _Ym = year_month{_Left.year(), _Left.month()} + _Right; + return {_Ym.year(), _Ym.month(), _Left.weekday_last()}; } constexpr year_month_weekday_last operator+(const months& _Left, const year_month_weekday_last& _Right) noexcept { return _Right + _Left; @@ -1660,6 +1608,47 @@ namespace chrono { return *this; } + _NODISCARD constexpr year_month operator/(const year& _Year, const month& _Month) noexcept; + _NODISCARD constexpr year_month operator/(const year& _Year, int _Month) noexcept; + _NODISCARD constexpr month_day operator/(const month& _Month, const day& _Day) noexcept; + _NODISCARD constexpr month_day operator/(const month& _Month, int _Day) noexcept; + _NODISCARD constexpr month_day operator/(int _Month, const day& _Day) noexcept; + _NODISCARD constexpr month_day operator/(const day& _Day, const month& _Month) noexcept; + _NODISCARD constexpr month_day operator/(const day& _Day, int _Month) noexcept; + _NODISCARD constexpr month_day_last operator/(const month& _Month, last_spec) noexcept; + _NODISCARD constexpr month_day_last operator/(int _Month, last_spec) noexcept; + _NODISCARD constexpr month_day_last operator/(last_spec, const month& _Month) noexcept; + _NODISCARD constexpr month_day_last operator/(last_spec, int _Month) noexcept; + _NODISCARD constexpr month_weekday operator/(const month& _Month, const weekday_indexed& _Wdi) noexcept; + _NODISCARD constexpr month_weekday operator/(int _Month, const weekday_indexed& _Wdi) noexcept; + _NODISCARD constexpr month_weekday operator/(const weekday_indexed& _Wdi, const month& _Month) noexcept; + _NODISCARD constexpr month_weekday operator/(const weekday_indexed& _Wdi, int _Month) noexcept; + _NODISCARD constexpr month_weekday_last operator/(const month& _Month, const weekday_last& _Wdl) noexcept; + _NODISCARD constexpr month_weekday_last operator/(int _Month, const weekday_last& _Wdl) noexcept; + _NODISCARD constexpr month_weekday_last operator/(const weekday_last& _Wdl, const month& _Month) noexcept; + _NODISCARD constexpr month_weekday_last operator/(const weekday_last& _Wdl, int _Month) noexcept; + _NODISCARD constexpr year_month_day operator/(const year_month& _Ym, const day& _Day) noexcept; + _NODISCARD constexpr year_month_day operator/(const year_month& _Ym, int _Day) noexcept; + _NODISCARD constexpr year_month_day operator/(const year& _Year, const month_day& _Md) noexcept; + _NODISCARD constexpr year_month_day operator/(int _Year, const month_day& _Md) noexcept; + _NODISCARD constexpr year_month_day operator/(const month_day& _Md, const year& _Year) noexcept; + _NODISCARD constexpr year_month_day operator/(const month_day& _Md, int _Year) noexcept; + _NODISCARD constexpr year_month_day_last operator/(const year_month& _Ym, last_spec) noexcept; + _NODISCARD constexpr year_month_day_last operator/(const year& _Year, const month_day_last& _Mdl) noexcept; + _NODISCARD constexpr year_month_day_last operator/(int _Year, const month_day_last& _Mdl) noexcept; + _NODISCARD constexpr year_month_day_last operator/(const month_day_last& _Mdl, const year& _Year) noexcept; + _NODISCARD constexpr year_month_day_last operator/(const month_day_last& _Mdl, int _Year) noexcept; + _NODISCARD constexpr year_month_weekday operator/(const year_month& _Ym, const weekday_indexed& _Wdi) noexcept; + _NODISCARD constexpr year_month_weekday operator/(const year& _Year, const month_weekday& _Mwd) noexcept; + _NODISCARD constexpr year_month_weekday operator/(int _Year, const month_weekday& _Mwd) noexcept; + _NODISCARD constexpr year_month_weekday operator/(const month_weekday& _Mwd, const year& _Year) noexcept; + _NODISCARD constexpr year_month_weekday operator/(const month_weekday& _Mwd, int _Year) noexcept; + _NODISCARD constexpr year_month_weekday_last operator/(const year_month& _Ym, const weekday_last& _Wdl) noexcept; + _NODISCARD constexpr year_month_weekday_last operator/(const year& _Year, const month_weekday_last& _Mwdl) noexcept; + _NODISCARD constexpr year_month_weekday_last operator/(int _Year, const month_weekday_last& _Mwdl) noexcept; + _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, const year& _Year) noexcept; + _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, int _Year) noexcept; + // Civil calendar conventional syntax operators constexpr year_month operator/(const year& _Year, const month& _Month) noexcept { return {_Year, _Month}; From 467a63c15cd8d9474656c678e72dc1d1175b5dbb Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Wed, 15 Apr 2020 15:18:48 +0100 Subject: [PATCH 055/143] Remove / operator declarations --- stl/inc/chrono | 123 +++++++++++++++++-------------------------------- 1 file changed, 42 insertions(+), 81 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index d165f21b0df..c3740f62f25 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1608,166 +1608,127 @@ namespace chrono { return *this; } - _NODISCARD constexpr year_month operator/(const year& _Year, const month& _Month) noexcept; - _NODISCARD constexpr year_month operator/(const year& _Year, int _Month) noexcept; - _NODISCARD constexpr month_day operator/(const month& _Month, const day& _Day) noexcept; - _NODISCARD constexpr month_day operator/(const month& _Month, int _Day) noexcept; - _NODISCARD constexpr month_day operator/(int _Month, const day& _Day) noexcept; - _NODISCARD constexpr month_day operator/(const day& _Day, const month& _Month) noexcept; - _NODISCARD constexpr month_day operator/(const day& _Day, int _Month) noexcept; - _NODISCARD constexpr month_day_last operator/(const month& _Month, last_spec) noexcept; - _NODISCARD constexpr month_day_last operator/(int _Month, last_spec) noexcept; - _NODISCARD constexpr month_day_last operator/(last_spec, const month& _Month) noexcept; - _NODISCARD constexpr month_day_last operator/(last_spec, int _Month) noexcept; - _NODISCARD constexpr month_weekday operator/(const month& _Month, const weekday_indexed& _Wdi) noexcept; - _NODISCARD constexpr month_weekday operator/(int _Month, const weekday_indexed& _Wdi) noexcept; - _NODISCARD constexpr month_weekday operator/(const weekday_indexed& _Wdi, const month& _Month) noexcept; - _NODISCARD constexpr month_weekday operator/(const weekday_indexed& _Wdi, int _Month) noexcept; - _NODISCARD constexpr month_weekday_last operator/(const month& _Month, const weekday_last& _Wdl) noexcept; - _NODISCARD constexpr month_weekday_last operator/(int _Month, const weekday_last& _Wdl) noexcept; - _NODISCARD constexpr month_weekday_last operator/(const weekday_last& _Wdl, const month& _Month) noexcept; - _NODISCARD constexpr month_weekday_last operator/(const weekday_last& _Wdl, int _Month) noexcept; - _NODISCARD constexpr year_month_day operator/(const year_month& _Ym, const day& _Day) noexcept; - _NODISCARD constexpr year_month_day operator/(const year_month& _Ym, int _Day) noexcept; - _NODISCARD constexpr year_month_day operator/(const year& _Year, const month_day& _Md) noexcept; - _NODISCARD constexpr year_month_day operator/(int _Year, const month_day& _Md) noexcept; - _NODISCARD constexpr year_month_day operator/(const month_day& _Md, const year& _Year) noexcept; - _NODISCARD constexpr year_month_day operator/(const month_day& _Md, int _Year) noexcept; - _NODISCARD constexpr year_month_day_last operator/(const year_month& _Ym, last_spec) noexcept; - _NODISCARD constexpr year_month_day_last operator/(const year& _Year, const month_day_last& _Mdl) noexcept; - _NODISCARD constexpr year_month_day_last operator/(int _Year, const month_day_last& _Mdl) noexcept; - _NODISCARD constexpr year_month_day_last operator/(const month_day_last& _Mdl, const year& _Year) noexcept; - _NODISCARD constexpr year_month_day_last operator/(const month_day_last& _Mdl, int _Year) noexcept; - _NODISCARD constexpr year_month_weekday operator/(const year_month& _Ym, const weekday_indexed& _Wdi) noexcept; - _NODISCARD constexpr year_month_weekday operator/(const year& _Year, const month_weekday& _Mwd) noexcept; - _NODISCARD constexpr year_month_weekday operator/(int _Year, const month_weekday& _Mwd) noexcept; - _NODISCARD constexpr year_month_weekday operator/(const month_weekday& _Mwd, const year& _Year) noexcept; - _NODISCARD constexpr year_month_weekday operator/(const month_weekday& _Mwd, int _Year) noexcept; - _NODISCARD constexpr year_month_weekday_last operator/(const year_month& _Ym, const weekday_last& _Wdl) noexcept; - _NODISCARD constexpr year_month_weekday_last operator/(const year& _Year, const month_weekday_last& _Mwdl) noexcept; - _NODISCARD constexpr year_month_weekday_last operator/(int _Year, const month_weekday_last& _Mwdl) noexcept; - _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, const year& _Year) noexcept; - _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, int _Year) noexcept; - // Civil calendar conventional syntax operators - constexpr year_month operator/(const year& _Year, const month& _Month) noexcept { + _NODISCARD constexpr year_month operator/(const year& _Year, const month& _Month) noexcept { return {_Year, _Month}; } - constexpr year_month operator/(const year& _Year, int _Month) noexcept { + _NODISCARD constexpr year_month operator/(const year& _Year, int _Month) noexcept { return _Year / month{static_cast(_Month)}; } - constexpr month_day operator/(const month& _Month, const day& _Day) noexcept { + _NODISCARD constexpr month_day operator/(const month& _Month, const day& _Day) noexcept { return {_Month, _Day}; } - constexpr month_day operator/(const month& _Month, int _Day) noexcept { + _NODISCARD constexpr month_day operator/(const month& _Month, int _Day) noexcept { return _Month / day{static_cast(_Day)}; } - constexpr month_day operator/(int _Month, const day& _Day) noexcept { + _NODISCARD constexpr month_day operator/(int _Month, const day& _Day) noexcept { return month{static_cast(_Month)} / _Day; } - constexpr month_day operator/(const day& _Day, const month& _Month) noexcept { + _NODISCARD constexpr month_day operator/(const day& _Day, const month& _Month) noexcept { return _Month / _Day; } - constexpr month_day operator/(const day& _Day, int _Month) noexcept { + _NODISCARD constexpr month_day operator/(const day& _Day, int _Month) noexcept { return month{static_cast(_Month)} / _Day; } - constexpr month_day_last operator/(const month& _Month, last_spec) noexcept { + _NODISCARD constexpr month_day_last operator/(const month& _Month, last_spec) noexcept { return month_day_last{_Month}; } - constexpr month_day_last operator/(int _Month, last_spec) noexcept { + _NODISCARD constexpr month_day_last operator/(int _Month, last_spec) noexcept { return month{static_cast(_Month)} / last; } - constexpr month_day_last operator/(last_spec, const month& _Month) noexcept { + _NODISCARD constexpr month_day_last operator/(last_spec, const month& _Month) noexcept { return _Month / last; } - constexpr month_day_last operator/(last_spec, int _Month) noexcept { + _NODISCARD constexpr month_day_last operator/(last_spec, int _Month) noexcept { return month{static_cast(_Month)} / last; } - constexpr month_weekday operator/(const month& _Month, const weekday_indexed& _Wdi) noexcept { + _NODISCARD constexpr month_weekday operator/(const month& _Month, const weekday_indexed& _Wdi) noexcept { return {_Month, _Wdi}; } - constexpr month_weekday operator/(int _Month, const weekday_indexed& _Wdi) noexcept { + _NODISCARD constexpr month_weekday operator/(int _Month, const weekday_indexed& _Wdi) noexcept { return month{static_cast(_Month)} / _Wdi; } - constexpr month_weekday operator/(const weekday_indexed& _Wdi, const month& _Month) noexcept { + _NODISCARD constexpr month_weekday operator/(const weekday_indexed& _Wdi, const month& _Month) noexcept { return _Month / _Wdi; } - constexpr month_weekday operator/(const weekday_indexed& _Wdi, int _Month) noexcept { + _NODISCARD constexpr month_weekday operator/(const weekday_indexed& _Wdi, int _Month) noexcept { return month{static_cast(_Month)} / _Wdi; } - constexpr month_weekday_last operator/(const month& _Month, const weekday_last& _Wdl) noexcept { + _NODISCARD constexpr month_weekday_last operator/(const month& _Month, const weekday_last& _Wdl) noexcept { return {_Month, _Wdl}; } - constexpr month_weekday_last operator/(int _Month, const weekday_last& _Wdl) noexcept { + _NODISCARD constexpr month_weekday_last operator/(int _Month, const weekday_last& _Wdl) noexcept { return month{static_cast(_Month)} / _Wdl; } - constexpr month_weekday_last operator/(const weekday_last& _Wdl, const month& _Month) noexcept { + _NODISCARD constexpr month_weekday_last operator/(const weekday_last& _Wdl, const month& _Month) noexcept { return _Month / _Wdl; } - constexpr month_weekday_last operator/(const weekday_last& _Wdl, int _Month) noexcept { + _NODISCARD constexpr month_weekday_last operator/(const weekday_last& _Wdl, int _Month) noexcept { return month{static_cast(_Month)} / _Wdl; } - constexpr year_month_day operator/(const year_month& _Ym, const day& _Day) noexcept { + _NODISCARD constexpr year_month_day operator/(const year_month& _Ym, const day& _Day) noexcept { return {_Ym.year(), _Ym.month(), _Day}; } - constexpr year_month_day operator/(const year_month& _Ym, int _Day) noexcept { + _NODISCARD constexpr year_month_day operator/(const year_month& _Ym, int _Day) noexcept { return _Ym / day{static_cast(_Day)}; } - constexpr year_month_day operator/(const year& _Year, const month_day& _Md) noexcept { + _NODISCARD constexpr year_month_day operator/(const year& _Year, const month_day& _Md) noexcept { return _Year / _Md.month() / _Md.day(); } - constexpr year_month_day operator/(int _Year, const month_day& _Md) noexcept { + _NODISCARD constexpr year_month_day operator/(int _Year, const month_day& _Md) noexcept { return year{_Year} / _Md.month() / _Md.day(); } - constexpr year_month_day operator/(const month_day& _Md, const year& _Year) noexcept { + _NODISCARD constexpr year_month_day operator/(const month_day& _Md, const year& _Year) noexcept { return _Year / _Md.month() / _Md.day(); } - constexpr year_month_day operator/(const month_day& _Md, int _Year) noexcept { + _NODISCARD constexpr year_month_day operator/(const month_day& _Md, int _Year) noexcept { return year{_Year} / _Md.month() / _Md.day(); } - constexpr year_month_day_last operator/(const year_month& _Ym, last_spec) noexcept { + _NODISCARD constexpr year_month_day_last operator/(const year_month& _Ym, last_spec) noexcept { return {_Ym.year(), month_day_last{_Ym.month()}}; } - constexpr year_month_day_last operator/(const year& _Year, const month_day_last& _Mdl) noexcept { + _NODISCARD constexpr year_month_day_last operator/(const year& _Year, const month_day_last& _Mdl) noexcept { return {_Year, _Mdl}; } - constexpr year_month_day_last operator/(int _Year, const month_day_last& _Mdl) noexcept { + _NODISCARD constexpr year_month_day_last operator/(int _Year, const month_day_last& _Mdl) noexcept { return year{_Year} / _Mdl; } - constexpr year_month_day_last operator/(const month_day_last& _Mdl, const year& _Year) noexcept { + _NODISCARD constexpr year_month_day_last operator/(const month_day_last& _Mdl, const year& _Year) noexcept { return _Year / _Mdl; } - constexpr year_month_day_last operator/(const month_day_last& _Mdl, int _Year) noexcept { + _NODISCARD constexpr year_month_day_last operator/(const month_day_last& _Mdl, int _Year) noexcept { return year{_Year} / _Mdl; } - constexpr year_month_weekday operator/(const year_month& _Ym, const weekday_indexed& _Wdi) noexcept { + _NODISCARD constexpr year_month_weekday operator/(const year_month& _Ym, const weekday_indexed& _Wdi) noexcept { return year_month_weekday{_Ym.year(), _Ym.month(), _Wdi}; } - constexpr year_month_weekday operator/(const year& _Year, const month_weekday& _Mwd) noexcept { + _NODISCARD constexpr year_month_weekday operator/(const year& _Year, const month_weekday& _Mwd) noexcept { return year_month_weekday{_Year, _Mwd.month(), _Mwd.weekday_indexed()}; } - constexpr year_month_weekday operator/(int _Year, const month_weekday& _Mwd) noexcept { + _NODISCARD constexpr year_month_weekday operator/(int _Year, const month_weekday& _Mwd) noexcept { return year{_Year} / _Mwd; } - constexpr year_month_weekday operator/(const month_weekday& _Mwd, const year& _Year) noexcept { + _NODISCARD constexpr year_month_weekday operator/(const month_weekday& _Mwd, const year& _Year) noexcept { return _Year / _Mwd; } - constexpr year_month_weekday operator/(const month_weekday& _Mwd, int _Year) noexcept { + _NODISCARD constexpr year_month_weekday operator/(const month_weekday& _Mwd, int _Year) noexcept { return year{_Year} / _Mwd; } - constexpr year_month_weekday_last operator/(const year_month& _Ym, const weekday_last& _Wdl) noexcept { + _NODISCARD constexpr year_month_weekday_last operator/(const year_month& _Ym, const weekday_last& _Wdl) noexcept { return {_Ym.year(), _Ym.month(), _Wdl}; } - constexpr year_month_weekday_last operator/(const year& _Year, const month_weekday_last& _Mwdl) noexcept { + _NODISCARD constexpr year_month_weekday_last operator/( + const year& _Year, const month_weekday_last& _Mwdl) noexcept { return {_Year, _Mwdl.month(), _Mwdl.weekday_last()}; } - constexpr year_month_weekday_last operator/(int _Year, const month_weekday_last& _Mwdl) noexcept { + _NODISCARD constexpr year_month_weekday_last operator/(int _Year, const month_weekday_last& _Mwdl) noexcept { return year{_Year} / _Mwdl; } - constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, const year& _Year) noexcept { + _NODISCARD constexpr year_month_weekday_last operator/( + const month_weekday_last& _Mwdl, const year& _Year) noexcept { return _Year / _Mwdl; } - constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, int _Year) noexcept { + _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, int _Year) noexcept { return year{_Year} / _Mwdl; } From fb11c21a9f0c612bb66224a7292de579a79fbbd6 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Wed, 15 Apr 2020 18:37:26 +0100 Subject: [PATCH 056/143] Fix year::ok()? --- stl/inc/chrono | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index c3740f62f25..5ce3f72b675 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -803,6 +803,8 @@ namespace chrono { class year { short _Year; + constexpr static int _Ymin = -32767; + constexpr static int _Ymax = 32767; public: year() = default; @@ -848,14 +850,14 @@ namespace chrono { } _NODISCARD constexpr bool ok() const noexcept { - return (min)()._Year <= _Year && _Year <= (max)()._Year; + return _Ymin <= _Year && _Year <= _Ymax; } _NODISCARD static constexpr year(min)() noexcept { - return year{-32767}; + return year{_Ymin}; } _NODISCARD static constexpr year(max)() noexcept { - return year{32767}; + return year{_Ymax}; } }; From ed11f50d1f79982c4a73110998358fe8780bae01 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Thu, 16 Apr 2020 15:41:24 +0100 Subject: [PATCH 057/143] Unskip libcxx tests --- tests/libcxx/expected_results.txt | 154 ---------------------------- tests/libcxx/skipped_tests.txt | 164 ++---------------------------- 2 files changed, 10 insertions(+), 308 deletions(-) diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt index a91dbd2300e..c841eae6f10 100644 --- a/tests/libcxx/expected_results.txt +++ b/tests/libcxx/expected_results.txt @@ -208,184 +208,30 @@ std/utilities/tuple/tuple.tuple/tuple.apply/apply_large_arity.pass.cpp SKIPPED std/language.support/support.limits/support.limits.general/atomic.version.pass.cpp SKIPPED # C++20 P0355R7 " Calendars And Time Zones" -std/utilities/time/days.pass.cpp SKIPPED -std/utilities/time/months.pass.cpp SKIPPED -std/utilities/time/weeks.pass.cpp SKIPPED -std/utilities/time/years.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.day/types.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.day/time.cal.day.members/ctor.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.day/time.cal.day.members/decrement.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.day/time.cal.day.members/increment.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.day/time.cal.day.members/ok.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.day/time.cal.day.members/plus_minus_equal.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/comparisons.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/literals.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/minus.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/plus.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/streaming.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.last/types.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.md/types.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ctor.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.md/time.cal.md.members/day.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.md/time.cal.md.members/month.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ok.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/comparisons.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/streaming.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.mdlast/comparisons.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.mdlast/ctor.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.mdlast/month.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.mdlast/ok.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.mdlast/streaming.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.mdlast/types.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.month/types.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.month/time.cal.month.members/ctor.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.month/time.cal.month.members/decrement.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.month/time.cal.month.members/increment.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.month/time.cal.month.members/ok.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.month/time.cal.month.members/plus_minus_equal.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/comparisons.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/literals.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/minus.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/plus.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/streaming.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.mwd/types.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ctor.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/month.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ok.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/weekday_indexed.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/comparisons.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/streaming.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.mwdlast/types.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ctor.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/month.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ok.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/weekday_last.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/comparisons.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/streaming.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.operators/month_day.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.operators/month_day_last.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.operators/month_weekday.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.operators/month_weekday_last.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.operators/year_month.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.operators/year_month_day.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.operators/year_month_day_last.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.operators/year_month_weekday.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.operators/year_month_weekday_last.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.wdidx/types.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ctor.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/index.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ok.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/weekday.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/comparisons.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/streaming.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.wdlast/types.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/ctor.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/ok.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.members/weekday.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/comparisons.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/streaming.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.weekday/types.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/c_encoding.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.local_days.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.sys_days.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/decrement.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/increment.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/iso_encoding.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ok.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/operator[].pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/plus_minus_equal.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/comparisons.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/literals.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/minus.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/plus.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/streaming.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.year/types.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.year/time.cal.year.members/ctor.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.year/time.cal.year.members/decrement.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.year/time.cal.year.members/increment.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.year/time.cal.year.members/is_leap.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.year/time.cal.year.members/ok.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.year/time.cal.year.members/plus_minus.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.year/time.cal.year.members/plus_minus_equal.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/comparisons.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/literals.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/minus.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/plus.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/streaming.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ym/types.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/ctor.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/month.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/ok.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/plus_minus_equal_month.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/plus_minus_equal_year.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ym/time.cal.ym.members/year.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/comparisons.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/minus.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/plus.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/streaming.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymd/types.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.local_days.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.sys_days.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.year_month_day_last.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/day.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/month.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ok.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/plus_minus_equal_month.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/plus_minus_equal_year.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/year.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/comparisons.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/minus.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/plus.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/streaming.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/ctor.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/day.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/month.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/month_day_last.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/ok.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_local_days.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_sys_days.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/plus_minus_equal_month.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/plus_minus_equal_year.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/year.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/comparisons.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/minus.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/plus.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/streaming.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwd/types.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.local_days.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.sys_days.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/index.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/month.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ok.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.local_days.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/plus_minus_equal_month.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/plus_minus_equal_year.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/weekday.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/weekday_indexed.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/year.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/comparisons.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/minus.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/plus.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/streaming.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwdlast/types.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/ctor.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/month.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/ok.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_local_days.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_sys_days.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/plus_minus_equal_month.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/plus_minus_equal_year.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/weekday.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/year.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/comparisons.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/minus.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/plus.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/streaming.pass.cpp SKIPPED std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp SKIPPED std/utilities/time/time.clock/time.clock.file/file_time.pass.cpp SKIPPED diff --git a/tests/libcxx/skipped_tests.txt b/tests/libcxx/skipped_tests.txt index 20caf9c5777..418da770c6f 100644 --- a/tests/libcxx/skipped_tests.txt +++ b/tests/libcxx/skipped_tests.txt @@ -208,184 +208,40 @@ utilities\tuple\tuple.tuple\tuple.apply\apply_large_arity.pass.cpp language.support\support.limits\support.limits.general\atomic.version.pass.cpp # C++20 P0355R7 " Calendars And Time Zones" -utilities\time\days.pass.cpp -utilities\time\months.pass.cpp -utilities\time\weeks.pass.cpp -utilities\time\years.pass.cpp -utilities\time\time.cal\time.cal.day\types.pass.cpp -utilities\time\time.cal\time.cal.day\time.cal.day.members\ctor.pass.cpp -utilities\time\time.cal\time.cal.day\time.cal.day.members\decrement.pass.cpp -utilities\time\time.cal\time.cal.day\time.cal.day.members\increment.pass.cpp -utilities\time\time.cal\time.cal.day\time.cal.day.members\ok.pass.cpp -utilities\time\time.cal\time.cal.day\time.cal.day.members\plus_minus_equal.pass.cpp -utilities\time\time.cal\time.cal.day\time.cal.day.nonmembers\comparisons.pass.cpp -utilities\time\time.cal\time.cal.day\time.cal.day.nonmembers\literals.pass.cpp -utilities\time\time.cal\time.cal.day\time.cal.day.nonmembers\minus.pass.cpp -utilities\time\time.cal\time.cal.day\time.cal.day.nonmembers\plus.pass.cpp utilities\time\time.cal\time.cal.day\time.cal.day.nonmembers\streaming.pass.cpp -utilities\time\time.cal\time.cal.last\types.pass.cpp -utilities\time\time.cal\time.cal.md\types.pass.cpp -utilities\time\time.cal\time.cal.md\time.cal.md.members\ctor.pass.cpp -utilities\time\time.cal\time.cal.md\time.cal.md.members\day.pass.cpp -utilities\time\time.cal\time.cal.md\time.cal.md.members\month.pass.cpp -utilities\time\time.cal\time.cal.md\time.cal.md.members\ok.pass.cpp -utilities\time\time.cal\time.cal.md\time.cal.md.nonmembers\comparisons.pass.cpp utilities\time\time.cal\time.cal.md\time.cal.md.nonmembers\streaming.pass.cpp -utilities\time\time.cal\time.cal.mdlast\comparisons.pass.cpp -utilities\time\time.cal\time.cal.mdlast\ctor.pass.cpp -utilities\time\time.cal\time.cal.mdlast\month.pass.cpp -utilities\time\time.cal\time.cal.mdlast\ok.pass.cpp utilities\time\time.cal\time.cal.mdlast\streaming.pass.cpp -utilities\time\time.cal\time.cal.mdlast\types.pass.cpp -utilities\time\time.cal\time.cal.month\types.pass.cpp -utilities\time\time.cal\time.cal.month\time.cal.month.members\ctor.pass.cpp +# --month{14} should be 1 not 13 as the test expects utilities\time\time.cal\time.cal.month\time.cal.month.members\decrement.pass.cpp -utilities\time\time.cal\time.cal.month\time.cal.month.members\increment.pass.cpp -utilities\time\time.cal\time.cal.month\time.cal.month.members\ok.pass.cpp -utilities\time\time.cal\time.cal.month\time.cal.month.members\plus_minus_equal.pass.cpp +# C6294 Ill-defined for-loop: initial condition does not satisfy test utilities\time\time.cal\time.cal.month\time.cal.month.nonmembers\comparisons.pass.cpp -utilities\time\time.cal\time.cal.month\time.cal.month.nonmembers\literals.pass.cpp -utilities\time\time.cal\time.cal.month\time.cal.month.nonmembers\minus.pass.cpp -utilities\time\time.cal\time.cal.month\time.cal.month.nonmembers\plus.pass.cpp utilities\time\time.cal\time.cal.month\time.cal.month.nonmembers\streaming.pass.cpp -utilities\time\time.cal\time.cal.mwd\types.pass.cpp -utilities\time\time.cal\time.cal.mwd\time.cal.mwd.members\ctor.pass.cpp +# test is broken due to month_weekday not being default constructible utilities\time\time.cal\time.cal.mwd\time.cal.mwd.members\month.pass.cpp -utilities\time\time.cal\time.cal.mwd\time.cal.mwd.members\ok.pass.cpp -utilities\time\time.cal\time.cal.mwd\time.cal.mwd.members\weekday_indexed.pass.cpp -utilities\time\time.cal\time.cal.mwd\time.cal.mwd.nonmembers\comparisons.pass.cpp utilities\time\time.cal\time.cal.mwd\time.cal.mwd.nonmembers\streaming.pass.cpp -utilities\time\time.cal\time.cal.mwdlast\types.pass.cpp -utilities\time\time.cal\time.cal.mwdlast\time.cal.mwdlast.members\ctor.pass.cpp -utilities\time\time.cal\time.cal.mwdlast\time.cal.mwdlast.members\month.pass.cpp -utilities\time\time.cal\time.cal.mwdlast\time.cal.mwdlast.members\ok.pass.cpp -utilities\time\time.cal\time.cal.mwdlast\time.cal.mwdlast.members\weekday_last.pass.cpp -utilities\time\time.cal\time.cal.mwdlast\time.cal.mwdlast.nonmembers\comparisons.pass.cpp utilities\time\time.cal\time.cal.mwdlast\time.cal.mwdlast.nonmembers\streaming.pass.cpp -utilities\time\time.cal\time.cal.operators\month_day.pass.cpp -utilities\time\time.cal\time.cal.operators\month_day_last.pass.cpp -utilities\time\time.cal\time.cal.operators\month_weekday.pass.cpp -utilities\time\time.cal\time.cal.operators\month_weekday_last.pass.cpp -utilities\time\time.cal\time.cal.operators\year_month.pass.cpp -utilities\time\time.cal\time.cal.operators\year_month_day.pass.cpp -utilities\time\time.cal\time.cal.operators\year_month_day_last.pass.cpp -utilities\time\time.cal\time.cal.operators\year_month_weekday.pass.cpp -utilities\time\time.cal\time.cal.operators\year_month_weekday_last.pass.cpp -utilities\time\time.cal\time.cal.wdidx\types.pass.cpp -utilities\time\time.cal\time.cal.wdidx\time.cal.wdidx.members\ctor.pass.cpp -utilities\time\time.cal\time.cal.wdidx\time.cal.wdidx.members\index.pass.cpp -utilities\time\time.cal\time.cal.wdidx\time.cal.wdidx.members\ok.pass.cpp -utilities\time\time.cal\time.cal.wdidx\time.cal.wdidx.members\weekday.pass.cpp -utilities\time\time.cal\time.cal.wdidx\time.cal.wdidx.nonmembers\comparisons.pass.cpp utilities\time\time.cal\time.cal.wdidx\time.cal.wdidx.nonmembers\streaming.pass.cpp -utilities\time\time.cal\time.cal.wdlast\types.pass.cpp -utilities\time\time.cal\time.cal.wdlast\time.cal.wdlast.members\ctor.pass.cpp -utilities\time\time.cal\time.cal.wdlast\time.cal.wdlast.members\ok.pass.cpp -utilities\time\time.cal\time.cal.wdlast\time.cal.wdlast.members\weekday.pass.cpp -utilities\time\time.cal\time.cal.wdlast\time.cal.wdlast.nonmembers\comparisons.pass.cpp utilities\time\time.cal\time.cal.wdlast\time.cal.wdlast.nonmembers\streaming.pass.cpp -utilities\time\time.cal\time.cal.weekday\types.pass.cpp -utilities\time\time.cal\time.cal.weekday\time.cal.weekday.members\c_encoding.pass.cpp -utilities\time\time.cal\time.cal.weekday\time.cal.weekday.members\ctor.local_days.pass.cpp -utilities\time\time.cal\time.cal.weekday\time.cal.weekday.members\ctor.pass.cpp -utilities\time\time.cal\time.cal.weekday\time.cal.weekday.members\ctor.sys_days.pass.cpp -utilities\time\time.cal\time.cal.weekday\time.cal.weekday.members\decrement.pass.cpp -utilities\time\time.cal\time.cal.weekday\time.cal.weekday.members\increment.pass.cpp -utilities\time\time.cal\time.cal.weekday\time.cal.weekday.members\iso_encoding.pass.cpp -utilities\time\time.cal\time.cal.weekday\time.cal.weekday.members\ok.pass.cpp -utilities\time\time.cal\time.cal.weekday\time.cal.weekday.members\operator[].pass.cpp -utilities\time\time.cal\time.cal.weekday\time.cal.weekday.members\plus_minus_equal.pass.cpp -utilities\time\time.cal\time.cal.weekday\time.cal.weekday.nonmembers\comparisons.pass.cpp -utilities\time\time.cal\time.cal.weekday\time.cal.weekday.nonmembers\literals.pass.cpp +# C28301 No annotations for first declaration of 'printf' utilities\time\time.cal\time.cal.weekday\time.cal.weekday.nonmembers\minus.pass.cpp -utilities\time\time.cal\time.cal.weekday\time.cal.weekday.nonmembers\plus.pass.cpp utilities\time\time.cal\time.cal.weekday\time.cal.weekday.nonmembers\streaming.pass.cpp -utilities\time\time.cal\time.cal.year\types.pass.cpp -utilities\time\time.cal\time.cal.year\time.cal.year.members\ctor.pass.cpp -utilities\time\time.cal\time.cal.year\time.cal.year.members\decrement.pass.cpp -utilities\time\time.cal\time.cal.year\time.cal.year.members\increment.pass.cpp -utilities\time\time.cal\time.cal.year\time.cal.year.members\is_leap.pass.cpp -utilities\time\time.cal\time.cal.year\time.cal.year.members\ok.pass.cpp -utilities\time\time.cal\time.cal.year\time.cal.year.members\plus_minus.pass.cpp -utilities\time\time.cal\time.cal.year\time.cal.year.members\plus_minus_equal.pass.cpp -utilities\time\time.cal\time.cal.year\time.cal.year.nonmembers\comparisons.pass.cpp -utilities\time\time.cal\time.cal.year\time.cal.year.nonmembers\literals.pass.cpp +# C28301 No annotations for first declaration of 'printf' utilities\time\time.cal\time.cal.year\time.cal.year.nonmembers\minus.pass.cpp -utilities\time\time.cal\time.cal.year\time.cal.year.nonmembers\plus.pass.cpp utilities\time\time.cal\time.cal.year\time.cal.year.nonmembers\streaming.pass.cpp -utilities\time\time.cal\time.cal.ym\types.pass.cpp -utilities\time\time.cal\time.cal.ym\time.cal.ym.members\ctor.pass.cpp -utilities\time\time.cal\time.cal.ym\time.cal.ym.members\month.pass.cpp -utilities\time\time.cal\time.cal.ym\time.cal.ym.members\ok.pass.cpp -utilities\time\time.cal\time.cal.ym\time.cal.ym.members\plus_minus_equal_month.pass.cpp -utilities\time\time.cal\time.cal.ym\time.cal.ym.members\plus_minus_equal_year.pass.cpp -utilities\time\time.cal\time.cal.ym\time.cal.ym.members\year.pass.cpp +# C6294 Ill-defined for-loop: initial condition does not satisfy test utilities\time\time.cal\time.cal.ym\time.cal.ym.nonmembers\comparisons.pass.cpp -utilities\time\time.cal\time.cal.ym\time.cal.ym.nonmembers\minus.pass.cpp -utilities\time\time.cal\time.cal.ym\time.cal.ym.nonmembers\plus.pass.cpp utilities\time\time.cal\time.cal.ym\time.cal.ym.nonmembers\streaming.pass.cpp -utilities\time\time.cal\time.cal.ymd\types.pass.cpp -utilities\time\time.cal\time.cal.ymd\time.cal.ymd.members\ctor.local_days.pass.cpp -utilities\time\time.cal\time.cal.ymd\time.cal.ymd.members\ctor.pass.cpp -utilities\time\time.cal\time.cal.ymd\time.cal.ymd.members\ctor.sys_days.pass.cpp -utilities\time\time.cal\time.cal.ymd\time.cal.ymd.members\ctor.year_month_day_last.pass.cpp -utilities\time\time.cal\time.cal.ymd\time.cal.ymd.members\day.pass.cpp -utilities\time\time.cal\time.cal.ymd\time.cal.ymd.members\month.pass.cpp -utilities\time\time.cal\time.cal.ymd\time.cal.ymd.members\ok.pass.cpp -utilities\time\time.cal\time.cal.ymd\time.cal.ymd.members\op.local_days.pass.cpp -utilities\time\time.cal\time.cal.ymd\time.cal.ymd.members\op.sys_days.pass.cpp -utilities\time\time.cal\time.cal.ymd\time.cal.ymd.members\plus_minus_equal_month.pass.cpp -utilities\time\time.cal\time.cal.ymd\time.cal.ymd.members\plus_minus_equal_year.pass.cpp -utilities\time\time.cal\time.cal.ymd\time.cal.ymd.members\year.pass.cpp +# C6294 Ill-defined for-loop: initial condition does not satisfy test utilities\time\time.cal\time.cal.ymd\time.cal.ymd.nonmembers\comparisons.pass.cpp -utilities\time\time.cal\time.cal.ymd\time.cal.ymd.nonmembers\minus.pass.cpp -utilities\time\time.cal\time.cal.ymd\time.cal.ymd.nonmembers\plus.pass.cpp utilities\time\time.cal\time.cal.ymd\time.cal.ymd.nonmembers\streaming.pass.cpp -utilities\time\time.cal\time.cal.ymdlast\time.cal.ymdlast.members\ctor.pass.cpp -utilities\time\time.cal\time.cal.ymdlast\time.cal.ymdlast.members\day.pass.cpp -utilities\time\time.cal\time.cal.ymdlast\time.cal.ymdlast.members\month.pass.cpp -utilities\time\time.cal\time.cal.ymdlast\time.cal.ymdlast.members\month_day_last.pass.cpp -utilities\time\time.cal\time.cal.ymdlast\time.cal.ymdlast.members\ok.pass.cpp -utilities\time\time.cal\time.cal.ymdlast\time.cal.ymdlast.members\op_local_days.pass.cpp -utilities\time\time.cal\time.cal.ymdlast\time.cal.ymdlast.members\op_sys_days.pass.cpp -utilities\time\time.cal\time.cal.ymdlast\time.cal.ymdlast.members\plus_minus_equal_month.pass.cpp -utilities\time\time.cal\time.cal.ymdlast\time.cal.ymdlast.members\plus_minus_equal_year.pass.cpp -utilities\time\time.cal\time.cal.ymdlast\time.cal.ymdlast.members\year.pass.cpp +# C6294 Ill-defined for-loop: initial condition does not satisfy test utilities\time\time.cal\time.cal.ymdlast\time.cal.ymdlast.nonmembers\comparisons.pass.cpp -utilities\time\time.cal\time.cal.ymdlast\time.cal.ymdlast.nonmembers\minus.pass.cpp -utilities\time\time.cal\time.cal.ymdlast\time.cal.ymdlast.nonmembers\plus.pass.cpp utilities\time\time.cal\time.cal.ymdlast\time.cal.ymdlast.nonmembers\streaming.pass.cpp -utilities\time\time.cal\time.cal.ymwd\types.pass.cpp -utilities\time\time.cal\time.cal.ymwd\time.cal.ymwd.members\ctor.local_days.pass.cpp -utilities\time\time.cal\time.cal.ymwd\time.cal.ymwd.members\ctor.pass.cpp -utilities\time\time.cal\time.cal.ymwd\time.cal.ymwd.members\ctor.sys_days.pass.cpp -utilities\time\time.cal\time.cal.ymwd\time.cal.ymwd.members\index.pass.cpp -utilities\time\time.cal\time.cal.ymwd\time.cal.ymwd.members\month.pass.cpp -utilities\time\time.cal\time.cal.ymwd\time.cal.ymwd.members\ok.pass.cpp -utilities\time\time.cal\time.cal.ymwd\time.cal.ymwd.members\op.local_days.pass.cpp -utilities\time\time.cal\time.cal.ymwd\time.cal.ymwd.members\op.sys_days.pass.cpp -utilities\time\time.cal\time.cal.ymwd\time.cal.ymwd.members\plus_minus_equal_month.pass.cpp -utilities\time\time.cal\time.cal.ymwd\time.cal.ymwd.members\plus_minus_equal_year.pass.cpp -utilities\time\time.cal\time.cal.ymwd\time.cal.ymwd.members\weekday.pass.cpp -utilities\time\time.cal\time.cal.ymwd\time.cal.ymwd.members\weekday_indexed.pass.cpp -utilities\time\time.cal\time.cal.ymwd\time.cal.ymwd.members\year.pass.cpp +# C6294 Ill-defined for-loop: initial condition does not satisfy test utilities\time\time.cal\time.cal.ymwd\time.cal.ymwd.nonmembers\comparisons.pass.cpp -utilities\time\time.cal\time.cal.ymwd\time.cal.ymwd.nonmembers\minus.pass.cpp -utilities\time\time.cal\time.cal.ymwd\time.cal.ymwd.nonmembers\plus.pass.cpp utilities\time\time.cal\time.cal.ymwd\time.cal.ymwd.nonmembers\streaming.pass.cpp -utilities\time\time.cal\time.cal.ymwdlast\types.pass.cpp -utilities\time\time.cal\time.cal.ymwdlast\time.cal.ymwdlast.members\ctor.pass.cpp -utilities\time\time.cal\time.cal.ymwdlast\time.cal.ymwdlast.members\month.pass.cpp -utilities\time\time.cal\time.cal.ymwdlast\time.cal.ymwdlast.members\ok.pass.cpp -utilities\time\time.cal\time.cal.ymwdlast\time.cal.ymwdlast.members\op_local_days.pass.cpp -utilities\time\time.cal\time.cal.ymwdlast\time.cal.ymwdlast.members\op_sys_days.pass.cpp -utilities\time\time.cal\time.cal.ymwdlast\time.cal.ymwdlast.members\plus_minus_equal_month.pass.cpp -utilities\time\time.cal\time.cal.ymwdlast\time.cal.ymwdlast.members\plus_minus_equal_year.pass.cpp -utilities\time\time.cal\time.cal.ymwdlast\time.cal.ymwdlast.members\weekday.pass.cpp -utilities\time\time.cal\time.cal.ymwdlast\time.cal.ymwdlast.members\year.pass.cpp +# C6294 Ill-defined for-loop: initial condition does not satisfy test utilities\time\time.cal\time.cal.ymwdlast\time.cal.ymwdlast.nonmembers\comparisons.pass.cpp -utilities\time\time.cal\time.cal.ymwdlast\time.cal.ymwdlast.nonmembers\minus.pass.cpp -utilities\time\time.cal\time.cal.ymwdlast\time.cal.ymwdlast.nonmembers\plus.pass.cpp utilities\time\time.cal\time.cal.ymwdlast\time.cal.ymwdlast.nonmembers\streaming.pass.cpp utilities\time\time.clock\time.clock.file\consistency.pass.cpp utilities\time\time.clock\time.clock.file\file_time.pass.cpp From 821be19b6bd0ce326c7a08f25e37595a95485df8 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Fri, 17 Apr 2020 11:31:48 +0100 Subject: [PATCH 058/143] Add missing noexcept --- stl/inc/chrono | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 5ce3f72b675..2b02b25d698 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1061,10 +1061,10 @@ namespace chrono { } }; - constexpr bool operator==(const month_day_last& _Left, const month_day_last& _Right) { + constexpr bool operator==(const month_day_last& _Left, const month_day_last& _Right) noexcept { return _Left.month() == _Right.month(); } - constexpr strong_ordering operator<=>(const month_day_last& _Left, const month_day_last& _Right) { + constexpr strong_ordering operator<=>(const month_day_last& _Left, const month_day_last& _Right) noexcept { return _Left.month() <=> _Right.month(); } @@ -1088,7 +1088,7 @@ namespace chrono { } }; - constexpr bool operator==(const month_weekday& _Left, const month_weekday& _Right) { + constexpr bool operator==(const month_weekday& _Left, const month_weekday& _Right) noexcept { return _Left.month() == _Right.month() && _Left.weekday_indexed() == _Right.weekday_indexed(); } From 3d2e8155afedad488c90597bc525b2cd0e73db8b Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sat, 18 Apr 2020 10:30:02 +0100 Subject: [PATCH 059/143] Missed year_month_day_last::ok() Add additional !ok() tests to year_month_weekday --- .../tests/P0355R7_calendars_and_time_zones_dates/test.cpp | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 3a667dbabc0..dab47000b9b 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -490,6 +490,8 @@ constexpr void year_month_weekday_test() { assert((2020y / April / Wednesday[5]).ok()); + assert(!(-32768y / April / Wednesday[1]).ok()); + assert(!(2020y / month{0} / Wednesday[1]).ok()); assert(!(2020y / April / Tuesday[5]).ok()); assert(ymwd + months{2} == 2020y / June / Tuesday[2]); @@ -524,6 +526,11 @@ constexpr void year_month_weekday_last_test() { assert((static_cast(ymwdl) == sys_days{days{18'288}})); assert((static_cast(ymwdl) == local_days{ymwdl})); + assert((2020y / April / Wednesday[last]).ok()); + assert(!(-32768y / April / Wednesday[last]).ok()); + assert(!(2020y / month{0} / Wednesday[last]).ok()); + assert(!(2020y / April / weekday{8}[last]).ok()); + assert(ymwdl + months{2} == 2020y / March / Monday[last]); assert(months{2} + ymwdl == 2020y / March / Monday[last]); From 6c2ef283d0fefabed901738de041f62ae62e68fa Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sat, 18 Apr 2020 10:50:01 +0100 Subject: [PATCH 060/143] Move commented out tests to their own function --- .../test.cpp | 118 +++++++++--------- 1 file changed, 58 insertions(+), 60 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index dab47000b9b..f59d59e7e5d 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -238,21 +238,6 @@ constexpr void month_weekday_test() { assert(mwd1.weekday_indexed().weekday() == Monday); assert(mwd1.weekday_indexed().index() == 2); - // error C2131: expression did not evaluate to a constant - // failure was caused by evaluation exceeding step limit of 1048576 - // for (unsigned m = 0; m <= 255; ++m) { - // for (unsigned wd = 0; wd <= 255; ++wd) { - // for (unsigned wdi = 0; wdi <= 6; ++wdi) { - // const month_weekday mwd2{month{m}, weekday_indexed{weekday{wd}, wdi}}; - // if (m >= 1 && m <= 12 && wd <= 7 && wdi >= 1 && wdi <= 5) { - // assert(mwd2.ok()); - // } else { - // assert(!mwd2.ok()); - // } - // } - // } - //} - assert(January / Monday[2] == January / Monday[2]); } @@ -282,19 +267,6 @@ constexpr void year_month_test() { assert(ym.year() == 2020y); assert(ym.month() == January); - // error C2131: expression did not evaluate to a constant - // failure was caused by evaluation exceeding step limit of 1048576 - // for (int i = static_cast(year::min()); i <= static_cast(year::max()); i++) { - // for (unsigned j = 0; j <= 255; ++j) { - // const year_month ym_is{year{i}, month{j}}; - // if (j >= 1 && j <= 12) { - // assert(ym_is.ok()); - // } else { - // assert(!ym_is.ok()); - // } - // } - //} - assert(2020y / April == 2020y / April); assert(2019y / April < 2020y / April); assert(2020y / March < 2020y / April); @@ -362,24 +334,6 @@ constexpr void year_month_day_test() { assert(static_cast(ymld) == local_days{}); - // constexpr int y_min = static_cast(year::min()); - // constexpr int y_max = static_cast(year::max()); - - // for (int iy = y_min; iy <= y_max; ++iy) { - // for (auto um = 0u; um <= 255u; ++um) { - // for (auto ud = 0u; ud <= 32u; ++ud) { - // year y{iy}; - // month m{um}; - // day d{ud}; - // if (y.ok() && m.ok() && d >= 1d && d <= (y / m / last).day()) { - // assert(((y / m / d).ok())); - // } else { - // assert((!(y / m / d).ok())); - // } - // } - // } - //} - assert(2020y / January / 1d == 2020y / January / 1d); assert(2019y / January / 1d < 2020y / January / 1d); assert(2020y / January / 1d < 2020y / February / 1d); @@ -426,20 +380,6 @@ constexpr void year_month_day_last_test() { assert(2020y / April / last == sys_days{days{18'382}}); assert(static_cast(ymdl) == local_days{ymdl}); - // constexpr int y_min = static_cast(year::min()); - // constexpr int y_max = static_cast(year::max()); - // for (int iy = y_min; iy <= y_max; ++iy) { - // for (unsigned m = 0; m <= 255; ++m) { - // year y{iy}; - // month_day_last mdl{month{m}}; - // if (y.ok() && mdl.ok()) { - // assert((year_month_day_last{y, mdl}.ok())); - // } else { - // assert((!year_month_day_last{y, mdl}.ok())); - // } - // } - //} - assert(ymdl < 2021y / February / last); assert(ymdl < 2020y / March / last); assert(2021y / February / last > ymdl); @@ -561,7 +501,65 @@ constexpr bool test() { return true; } +void ok_test() { + // month_weekday + for (auto m = 0u; m <= 255u; ++m) { + for (auto wd = 0u; wd <= 255u; ++wd) { + for (auto wdi = 0u; wdi <= 6u; ++wdi) { + const auto mwd = month{m} / weekday{wd}[wdi]; + if (m >= 1 && m <= 12 && wd <= 7 && wdi >= 1 && wdi <= 5) { + assert(mwd.ok()); + } else { + assert(!mwd.ok()); + } + } + } + } + // year_month + constexpr int y_min = static_cast(year::min()); + constexpr int y_max = static_cast(year::max()); + + for (int y = y_min; y <= y_max; y++) { + for (auto m = 0u; m <= 255u; ++m) { + const auto ym = year{y} / month{m}; + if (m >= 1 && m <= 12) { + assert(ym.ok()); + } else { + assert(!ym.ok()); + } + } + } + // year_month_day + for (int iy = y_min; iy <= y_max; ++iy) { + for (auto um = 0u; um <= 255u; ++um) { + for (auto ud = 0u; ud <= 32u; ++ud) { + const year y{iy}; + const month m{um}; + const day d{ud}; + if (y.ok() && m.ok() && d >= 1d && d <= (y / m / last).day()) { + assert(((y / m / d).ok())); + } else { + assert((!(y / m / d).ok())); + } + } + } + } + // year_month_day_last + for (int iy = y_min; iy <= y_max; ++iy) { + for (auto m = 0u; m <= 255u; ++m) { + const year y{iy}; + const auto mdl = month{m} / last; + if (y.ok() && mdl.ok()) { + assert((y / mdl).ok()); + } else { + assert((!(y/ mdl).ok())); + } + } + } +} + int main() { test(); + ok_test(); // tests fail to compile in constexpr static_assert(test()); } From 6a1d6d7abaed63b9fde4227a825735444c2c8ee4 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sat, 18 Apr 2020 13:18:53 +0100 Subject: [PATCH 061/143] Whoops --- tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index f59d59e7e5d..d93fed5dd6d 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -552,7 +552,7 @@ void ok_test() { if (y.ok() && mdl.ok()) { assert((y / mdl).ok()); } else { - assert((!(y/ mdl).ok())); + assert((!(y / mdl).ok())); } } } From 4eea65755479dac95c43b54fcf1fe9136e9cba5a Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Tue, 21 Apr 2020 10:06:23 +0100 Subject: [PATCH 062/143] Unskip C6294 failing libcxx tests --- tests/libcxx/expected_results.txt | 6 ------ tests/libcxx/skipped_tests.txt | 12 ------------ 2 files changed, 18 deletions(-) diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt index c841eae6f10..193a96d7d3b 100644 --- a/tests/libcxx/expected_results.txt +++ b/tests/libcxx/expected_results.txt @@ -212,7 +212,6 @@ std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/streaming.pass. std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/streaming.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.mdlast/streaming.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.month/time.cal.month.members/decrement.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/comparisons.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/streaming.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/month.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/streaming.pass.cpp SKIPPED @@ -223,15 +222,10 @@ std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/minus.p std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/streaming.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/minus.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/streaming.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/comparisons.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/streaming.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/comparisons.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/streaming.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/comparisons.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/streaming.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/comparisons.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/streaming.pass.cpp SKIPPED -std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/comparisons.pass.cpp SKIPPED std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/streaming.pass.cpp SKIPPED std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp SKIPPED std/utilities/time/time.clock/time.clock.file/file_time.pass.cpp SKIPPED diff --git a/tests/libcxx/skipped_tests.txt b/tests/libcxx/skipped_tests.txt index 418da770c6f..5345ff05089 100644 --- a/tests/libcxx/skipped_tests.txt +++ b/tests/libcxx/skipped_tests.txt @@ -213,8 +213,6 @@ utilities\time\time.cal\time.cal.md\time.cal.md.nonmembers\streaming.pass.cpp utilities\time\time.cal\time.cal.mdlast\streaming.pass.cpp # --month{14} should be 1 not 13 as the test expects utilities\time\time.cal\time.cal.month\time.cal.month.members\decrement.pass.cpp -# C6294 Ill-defined for-loop: initial condition does not satisfy test -utilities\time\time.cal\time.cal.month\time.cal.month.nonmembers\comparisons.pass.cpp utilities\time\time.cal\time.cal.month\time.cal.month.nonmembers\streaming.pass.cpp # test is broken due to month_weekday not being default constructible utilities\time\time.cal\time.cal.mwd\time.cal.mwd.members\month.pass.cpp @@ -228,20 +226,10 @@ utilities\time\time.cal\time.cal.weekday\time.cal.weekday.nonmembers\streaming.p # C28301 No annotations for first declaration of 'printf' utilities\time\time.cal\time.cal.year\time.cal.year.nonmembers\minus.pass.cpp utilities\time\time.cal\time.cal.year\time.cal.year.nonmembers\streaming.pass.cpp -# C6294 Ill-defined for-loop: initial condition does not satisfy test -utilities\time\time.cal\time.cal.ym\time.cal.ym.nonmembers\comparisons.pass.cpp utilities\time\time.cal\time.cal.ym\time.cal.ym.nonmembers\streaming.pass.cpp -# C6294 Ill-defined for-loop: initial condition does not satisfy test -utilities\time\time.cal\time.cal.ymd\time.cal.ymd.nonmembers\comparisons.pass.cpp utilities\time\time.cal\time.cal.ymd\time.cal.ymd.nonmembers\streaming.pass.cpp -# C6294 Ill-defined for-loop: initial condition does not satisfy test -utilities\time\time.cal\time.cal.ymdlast\time.cal.ymdlast.nonmembers\comparisons.pass.cpp utilities\time\time.cal\time.cal.ymdlast\time.cal.ymdlast.nonmembers\streaming.pass.cpp -# C6294 Ill-defined for-loop: initial condition does not satisfy test -utilities\time\time.cal\time.cal.ymwd\time.cal.ymwd.nonmembers\comparisons.pass.cpp utilities\time\time.cal\time.cal.ymwd\time.cal.ymwd.nonmembers\streaming.pass.cpp -# C6294 Ill-defined for-loop: initial condition does not satisfy test -utilities\time\time.cal\time.cal.ymwdlast\time.cal.ymwdlast.nonmembers\comparisons.pass.cpp utilities\time\time.cal\time.cal.ymwdlast\time.cal.ymwdlast.nonmembers\streaming.pass.cpp utilities\time\time.clock\time.clock.file\consistency.pass.cpp utilities\time\time.clock\time.clock.file\file_time.pass.cpp From 2c87c56e5e447c8ae31d47ddd697ba0fe5e707a2 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Thu, 23 Apr 2020 08:53:07 +0100 Subject: [PATCH 063/143] Suppress C6294 in tests --- tests/libcxx/usual_matrix.lst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/libcxx/usual_matrix.lst b/tests/libcxx/usual_matrix.lst index e27596e499a..60647c066b2 100644 --- a/tests/libcxx/usual_matrix.lst +++ b/tests/libcxx/usual_matrix.lst @@ -3,5 +3,5 @@ PM_CL="/nologo /Od /W4 /w14061 /w14242 /w14265 /w14582 /w14583 /w14587 /w14588 /wd4643 /w14749 /w14841 /w14842 /w15038 /w15214 /w15215 /w15216 /w15217 /sdl /WX /Zc:strictStrings /D_ENABLE_STL_INTERNAL_CHECK /bigobj /FImsvc_stdlib_force_include.h /permissive-" RUNALL_CROSSLIST -PM_CL="/EHsc /MTd /D_ITERATOR_DEBUG_LEVEL=2 /std:c++latest /analyze" +PM_CL="/EHsc /MTd /D_ITERATOR_DEBUG_LEVEL=2 /std:c++latest /analyze /wd6294" PM_COMPILER="clang-cl" PM_CL="-fno-ms-compatibility -fno-delayed-template-parsing /EHsc /MTd /std:c++latest" From 0c3620c1388d8a86ad225124ea364d77e9b0d982 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Tue, 19 May 2020 10:35:17 +0100 Subject: [PATCH 064/143] Failing minus tests now pass. --- tests/libcxx/expected_results.txt | 2 -- tests/libcxx/skipped_tests.txt | 4 ---- 2 files changed, 6 deletions(-) diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt index d06248adb32..084543df96c 100644 --- a/tests/libcxx/expected_results.txt +++ b/tests/libcxx/expected_results.txt @@ -263,9 +263,7 @@ std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/streaming.pass. std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/streaming.pass.cpp FAIL std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/streaming.pass.cpp FAIL std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/streaming.pass.cpp FAIL -std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/minus.pass.cpp FAIL std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/streaming.pass.cpp FAIL -std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/minus.pass.cpp FAIL std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/streaming.pass.cpp FAIL std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/streaming.pass.cpp FAIL std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/streaming.pass.cpp FAIL diff --git a/tests/libcxx/skipped_tests.txt b/tests/libcxx/skipped_tests.txt index 179048219dd..a2db2509070 100644 --- a/tests/libcxx/skipped_tests.txt +++ b/tests/libcxx/skipped_tests.txt @@ -265,11 +265,7 @@ utilities\time\time.cal\time.cal.mwd\time.cal.mwd.nonmembers\streaming.pass.cpp utilities\time\time.cal\time.cal.mwdlast\time.cal.mwdlast.nonmembers\streaming.pass.cpp utilities\time\time.cal\time.cal.wdidx\time.cal.wdidx.nonmembers\streaming.pass.cpp utilities\time\time.cal\time.cal.wdlast\time.cal.wdlast.nonmembers\streaming.pass.cpp -# C28301 No annotations for first declaration of 'printf' -utilities\time\time.cal\time.cal.weekday\time.cal.weekday.nonmembers\minus.pass.cpp utilities\time\time.cal\time.cal.weekday\time.cal.weekday.nonmembers\streaming.pass.cpp -# C28301 No annotations for first declaration of 'printf' -utilities\time\time.cal\time.cal.year\time.cal.year.nonmembers\minus.pass.cpp utilities\time\time.cal\time.cal.year\time.cal.year.nonmembers\streaming.pass.cpp utilities\time\time.cal\time.cal.ym\time.cal.ym.nonmembers\streaming.pass.cpp utilities\time\time.cal\time.cal.ymd\time.cal.ymd.nonmembers\streaming.pass.cpp From fc7dc137d91b65ffd8d0edded31d5d0811db2beb Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Tue, 19 May 2020 10:43:05 +0100 Subject: [PATCH 065/143] I want to pass --- tests/libcxx/usual_matrix.lst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/libcxx/usual_matrix.lst b/tests/libcxx/usual_matrix.lst index 60647c066b2..27cc3160d6f 100644 --- a/tests/libcxx/usual_matrix.lst +++ b/tests/libcxx/usual_matrix.lst @@ -3,5 +3,5 @@ PM_CL="/nologo /Od /W4 /w14061 /w14242 /w14265 /w14582 /w14583 /w14587 /w14588 /wd4643 /w14749 /w14841 /w14842 /w15038 /w15214 /w15215 /w15216 /w15217 /sdl /WX /Zc:strictStrings /D_ENABLE_STL_INTERNAL_CHECK /bigobj /FImsvc_stdlib_force_include.h /permissive-" RUNALL_CROSSLIST -PM_CL="/EHsc /MTd /D_ITERATOR_DEBUG_LEVEL=2 /std:c++latest /analyze /wd6294" +PM_CL="/EHsc /MTd /D_ITERATOR_DEBUG_LEVEL=2 /std:c++latest /analyze /wd6294 /wd28301" PM_COMPILER="clang-cl" PM_CL="-fno-ms-compatibility -fno-delayed-template-parsing /EHsc /MTd /std:c++latest" From ae9d2b37cd35e33af99a6f7b8f08339c08f9d2f7 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Tue, 19 May 2020 12:08:50 +0100 Subject: [PATCH 066/143] Gimme the green --- tests/libcxx/expected_results.txt | 3 --- tests/libcxx/skipped_tests.txt | 3 --- 2 files changed, 6 deletions(-) diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt index 084543df96c..db63463921c 100644 --- a/tests/libcxx/expected_results.txt +++ b/tests/libcxx/expected_results.txt @@ -274,9 +274,6 @@ std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp FAIL std/utilities/time/time.clock/time.clock.file/file_time.pass.cpp FAIL std/utilities/time/time.clock/time.clock.file/now.pass.cpp FAIL std/utilities/time/time.clock/time.clock.file/rep_signed.pass.cpp FAIL -std/utilities/time/time.clock/time.clock.system/local_time.types.pass.cpp FAIL -std/utilities/time/time.clock/time.clock.system/sys.time.types.pass.cpp FAIL -std/utilities/time/time.duration/time.duration.literals/literals1.pass.cpp FAIL std/utilities/time/time.hms/time.12/is_am.pass.cpp FAIL std/utilities/time/time.hms/time.12/is_pm.pass.cpp FAIL std/utilities/time/time.hms/time.12/make12.pass.cpp FAIL diff --git a/tests/libcxx/skipped_tests.txt b/tests/libcxx/skipped_tests.txt index a2db2509070..b09e3a82319 100644 --- a/tests/libcxx/skipped_tests.txt +++ b/tests/libcxx/skipped_tests.txt @@ -276,9 +276,6 @@ utilities\time\time.clock\time.clock.file\consistency.pass.cpp utilities\time\time.clock\time.clock.file\file_time.pass.cpp utilities\time\time.clock\time.clock.file\now.pass.cpp utilities\time\time.clock\time.clock.file\rep_signed.pass.cpp -utilities\time\time.clock\time.clock.system\local_time.types.pass.cpp -utilities\time\time.clock\time.clock.system\sys.time.types.pass.cpp -utilities\time\time.duration\time.duration.literals\literals1.pass.cpp utilities\time\time.hms\time.12\is_am.pass.cpp utilities\time\time.hms\time.12\is_pm.pass.cpp utilities\time\time.hms\time.12\make12.pass.cpp From 1dc58e5a1d2c33b0522d4e83ae2effdeeaec6fc3 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Tue, 25 Aug 2020 07:51:13 +0100 Subject: [PATCH 067/143] Forgot to re-disable warnings --- tests/libcxx/usual_matrix.lst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/libcxx/usual_matrix.lst b/tests/libcxx/usual_matrix.lst index 5fa9799fff4..ddfdc6c81d9 100644 --- a/tests/libcxx/usual_matrix.lst +++ b/tests/libcxx/usual_matrix.lst @@ -3,7 +3,7 @@ RUNALL_INCLUDE ..\universal_prefix.lst RUNALL_CROSSLIST -PM_CL="/EHsc /MTd /std:c++latest /permissive- /FImsvc_stdlib_force_include.h /wd4643" +PM_CL="/EHsc /MTd /std:c++latest /permissive- /FImsvc_stdlib_force_include.h /wd4643 /wd6294 /wd28301" RUNALL_CROSSLIST PM_CL="/analyze /Zc:preprocessor" PM_COMPILER="clang-cl" PM_CL="-fno-ms-compatibility -fno-delayed-template-parsing" From af2938586f1376794a77edecd4b15d2069a6d2aa Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Tue, 25 Aug 2020 10:00:22 +0100 Subject: [PATCH 068/143] Add static_cast --- stl/inc/chrono | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index c33c814d963..469e68d14c3 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1455,7 +1455,7 @@ namespace chrono { _NODISCARD constexpr operator sys_days() const noexcept { const sys_days _First = year_month_day{_Year, _Month, day{1}}; const days _Diff = weekday() - chrono::weekday{_First}; - const days _Days = _Diff + days{(index() - 1) * 7}; + const days _Days = _Diff + days{(static_cast(index()) - 1) * 7}; return _First + _Days; } _NODISCARD constexpr explicit operator local_days() const noexcept { From 0cd307248ea14d1fb5c1645be27412470773d867 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Tue, 25 Aug 2020 10:23:12 +0100 Subject: [PATCH 069/143] Use is_constant_evaluated() --- .../test.cpp | 122 +++++++++--------- 1 file changed, 62 insertions(+), 60 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index d93fed5dd6d..0797d83df18 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -8,6 +8,9 @@ using namespace std; using namespace std::chrono; +constexpr int y_min = -32767; +constexpr int y_max = 32767; + constexpr void day_test() { day d{0u}; assert(static_cast(d) == 0u); @@ -95,8 +98,6 @@ constexpr void year_test() { assert(+y == 1y); assert(-y == -1y); - constexpr int y_min = -32767; - constexpr int y_max = 32767; assert(year::min() == year{y_min}); assert(year::max() == year{y_max}); @@ -239,6 +240,21 @@ constexpr void month_weekday_test() { assert(mwd1.weekday_indexed().index() == 2); assert(January / Monday[2] == January / Monday[2]); + + if (!is_constant_evaluated()) { + for (auto m = 0u; m <= 255u; ++m) { + for (auto wd = 0u; wd <= 255u; ++wd) { + for (auto wdi = 0u; wdi <= 6u; ++wdi) { + const auto mwd = month{m} / weekday{wd}[wdi]; + if (m >= 1 && m <= 12 && wd <= 7 && wdi >= 1 && wdi <= 5) { + assert(mwd.ok()); + } else { + assert(!mwd.ok()); + } + } + } + } + } } constexpr void month_weekday_last_test() { @@ -284,6 +300,19 @@ constexpr void year_month_test() { assert(years{2} + ym == 2022y / January); assert(ym - years{2} == 2018y / January); + + if (!is_constant_evaluated()) { + for (int y = y_min; y <= y_max; y++) { + for (auto m = 0u; m <= 255u; ++m) { + const auto ym2 = year{y} / month{m}; + if (m >= 1 && m <= 12) { + assert(ym2.ok()); + } else { + assert(!ym2.ok()); + } + } + } + } } constexpr void year_month_day_test() { @@ -354,6 +383,23 @@ constexpr void year_month_day_test() { assert(years{2} + 2020y / January / 1d == 2022y / January / 1d); assert(2020y / January / 1d - years{2} == 2018y / January / 1d); + + if (!is_constant_evaluated()) { + for (int iy = y_min; iy <= y_max; ++iy) { + for (auto um = 0u; um <= 255u; ++um) { + for (auto ud = 0u; ud <= 32u; ++ud) { + const year y{iy}; + const month m{um}; + const day d{ud}; + if (y.ok() && m.ok() && d >= 1d && d <= (y / m / last).day()) { + assert(((y / m / d).ok())); + } else { + assert((!(y / m / d).ok())); + } + } + } + } + } } constexpr void year_month_day_last_test() { @@ -394,6 +440,20 @@ constexpr void year_month_day_last_test() { assert(years{2} + ymdl == 2022y / February / last); assert(ymdl - years{2} == 2018y / February / last); + + if (!is_constant_evaluated()) { + for (int iy = y_min; iy <= y_max; ++iy) { + for (auto m = 0u; m <= 255u; ++m) { + const year y{iy}; + const auto mdl = month{m} / last; + if (y.ok() && mdl.ok()) { + assert((y / mdl).ok()); + } else { + assert((!(y / mdl).ok())); + } + } + } + } } constexpr void year_month_weekday_test() { @@ -501,65 +561,7 @@ constexpr bool test() { return true; } -void ok_test() { - // month_weekday - for (auto m = 0u; m <= 255u; ++m) { - for (auto wd = 0u; wd <= 255u; ++wd) { - for (auto wdi = 0u; wdi <= 6u; ++wdi) { - const auto mwd = month{m} / weekday{wd}[wdi]; - if (m >= 1 && m <= 12 && wd <= 7 && wdi >= 1 && wdi <= 5) { - assert(mwd.ok()); - } else { - assert(!mwd.ok()); - } - } - } - } - // year_month - constexpr int y_min = static_cast(year::min()); - constexpr int y_max = static_cast(year::max()); - - for (int y = y_min; y <= y_max; y++) { - for (auto m = 0u; m <= 255u; ++m) { - const auto ym = year{y} / month{m}; - if (m >= 1 && m <= 12) { - assert(ym.ok()); - } else { - assert(!ym.ok()); - } - } - } - // year_month_day - for (int iy = y_min; iy <= y_max; ++iy) { - for (auto um = 0u; um <= 255u; ++um) { - for (auto ud = 0u; ud <= 32u; ++ud) { - const year y{iy}; - const month m{um}; - const day d{ud}; - if (y.ok() && m.ok() && d >= 1d && d <= (y / m / last).day()) { - assert(((y / m / d).ok())); - } else { - assert((!(y / m / d).ok())); - } - } - } - } - // year_month_day_last - for (int iy = y_min; iy <= y_max; ++iy) { - for (auto m = 0u; m <= 255u; ++m) { - const year y{iy}; - const auto mdl = month{m} / last; - if (y.ok() && mdl.ok()) { - assert((y / mdl).ok()); - } else { - assert((!(y / mdl).ok())); - } - } - } -} - int main() { test(); - ok_test(); // tests fail to compile in constexpr static_assert(test()); } From 00c40f47c80df97c7416f37e5e18396851e03b85 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Wed, 26 Aug 2020 04:29:38 +0100 Subject: [PATCH 070/143] review comments --- stl/inc/chrono | 269 +++++++++++++++++++++++++++++-------------------- 1 file changed, 159 insertions(+), 110 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 469e68d14c3..3aac1ab2acc 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -669,8 +669,6 @@ namespace chrono { inline constexpr last_spec last{}; class day { - unsigned char _Day; - public: day() = default; constexpr explicit day(unsigned _Val) noexcept : _Day{static_cast(_Val)} {} @@ -705,6 +703,9 @@ namespace chrono { _NODISCARD constexpr bool ok() const noexcept { return _Day >= 1 && _Day <= 31; } + + private: + unsigned char _Day; }; constexpr bool operator==(const day& _Left, const day& _Right) noexcept { @@ -728,8 +729,6 @@ namespace chrono { } class month { - unsigned char _Month; - public: month() = default; constexpr explicit month(unsigned _Val) noexcept : _Month{static_cast(_Val)} {} @@ -762,6 +761,9 @@ namespace chrono { _NODISCARD constexpr bool ok() const noexcept { return _Month >= 1 && _Month <= 12; } + + private: + unsigned char _Month; }; constexpr bool operator==(const month& _Left, const month& _Right) noexcept { @@ -772,9 +774,9 @@ namespace chrono { } constexpr month operator+(const month& _Left, const months& _Right) noexcept { - const auto _M = static_cast(static_cast(_Left)) + (_Right.count() - 1); - const auto _Div = (_M >= 0 ? _M : _M - 11) / 12; - return month{static_cast(_M - _Div * 12 + 1)}; + const auto _Mo = static_cast(static_cast(_Left)) + (_Right.count() - 1); + const auto _Div = (_Mo >= 0 ? _Mo : _Mo - 11) / 12; + return month{static_cast(_Mo - _Div * 12 + 1)}; } constexpr month operator+(const months& _Left, const month& _Right) noexcept { return _Right + _Left; @@ -783,8 +785,8 @@ namespace chrono { return _Left + -_Right; } constexpr months operator-(const month& _Left, const month& _Right) noexcept { - const auto _M = static_cast(_Left) - static_cast(_Right); - return months{_M <= 11 ? _M : _M + 12}; + const auto _Mo = static_cast(_Left) - static_cast(_Right); + return months{_Mo <= 11 ? _Mo : _Mo + 12}; } constexpr month& month::operator+=(const months& _Months) noexcept { @@ -797,10 +799,6 @@ namespace chrono { } class year { - short _Year; - constexpr static int _Ymin = -32767; - constexpr static int _Ymax = 32767; - public: year() = default; constexpr explicit year(int _Val) noexcept : _Year{static_cast(_Val)} {} @@ -845,15 +843,20 @@ namespace chrono { } _NODISCARD constexpr bool ok() const noexcept { - return _Ymin <= _Year && _Year <= _Ymax; + return _Year_min <= _Year && _Year <= _Year_max; } _NODISCARD static constexpr year(min)() noexcept { - return year{_Ymin}; + return year{_Year_min}; } _NODISCARD static constexpr year(max)() noexcept { - return year{_Ymax}; + return year{_Year_max}; } + + private: + short _Year; + static constexpr int _Year_min = -32767; + static constexpr int _Year_max = 32767; }; constexpr bool operator==(const year& _Left, const year& _Right) noexcept { @@ -877,14 +880,6 @@ namespace chrono { } class weekday { - unsigned char _Weekday; - - // courtesy of Howard Hinnant - // https://howardhinnant.github.io/date_algorithms.html#weekday_from_days - _NODISCARD static constexpr unsigned _Weekday_from_days(int _Tp) noexcept { - return static_cast(_Tp >= -4 ? (_Tp + 4) % 7 : (_Tp + 5) % 7 + 6); - } - public: weekday() = default; constexpr explicit weekday(unsigned _Val) noexcept @@ -926,6 +921,15 @@ namespace chrono { _NODISCARD constexpr class weekday_indexed operator[](unsigned _Index) const noexcept; _NODISCARD constexpr class weekday_last operator[](last_spec) const noexcept; + + private: + unsigned char _Weekday; + + // courtesy of Howard Hinnant + // https://howardhinnant.github.io/date_algorithms.html#weekday_from_days + _NODISCARD static constexpr unsigned _Weekday_from_days(int _Tp) noexcept { + return static_cast(_Tp >= -4 ? (_Tp + 4) % 7 : (_Tp + 5) % 7 + 6); + } }; constexpr bool operator==(const weekday& _Left, const weekday& _Right) noexcept { @@ -950,16 +954,15 @@ namespace chrono { } constexpr weekday& weekday::operator+=(const days& _Days) noexcept { - return *this = *this + _Days; + *this = *this + _Days; + return *this; } constexpr weekday& weekday::operator-=(const days& _Days) noexcept { - return *this = *this - _Days; + *this = *this - _Days; + return *this; } class weekday_indexed { - chrono::weekday _Weekday; - unsigned char _Index; - public: weekday_indexed() = default; constexpr weekday_indexed(const chrono::weekday& _Wd, unsigned _Idx) noexcept @@ -972,8 +975,12 @@ namespace chrono { return _Index; } _NODISCARD constexpr bool ok() const noexcept { - return _Weekday.ok() && 1 <= _Index && _Index <= 5; + return _Weekday.ok() && _Index >= 1 && _Index <= 5; } + + private: + chrono::weekday _Weekday; + unsigned char _Index; }; constexpr bool operator==(const weekday_indexed& _Left, const weekday_indexed& _Right) noexcept { @@ -981,8 +988,6 @@ namespace chrono { } class weekday_last { - chrono::weekday _Weekday; - public: constexpr explicit weekday_last(const chrono::weekday& _Wd) noexcept : _Weekday{_Wd} {} @@ -992,6 +997,9 @@ namespace chrono { _NODISCARD constexpr bool ok() const noexcept { return _Weekday.ok(); } + + private: + chrono::weekday _Weekday; }; constexpr bool operator==(const weekday_last& _Left, const weekday_last& _Right) noexcept { @@ -1007,9 +1015,6 @@ namespace chrono { } class month_day { - chrono::month _Month; - chrono::day _Day; - public: month_day() = default; constexpr month_day(const chrono::month& _M, const chrono::day& _D) noexcept : _Month{_M}, _Day{_D} {} @@ -1021,30 +1026,40 @@ namespace chrono { return _Day; } _NODISCARD constexpr bool ok() const noexcept { - if (!_Month.ok() || !_Day.ok()) + if (!_Month.ok() || !_Day.ok()) { return false; - const auto _D = static_cast(_Day); - const auto _M = static_cast(_Month); - if (_M == 2 && _D > 29) + } + + const auto _Da = static_cast(_Day); + const auto _Mo = static_cast(_Month); + if (_Mo == 2 && _Da > 29) { return false; - if (_M == 4 || _M == 6 || _M == 9 || _M == 11) - return _D <= 30; + } + + if (_Mo == 4 || _Mo == 6 || _Mo == 9 || _Mo == 11) { + return _Da <= 30; + } return true; } + + private: + chrono::month _Month; + chrono::day _Day; }; constexpr bool operator==(const month_day& _Left, const month_day& _Right) noexcept { return _Left.month() == _Right.month() && _Left.day() == _Right.day(); } constexpr strong_ordering operator<=>(const month_day& _Left, const month_day& _Right) noexcept { - if (auto _Comp = _Left.month() <=> _Right.month(); _Comp != 0) + auto _Comp = _Left.month() <=> _Right.month(); + if (_Comp != 0) { return _Comp; + } + return _Left.day() <=> _Right.day(); } class month_day_last { - chrono::month _Month; - public: constexpr explicit month_day_last(const chrono::month& _M) noexcept : _Month{_M} {} @@ -1054,6 +1069,9 @@ namespace chrono { _NODISCARD constexpr bool ok() const noexcept { return _Month.ok(); } + + private: + chrono::month _Month; }; constexpr bool operator==(const month_day_last& _Left, const month_day_last& _Right) noexcept { @@ -1064,9 +1082,6 @@ namespace chrono { } class month_weekday { - chrono::month _Month; - chrono::weekday_indexed _Weekday_index; - public: constexpr month_weekday(const chrono::month& _M, const chrono::weekday_indexed& _Wdi) noexcept : _Month{_M}, _Weekday_index{_Wdi} {} @@ -1081,6 +1096,10 @@ namespace chrono { _NODISCARD constexpr bool ok() const noexcept { return _Month.ok() && _Weekday_index.ok(); } + + private: + chrono::month _Month; + chrono::weekday_indexed _Weekday_index; }; constexpr bool operator==(const month_weekday& _Left, const month_weekday& _Right) noexcept { @@ -1088,9 +1107,6 @@ namespace chrono { } class month_weekday_last { - chrono::month _Month; - chrono::weekday_last _Weekday_last; - public: constexpr month_weekday_last(const chrono::month& _M, const chrono::weekday_last& _Wdl) noexcept : _Month{_M}, _Weekday_last{_Wdl} {} @@ -1104,6 +1120,10 @@ namespace chrono { _NODISCARD constexpr bool ok() const noexcept { return _Month.ok() && _Weekday_last.ok(); } + + private: + chrono::month _Month; + chrono::weekday_last _Weekday_last; }; constexpr bool operator==(const month_weekday_last& _Left, const month_weekday_last& _Right) noexcept { @@ -1111,9 +1131,6 @@ namespace chrono { } class year_month { - chrono::year _Year; - chrono::month _Month; - public: year_month() = default; constexpr year_month(const chrono::year& _Y, const chrono::month& _M) noexcept : _Year{_Y}, _Month{_M} {} @@ -1133,21 +1150,28 @@ namespace chrono { _NODISCARD constexpr bool ok() const noexcept { return _Year.ok() && _Month.ok(); } + + private: + chrono::year _Year; + chrono::month _Month; }; constexpr bool operator==(const year_month& _Left, const year_month& _Right) noexcept { return _Left.year() == _Right.year() && _Left.month() == _Right.month(); } constexpr strong_ordering operator<=>(const year_month& _Left, const year_month& _Right) noexcept { - if (auto _Comp = _Left.year() <=> _Right.year(); _Comp != 0) + auto _Comp = _Left.year() <=> _Right.year(); + if (_Comp != 0) { return _Comp; + } + return _Left.month() <=> _Right.month(); } constexpr year_month operator+(const year_month& _Left, const months& _Right) noexcept { - const auto _M = static_cast(static_cast(_Left.month())) + (_Right.count() - 1); - const auto _Div = (_M >= 0 ? _M : _M - 11) / 12; - return year_month{_Left.year() + years{_Div}, month{static_cast(_M - _Div * 12 + 1)}}; + const auto _Mo = static_cast(static_cast(_Left.month())) + (_Right.count() - 1); + const auto _Div = (_Mo >= 0 ? _Mo : _Mo - 11) / 12; + return year_month{_Left.year() + years{_Div}, month{static_cast(_Mo - _Div * 12 + 1)}}; } constexpr year_month operator+(const months& _Left, const year_month& _Right) noexcept { return _Right + _Left; @@ -1198,36 +1222,8 @@ namespace chrono { return _Month == month{2} && _Year.is_leap() ? _Days[static_cast(_Month) - 1] + days{1} : _Days[static_cast(_Month) - 1]; } + class year_month_day { - chrono::year _Year; - chrono::month _Month; - chrono::day _Day; - _NODISCARD static constexpr year_month_day _Civil_from_days(int _Tp) noexcept { - static_assert(_STD numeric_limits::digits >= 18); - static_assert(_STD numeric_limits::digits >= 20); - const int _Z = _Tp + 719468; - const int _Era = (_Z >= 0 ? _Z : _Z - 146096) / 146097; - const unsigned _Doe = static_cast(_Z - _Era * 146097); - const unsigned _Yoe = (_Doe - _Doe / 1460 + _Doe / 36524 - _Doe / 146096) / 365; - const int _Y = static_cast(_Yoe) + _Era * 400; - const unsigned _Doy = _Doe - (365 * _Yoe + _Yoe / 4 - _Yoe / 100); - const unsigned _Mp = (5 * _Doy + 2) / 153; - const unsigned _D = _Doy - (153 * _Mp + 2) / 5 + 1; - const unsigned _M = _Mp + (_Mp < 10 ? 3 : static_cast(-9)); - return year_month_day(chrono::year{_Y + (_M <= 2)}, chrono::month{_M}, chrono::day{_D}); - } - _NODISCARD constexpr days _Days_from_civil() const noexcept { - static_assert(_STD numeric_limits::digits >= 18); - static_assert(_STD numeric_limits::digits >= 20); - const int _Y = static_cast(_Year) - (_Month <= chrono::month{2}); - const unsigned _M = static_cast(_Month); - const int _Era = (_Y >= 0 ? _Y : _Y - 399) / 400; - const unsigned _Yoe = static_cast(_Y - _Era * 400); - const unsigned _Doy = - (153 * (_M + (_M > 2 ? static_cast(-3) : 9)) + 2) / 5 + static_cast(_Day) - 1; - const unsigned _Doe = _Yoe * 365 + _Yoe / 4 - _Yoe / 100 + _Doy; - return days{_Era * 146097 + static_cast(_Doe) - 719468}; - } public: year_month_day() = default; @@ -1261,20 +1257,63 @@ namespace chrono { return chrono::local_days{static_cast(*this).time_since_epoch()}; } _NODISCARD constexpr bool ok() const noexcept { - if (!_Year.ok() || !_Month.ok()) + if (!_Year.ok() || !_Month.ok()) { return false; + } + return _Day >= chrono::day{1} && _Day <= _Last_day(_Year, _Month); } + + private: + chrono::year _Year; + chrono::month _Month; + chrono::day _Day; + // courtesy of Howard Hinnant + // https://howardhinnant.github.io/date_algorithms.html#civil_from_days + _NODISCARD static constexpr year_month_day _Civil_from_days(int _Tp) noexcept { + static_assert(numeric_limits::digits >= 18); + static_assert(numeric_limits::digits >= 20); + const int _Zx = _Tp + 719468; + const int _Era = (_Zx >= 0 ? _Zx : _Zx - 146096) / 146097; + const unsigned _Doe = static_cast(_Zx - _Era * 146097); + const unsigned _Yoe = (_Doe - _Doe / 1460 + _Doe / 36524 - _Doe / 146096) / 365; + const int _Ye = static_cast(_Yoe) + _Era * 400; + const unsigned _Doy = _Doe - (365 * _Yoe + _Yoe / 4 - _Yoe / 100); + const unsigned _Mp = (5 * _Doy + 2) / 153; + const unsigned _Da = _Doy - (153 * _Mp + 2) / 5 + 1; + const unsigned _Mo = _Mp + (_Mp < 10 ? 3 : static_cast(-9)); + return year_month_day(chrono::year{_Ye + (_Mo <= 2)}, chrono::month{_Mo}, chrono::day{_Da}); + } + // courtesy of Howard Hinnant + // https://howardhinnant.github.io/date_algorithms.html#days_from_civil + _NODISCARD constexpr days _Days_from_civil() const noexcept { + static_assert(numeric_limits::digits >= 18); + static_assert(numeric_limits::digits >= 20); + const int _Ye = static_cast(_Year) - (_Month <= chrono::month{2}); + const unsigned _Mo = static_cast(_Month); + const int _Era = (_Ye >= 0 ? _Ye : _Ye - 399) / 400; + const unsigned _Yoe = static_cast(_Ye - _Era * 400); + const unsigned _Doy = + (153 * (_Mo + (_Mo > 2 ? static_cast(-3) : 9)) + 2) / 5 + static_cast(_Day) - 1; + const unsigned _Doe = _Yoe * 365 + _Yoe / 4 - _Yoe / 100 + _Doy; + return days{_Era * 146097 + static_cast(_Doe) - 719468}; + } }; constexpr bool operator==(const year_month_day& _Left, const year_month_day& _Right) noexcept { return _Left.year() == _Right.year() && _Left.month() == _Right.month() && _Left.day() == _Right.day(); } constexpr strong_ordering operator<=>(const year_month_day& _Left, const year_month_day& _Right) noexcept { - if (auto _Comp = _Left.year() <=> _Right.year(); _Comp != 0) + auto _Comp = _Left.year() <=> _Right.year(); + if (_Comp != 0) { return _Comp; - if (auto _Comp = _Left.month() <=> _Right.month(); _Comp != 0) + } + + _Comp = _Left.month() <=> _Right.month(); + if (_Comp != 0) { return _Comp; + } + return _Left.day() <=> _Right.day(); } @@ -1321,9 +1360,6 @@ namespace chrono { } class year_month_day_last { - chrono::year _Year; - chrono::month_day_last _Month_day_last; - public: constexpr year_month_day_last(const chrono::year& _Y, const chrono::month_day_last& _Mdl) noexcept : _Year{_Y}, _Month_day_last{_Mdl} {} @@ -1355,6 +1391,10 @@ namespace chrono { _NODISCARD constexpr bool ok() const noexcept { return _Year.ok() && _Month_day_last.ok(); } + + private: + chrono::year _Year; + chrono::month_day_last _Month_day_last; }; constexpr bool operator==(const year_month_day_last& _Left, const year_month_day_last& _Right) noexcept { @@ -1362,8 +1402,11 @@ namespace chrono { } constexpr strong_ordering operator<=>( const year_month_day_last& _Left, const year_month_day_last& _Right) noexcept { - if (auto _Comp = _Left.year() <=> _Right.year(); _Comp != 0) + auto _Comp = _Left.year() <=> _Right.year(); + if (_Comp != 0) { return _Comp; + } + return _Left.month_day_last() <=> _Right.month_day_last(); } @@ -1410,17 +1453,6 @@ namespace chrono { : _Year{_Ymdl.year()}, _Month{_Ymdl.month()}, _Day{_Ymdl.day()} {} class year_month_weekday { - chrono::year _Year; - chrono::month _Month; - chrono::weekday_indexed _Weekday_index; - - _NODISCARD static constexpr year_month_weekday _Ymwd_from_days(days _Dp) noexcept { - const chrono::year_month_day _Ymd = sys_days{_Dp}; - const chrono::weekday _Wd = sys_days{_Dp}; - const auto _Idx = ((static_cast(_Ymd.day()) - 1) / 7) + 1; - return {_Ymd.year(), _Ymd.month(), _Wd[_Idx]}; - } - public: year_month_weekday() = default; constexpr year_month_weekday( @@ -1462,15 +1494,31 @@ namespace chrono { return chrono::local_days{static_cast(*this).time_since_epoch()}; } _NODISCARD constexpr bool ok() const noexcept { - if (!_Year.ok() || !_Month.ok() || !_Weekday_index.ok()) + if (!_Year.ok() || !_Month.ok() || !_Weekday_index.ok()) { return false; - if (_Weekday_index.index() <= 4) + } + + if (_Weekday_index.index() <= 4) { return true; + } + const sys_days _First = year_month_day{_Year, _Month, day{1}}; const days _Diff = weekday() - chrono::weekday{_First}; const days _Last = _Diff + days{29}; return static_cast(_Last.count()) <= static_cast(_Last_day(_Year, _Month)); } + + private: + chrono::year _Year; + chrono::month _Month; + chrono::weekday_indexed _Weekday_index; + + _NODISCARD static constexpr year_month_weekday _Ymwd_from_days(days _Dp) noexcept { + const chrono::year_month_day _Ymd = sys_days{_Dp}; + const chrono::weekday _Wd = sys_days{_Dp}; + const auto _Idx = ((static_cast(_Ymd.day()) - 1) / 7) + 1; + return {_Ymd.year(), _Ymd.month(), _Wd[_Idx]}; + } }; constexpr bool operator==(const year_month_weekday& _Left, const year_month_weekday& _Right) noexcept { @@ -1519,10 +1567,6 @@ namespace chrono { } class year_month_weekday_last { - chrono::year _Year; - chrono::month _Month; - chrono::weekday_last _Weekday_last; - public: constexpr year_month_weekday_last( const chrono::year& _Y, const chrono::month& _M, const chrono::weekday_last& _Wdl) noexcept @@ -1558,6 +1602,11 @@ namespace chrono { _NODISCARD constexpr bool ok() const noexcept { return _Year.ok() && _Month.ok() && _Weekday_last.ok(); } + + private: + chrono::year _Year; + chrono::month _Month; + chrono::weekday_last _Weekday_last; }; constexpr bool operator==(const year_month_weekday_last& _Left, const year_month_weekday_last& _Right) noexcept { From 161943d1baf6109257d62c0ddcf4a60aacfe6bbd Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Wed, 26 Aug 2020 04:39:15 +0100 Subject: [PATCH 071/143] down with chrono::? --- stl/inc/chrono | 150 ++++++++++++++++++++++++------------------------- 1 file changed, 75 insertions(+), 75 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 3aac1ab2acc..a0d494d8e00 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -965,10 +965,10 @@ namespace chrono { class weekday_indexed { public: weekday_indexed() = default; - constexpr weekday_indexed(const chrono::weekday& _Wd, unsigned _Idx) noexcept + constexpr weekday_indexed(const weekday& _Wd, unsigned _Idx) noexcept : _Weekday{_Wd}, _Index{static_cast(_Idx)} {} - _NODISCARD constexpr chrono::weekday weekday() const noexcept { + _NODISCARD constexpr weekday weekday() const noexcept { return _Weekday; } _NODISCARD constexpr unsigned index() const noexcept { @@ -979,7 +979,7 @@ namespace chrono { } private: - chrono::weekday _Weekday; + weekday _Weekday; unsigned char _Index; }; @@ -989,9 +989,9 @@ namespace chrono { class weekday_last { public: - constexpr explicit weekday_last(const chrono::weekday& _Wd) noexcept : _Weekday{_Wd} {} + constexpr explicit weekday_last(const weekday& _Wd) noexcept : _Weekday{_Wd} {} - _NODISCARD constexpr chrono::weekday weekday() const noexcept { + _NODISCARD constexpr weekday weekday() const noexcept { return _Weekday; } _NODISCARD constexpr bool ok() const noexcept { @@ -999,7 +999,7 @@ namespace chrono { } private: - chrono::weekday _Weekday; + weekday _Weekday; }; constexpr bool operator==(const weekday_last& _Left, const weekday_last& _Right) noexcept { @@ -1017,12 +1017,12 @@ namespace chrono { class month_day { public: month_day() = default; - constexpr month_day(const chrono::month& _M, const chrono::day& _D) noexcept : _Month{_M}, _Day{_D} {} + constexpr month_day(const month& _M, const day& _D) noexcept : _Month{_M}, _Day{_D} {} - _NODISCARD constexpr chrono::month month() const noexcept { + _NODISCARD constexpr month month() const noexcept { return _Month; } - _NODISCARD constexpr chrono::day day() const noexcept { + _NODISCARD constexpr day day() const noexcept { return _Day; } _NODISCARD constexpr bool ok() const noexcept { @@ -1043,8 +1043,8 @@ namespace chrono { } private: - chrono::month _Month; - chrono::day _Day; + month _Month; + day _Day; }; constexpr bool operator==(const month_day& _Left, const month_day& _Right) noexcept { @@ -1061,9 +1061,9 @@ namespace chrono { class month_day_last { public: - constexpr explicit month_day_last(const chrono::month& _M) noexcept : _Month{_M} {} + constexpr explicit month_day_last(const month& _M) noexcept : _Month{_M} {} - _NODISCARD constexpr chrono::month month() const noexcept { + _NODISCARD constexpr month month() const noexcept { return _Month; } _NODISCARD constexpr bool ok() const noexcept { @@ -1071,7 +1071,7 @@ namespace chrono { } private: - chrono::month _Month; + month _Month; }; constexpr bool operator==(const month_day_last& _Left, const month_day_last& _Right) noexcept { @@ -1083,13 +1083,13 @@ namespace chrono { class month_weekday { public: - constexpr month_weekday(const chrono::month& _M, const chrono::weekday_indexed& _Wdi) noexcept + constexpr month_weekday(const month& _M, const weekday_indexed& _Wdi) noexcept : _Month{_M}, _Weekday_index{_Wdi} {} - _NODISCARD constexpr chrono::month month() const noexcept { + _NODISCARD constexpr month month() const noexcept { return _Month; } - _NODISCARD constexpr chrono::weekday_indexed weekday_indexed() const noexcept { + _NODISCARD constexpr weekday_indexed weekday_indexed() const noexcept { return _Weekday_index; } @@ -1098,8 +1098,8 @@ namespace chrono { } private: - chrono::month _Month; - chrono::weekday_indexed _Weekday_index; + month _Month; + weekday_indexed _Weekday_index; }; constexpr bool operator==(const month_weekday& _Left, const month_weekday& _Right) noexcept { @@ -1108,13 +1108,13 @@ namespace chrono { class month_weekday_last { public: - constexpr month_weekday_last(const chrono::month& _M, const chrono::weekday_last& _Wdl) noexcept + constexpr month_weekday_last(const month& _M, const weekday_last& _Wdl) noexcept : _Month{_M}, _Weekday_last{_Wdl} {} - _NODISCARD constexpr chrono::month month() const noexcept { + _NODISCARD constexpr month month() const noexcept { return _Month; } - _NODISCARD constexpr chrono::weekday_last weekday_last() const noexcept { + _NODISCARD constexpr weekday_last weekday_last() const noexcept { return _Weekday_last; } _NODISCARD constexpr bool ok() const noexcept { @@ -1122,8 +1122,8 @@ namespace chrono { } private: - chrono::month _Month; - chrono::weekday_last _Weekday_last; + month _Month; + weekday_last _Weekday_last; }; constexpr bool operator==(const month_weekday_last& _Left, const month_weekday_last& _Right) noexcept { @@ -1133,12 +1133,12 @@ namespace chrono { class year_month { public: year_month() = default; - constexpr year_month(const chrono::year& _Y, const chrono::month& _M) noexcept : _Year{_Y}, _Month{_M} {} + constexpr year_month(const year& _Y, const month& _M) noexcept : _Year{_Y}, _Month{_M} {} - _NODISCARD constexpr chrono::year year() const noexcept { + _NODISCARD constexpr year year() const noexcept { return _Year; } - _NODISCARD constexpr chrono::month month() const noexcept { + _NODISCARD constexpr month month() const noexcept { return _Month; } @@ -1152,8 +1152,8 @@ namespace chrono { } private: - chrono::year _Year; - chrono::month _Month; + year _Year; + month _Month; }; constexpr bool operator==(const year_month& _Left, const year_month& _Right) noexcept { @@ -1227,7 +1227,7 @@ namespace chrono { public: year_month_day() = default; - constexpr year_month_day(const chrono::year& _Y, const chrono::month& _M, const chrono::day& _D) noexcept + constexpr year_month_day(const year& _Y, const month& _M, const day& _D) noexcept : _Year{_Y}, _Month{_M}, _Day{_D} {} constexpr year_month_day(const class year_month_day_last& _Ymdl) noexcept; constexpr year_month_day(const sys_days& _Sys_days) noexcept @@ -1240,13 +1240,13 @@ namespace chrono { constexpr year_month_day& operator+=(const years& _Years) noexcept; constexpr year_month_day& operator-=(const years& _Years) noexcept; - _NODISCARD constexpr chrono::year year() const noexcept { + _NODISCARD constexpr year year() const noexcept { return _Year; } - _NODISCARD constexpr chrono::month month() const noexcept { + _NODISCARD constexpr month month() const noexcept { return _Month; } - _NODISCARD constexpr chrono::day day() const noexcept { + _NODISCARD constexpr day day() const noexcept { return _Day; } @@ -1254,20 +1254,20 @@ namespace chrono { return sys_days{_Days_from_civil()}; } _NODISCARD constexpr explicit operator local_days() const noexcept { - return chrono::local_days{static_cast(*this).time_since_epoch()}; + return local_days{static_cast(*this).time_since_epoch()}; } _NODISCARD constexpr bool ok() const noexcept { if (!_Year.ok() || !_Month.ok()) { return false; } - return _Day >= chrono::day{1} && _Day <= _Last_day(_Year, _Month); + return _Day >= day{1} && _Day <= _Last_day(_Year, _Month); } private: - chrono::year _Year; - chrono::month _Month; - chrono::day _Day; + year _Year; + month _Month; + day _Day; // courtesy of Howard Hinnant // https://howardhinnant.github.io/date_algorithms.html#civil_from_days _NODISCARD static constexpr year_month_day _Civil_from_days(int _Tp) noexcept { @@ -1282,14 +1282,14 @@ namespace chrono { const unsigned _Mp = (5 * _Doy + 2) / 153; const unsigned _Da = _Doy - (153 * _Mp + 2) / 5 + 1; const unsigned _Mo = _Mp + (_Mp < 10 ? 3 : static_cast(-9)); - return year_month_day(chrono::year{_Ye + (_Mo <= 2)}, chrono::month{_Mo}, chrono::day{_Da}); + return year_month_day(year{_Ye + (_Mo <= 2)}, month{_Mo}, day{_Da}); } // courtesy of Howard Hinnant // https://howardhinnant.github.io/date_algorithms.html#days_from_civil _NODISCARD constexpr days _Days_from_civil() const noexcept { static_assert(numeric_limits::digits >= 18); static_assert(numeric_limits::digits >= 20); - const int _Ye = static_cast(_Year) - (_Month <= chrono::month{2}); + const int _Ye = static_cast(_Year) - (_Month <= month{2}); const unsigned _Mo = static_cast(_Month); const int _Era = (_Ye >= 0 ? _Ye : _Ye - 399) / 400; const unsigned _Yoe = static_cast(_Ye - _Era * 400); @@ -1361,7 +1361,7 @@ namespace chrono { class year_month_day_last { public: - constexpr year_month_day_last(const chrono::year& _Y, const chrono::month_day_last& _Mdl) noexcept + constexpr year_month_day_last(const year& _Y, const month_day_last& _Mdl) noexcept : _Year{_Y}, _Month_day_last{_Mdl} {} constexpr year_month_day_last& operator+=(const months& _Months) noexcept; @@ -1369,16 +1369,16 @@ namespace chrono { constexpr year_month_day_last& operator+=(const years& _Years) noexcept; constexpr year_month_day_last& operator-=(const years& _Years) noexcept; - _NODISCARD constexpr chrono::year year() const noexcept { + _NODISCARD constexpr year year() const noexcept { return _Year; } - _NODISCARD constexpr chrono::month month() const noexcept { + _NODISCARD constexpr month month() const noexcept { return _Month_day_last.month(); } - _NODISCARD constexpr chrono::month_day_last month_day_last() const noexcept { + _NODISCARD constexpr month_day_last month_day_last() const noexcept { return _Month_day_last; } - _NODISCARD constexpr chrono::day day() const noexcept { + _NODISCARD constexpr day day() const noexcept { return _Last_day(year(), month()); } @@ -1386,15 +1386,15 @@ namespace chrono { return sys_days{year_month_day{year(), month(), day()}}; } _NODISCARD constexpr explicit operator local_days() const noexcept { - return _STD chrono::local_days{static_cast(*this).time_since_epoch()}; + return _STD local_days{static_cast(*this).time_since_epoch()}; } _NODISCARD constexpr bool ok() const noexcept { return _Year.ok() && _Month_day_last.ok(); } private: - chrono::year _Year; - chrono::month_day_last _Month_day_last; + year _Year; + month_day_last _Month_day_last; }; constexpr bool operator==(const year_month_day_last& _Left, const year_month_day_last& _Right) noexcept { @@ -1456,7 +1456,7 @@ namespace chrono { public: year_month_weekday() = default; constexpr year_month_weekday( - const chrono::year& _Y, const chrono::month& _M, const chrono::weekday_indexed& _Wdi) noexcept + const year& _Y, const month& _M, const weekday_indexed& _Wdi) noexcept : _Year{_Y}, _Month{_M}, _Weekday_index{_Wdi} {} constexpr year_month_weekday(const sys_days& _Sys_days) noexcept : year_month_weekday{_Ymwd_from_days(_Sys_days.time_since_epoch())} {} @@ -1468,30 +1468,30 @@ namespace chrono { constexpr year_month_weekday& operator+=(const years& _Years) noexcept; constexpr year_month_weekday& operator-=(const years& _Years) noexcept; - _NODISCARD constexpr chrono::year year() const noexcept { + _NODISCARD constexpr year year() const noexcept { return _Year; } - _NODISCARD constexpr chrono::month month() const noexcept { + _NODISCARD constexpr month month() const noexcept { return _Month; } - _NODISCARD constexpr chrono::weekday weekday() const noexcept { + _NODISCARD constexpr weekday weekday() const noexcept { return _Weekday_index.weekday(); } _NODISCARD constexpr unsigned index() const noexcept { return _Weekday_index.index(); } - _NODISCARD constexpr chrono::weekday_indexed weekday_indexed() const noexcept { + _NODISCARD constexpr weekday_indexed weekday_indexed() const noexcept { return _Weekday_index; } _NODISCARD constexpr operator sys_days() const noexcept { const sys_days _First = year_month_day{_Year, _Month, day{1}}; - const days _Diff = weekday() - chrono::weekday{_First}; + const days _Diff = weekday() - weekday{_First}; const days _Days = _Diff + days{(static_cast(index()) - 1) * 7}; return _First + _Days; } _NODISCARD constexpr explicit operator local_days() const noexcept { - return chrono::local_days{static_cast(*this).time_since_epoch()}; + return local_days{static_cast(*this).time_since_epoch()}; } _NODISCARD constexpr bool ok() const noexcept { if (!_Year.ok() || !_Month.ok() || !_Weekday_index.ok()) { @@ -1503,19 +1503,19 @@ namespace chrono { } const sys_days _First = year_month_day{_Year, _Month, day{1}}; - const days _Diff = weekday() - chrono::weekday{_First}; + const days _Diff = weekday() - weekday{_First}; const days _Last = _Diff + days{29}; return static_cast(_Last.count()) <= static_cast(_Last_day(_Year, _Month)); } private: - chrono::year _Year; - chrono::month _Month; - chrono::weekday_indexed _Weekday_index; + year _Year; + month _Month; + weekday_indexed _Weekday_index; _NODISCARD static constexpr year_month_weekday _Ymwd_from_days(days _Dp) noexcept { - const chrono::year_month_day _Ymd = sys_days{_Dp}; - const chrono::weekday _Wd = sys_days{_Dp}; + const year_month_day _Ymd = sys_days{_Dp}; + const weekday _Wd = sys_days{_Dp}; const auto _Idx = ((static_cast(_Ymd.day()) - 1) / 7) + 1; return {_Ymd.year(), _Ymd.month(), _Wd[_Idx]}; } @@ -1569,7 +1569,7 @@ namespace chrono { class year_month_weekday_last { public: constexpr year_month_weekday_last( - const chrono::year& _Y, const chrono::month& _M, const chrono::weekday_last& _Wdl) noexcept + const year& _Y, const month& _M, const weekday_last& _Wdl) noexcept : _Year{_Y}, _Month{_M}, _Weekday_last{_Wdl} {} constexpr year_month_weekday_last& operator+=(const months& _Months) noexcept; @@ -1577,36 +1577,36 @@ namespace chrono { constexpr year_month_weekday_last& operator+=(const years& _Years) noexcept; constexpr year_month_weekday_last& operator-=(const years& _Years) noexcept; - _NODISCARD constexpr chrono::year year() const noexcept { + _NODISCARD constexpr year year() const noexcept { return _Year; } - _NODISCARD constexpr chrono::month month() const noexcept { + _NODISCARD constexpr month month() const noexcept { return _Month; } - _NODISCARD constexpr chrono::weekday weekday() const noexcept { + _NODISCARD constexpr weekday weekday() const noexcept { return _Weekday_last.weekday(); } - _NODISCARD constexpr chrono::weekday_last weekday_last() const noexcept { + _NODISCARD constexpr weekday_last weekday_last() const noexcept { return _Weekday_last; } _NODISCARD constexpr operator sys_days() const noexcept { const sys_days _Last = year_month_day_last{_Year, month_day_last{_Month}}; - const auto _Diff = chrono::weekday{_Last} - weekday(); + const auto _Diff = weekday{_Last} - weekday(); return _Last - _Diff; } _NODISCARD constexpr explicit operator local_days() const noexcept { - return chrono::local_days{static_cast(*this).time_since_epoch()}; + return local_days{static_cast(*this).time_since_epoch()}; } _NODISCARD constexpr bool ok() const noexcept { return _Year.ok() && _Month.ok() && _Weekday_last.ok(); } private: - chrono::year _Year; - chrono::month _Month; - chrono::weekday_last _Weekday_last; + year _Year; + month _Month; + weekday_last _Weekday_last; }; constexpr bool operator==(const year_month_weekday_last& _Left, const year_month_weekday_last& _Right) noexcept { @@ -1883,11 +1883,11 @@ inline namespace literals { return chrono::duration(_Val); } #if _HAS_CXX20 - _NODISCARD constexpr chrono::day operator"" d(unsigned long long _Day) noexcept /* strengthened */ { - return chrono::day{static_cast(_Day)}; + _NODISCARD constexpr day operator"" d(unsigned long long _Day) noexcept /* strengthened */ { + return day{static_cast(_Day)}; } - _NODISCARD constexpr chrono::year operator"" y(unsigned long long _Year) noexcept /* strengthened */ { - return chrono::year{static_cast(_Year)}; + _NODISCARD constexpr year operator"" y(unsigned long long _Year) noexcept /* strengthened */ { + return year{static_cast(_Year)}; } #endif // _HAS_CXX20 } // namespace chrono_literals From e242bc468172e0fb3ee09556e56822b9983d1d67 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Wed, 26 Aug 2020 07:42:21 +0100 Subject: [PATCH 072/143] clang-format --- stl/inc/chrono | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index a0d494d8e00..7dfca2fce4c 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1455,8 +1455,7 @@ namespace chrono { class year_month_weekday { public: year_month_weekday() = default; - constexpr year_month_weekday( - const year& _Y, const month& _M, const weekday_indexed& _Wdi) noexcept + constexpr year_month_weekday(const year& _Y, const month& _M, const weekday_indexed& _Wdi) noexcept : _Year{_Y}, _Month{_M}, _Weekday_index{_Wdi} {} constexpr year_month_weekday(const sys_days& _Sys_days) noexcept : year_month_weekday{_Ymwd_from_days(_Sys_days.time_since_epoch())} {} @@ -1516,7 +1515,7 @@ namespace chrono { _NODISCARD static constexpr year_month_weekday _Ymwd_from_days(days _Dp) noexcept { const year_month_day _Ymd = sys_days{_Dp}; const weekday _Wd = sys_days{_Dp}; - const auto _Idx = ((static_cast(_Ymd.day()) - 1) / 7) + 1; + const auto _Idx = ((static_cast(_Ymd.day()) - 1) / 7) + 1; return {_Ymd.year(), _Ymd.month(), _Wd[_Idx]}; } }; @@ -1568,8 +1567,7 @@ namespace chrono { class year_month_weekday_last { public: - constexpr year_month_weekday_last( - const year& _Y, const month& _M, const weekday_last& _Wdl) noexcept + constexpr year_month_weekday_last(const year& _Y, const month& _M, const weekday_last& _Wdl) noexcept : _Year{_Y}, _Month{_M}, _Weekday_last{_Wdl} {} constexpr year_month_weekday_last& operator+=(const months& _Months) noexcept; From 31886ce95b7bdd30cffc656745e651d9fa418973 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Wed, 26 Aug 2020 07:55:43 +0100 Subject: [PATCH 073/143] down with some chrono:: --- stl/inc/chrono | 72 +++++++++++++++++++++++++------------------------- 1 file changed, 36 insertions(+), 36 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 7dfca2fce4c..c217603d8cc 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -979,7 +979,7 @@ namespace chrono { } private: - weekday _Weekday; + chrono::weekday _Weekday; unsigned char _Index; }; @@ -999,7 +999,7 @@ namespace chrono { } private: - weekday _Weekday; + chrono::weekday _Weekday; }; constexpr bool operator==(const weekday_last& _Left, const weekday_last& _Right) noexcept { @@ -1043,8 +1043,8 @@ namespace chrono { } private: - month _Month; - day _Day; + chrono::month _Month; + chrono::day _Day; }; constexpr bool operator==(const month_day& _Left, const month_day& _Right) noexcept { @@ -1071,7 +1071,7 @@ namespace chrono { } private: - month _Month; + chrono::month _Month; }; constexpr bool operator==(const month_day_last& _Left, const month_day_last& _Right) noexcept { @@ -1098,8 +1098,8 @@ namespace chrono { } private: - month _Month; - weekday_indexed _Weekday_index; + chrono::month _Month; + chrono::weekday_indexed _Weekday_index; }; constexpr bool operator==(const month_weekday& _Left, const month_weekday& _Right) noexcept { @@ -1122,8 +1122,8 @@ namespace chrono { } private: - month _Month; - weekday_last _Weekday_last; + chrono::month _Month; + chrono::weekday_last _Weekday_last; }; constexpr bool operator==(const month_weekday_last& _Left, const month_weekday_last& _Right) noexcept { @@ -1152,8 +1152,8 @@ namespace chrono { } private: - year _Year; - month _Month; + chrono::year _Year; + chrono::month _Month; }; constexpr bool operator==(const year_month& _Left, const year_month& _Right) noexcept { @@ -1261,13 +1261,13 @@ namespace chrono { return false; } - return _Day >= day{1} && _Day <= _Last_day(_Year, _Month); + return _Day >= chrono::day{1} && _Day <= _Last_day(_Year, _Month); } private: - year _Year; - month _Month; - day _Day; + chrono::year _Year; + chrono::month _Month; + chrono::day _Day; // courtesy of Howard Hinnant // https://howardhinnant.github.io/date_algorithms.html#civil_from_days _NODISCARD static constexpr year_month_day _Civil_from_days(int _Tp) noexcept { @@ -1282,14 +1282,14 @@ namespace chrono { const unsigned _Mp = (5 * _Doy + 2) / 153; const unsigned _Da = _Doy - (153 * _Mp + 2) / 5 + 1; const unsigned _Mo = _Mp + (_Mp < 10 ? 3 : static_cast(-9)); - return year_month_day(year{_Ye + (_Mo <= 2)}, month{_Mo}, day{_Da}); + return year_month_day(chrono::year{_Ye + (_Mo <= 2)}, chrono::month{_Mo}, chrono::day{_Da}); } // courtesy of Howard Hinnant // https://howardhinnant.github.io/date_algorithms.html#days_from_civil _NODISCARD constexpr days _Days_from_civil() const noexcept { static_assert(numeric_limits::digits >= 18); static_assert(numeric_limits::digits >= 20); - const int _Ye = static_cast(_Year) - (_Month <= month{2}); + const int _Ye = static_cast(_Year) - (_Month <= chrono::month{2}); const unsigned _Mo = static_cast(_Month); const int _Era = (_Ye >= 0 ? _Ye : _Ye - 399) / 400; const unsigned _Yoe = static_cast(_Ye - _Era * 400); @@ -1386,15 +1386,15 @@ namespace chrono { return sys_days{year_month_day{year(), month(), day()}}; } _NODISCARD constexpr explicit operator local_days() const noexcept { - return _STD local_days{static_cast(*this).time_since_epoch()}; + return local_days{static_cast(*this).time_since_epoch()}; } _NODISCARD constexpr bool ok() const noexcept { return _Year.ok() && _Month_day_last.ok(); } private: - year _Year; - month_day_last _Month_day_last; + chrono::year _Year; + chrono::month_day_last _Month_day_last; }; constexpr bool operator==(const year_month_day_last& _Left, const year_month_day_last& _Right) noexcept { @@ -1485,7 +1485,7 @@ namespace chrono { _NODISCARD constexpr operator sys_days() const noexcept { const sys_days _First = year_month_day{_Year, _Month, day{1}}; - const days _Diff = weekday() - weekday{_First}; + const days _Diff = weekday() - chrono::weekday{_First}; const days _Days = _Diff + days{(static_cast(index()) - 1) * 7}; return _First + _Days; } @@ -1502,20 +1502,20 @@ namespace chrono { } const sys_days _First = year_month_day{_Year, _Month, day{1}}; - const days _Diff = weekday() - weekday{_First}; + const days _Diff = weekday() - chrono::weekday{_First}; const days _Last = _Diff + days{29}; return static_cast(_Last.count()) <= static_cast(_Last_day(_Year, _Month)); } private: - year _Year; - month _Month; - weekday_indexed _Weekday_index; + chrono::year _Year; + chrono::month _Month; + chrono::weekday_indexed _Weekday_index; _NODISCARD static constexpr year_month_weekday _Ymwd_from_days(days _Dp) noexcept { - const year_month_day _Ymd = sys_days{_Dp}; - const weekday _Wd = sys_days{_Dp}; - const auto _Idx = ((static_cast(_Ymd.day()) - 1) / 7) + 1; + const chrono::year_month_day _Ymd = sys_days{_Dp}; + const chrono::weekday _Wd = sys_days{_Dp}; + const auto _Idx = ((static_cast(_Ymd.day()) - 1) / 7) + 1; return {_Ymd.year(), _Ymd.month(), _Wd[_Idx]}; } }; @@ -1591,7 +1591,7 @@ namespace chrono { _NODISCARD constexpr operator sys_days() const noexcept { const sys_days _Last = year_month_day_last{_Year, month_day_last{_Month}}; - const auto _Diff = weekday{_Last} - weekday(); + const auto _Diff = chrono::weekday{_Last} - weekday(); return _Last - _Diff; } _NODISCARD constexpr explicit operator local_days() const noexcept { @@ -1602,9 +1602,9 @@ namespace chrono { } private: - year _Year; - month _Month; - weekday_last _Weekday_last; + chrono::year _Year; + chrono::month _Month; + chrono::weekday_last _Weekday_last; }; constexpr bool operator==(const year_month_weekday_last& _Left, const year_month_weekday_last& _Right) noexcept { @@ -1881,11 +1881,11 @@ inline namespace literals { return chrono::duration(_Val); } #if _HAS_CXX20 - _NODISCARD constexpr day operator"" d(unsigned long long _Day) noexcept /* strengthened */ { - return day{static_cast(_Day)}; + _NODISCARD constexpr chrono::day operator"" d(unsigned long long _Day) noexcept /* strengthened */ { + return chrono::day{static_cast(_Day)}; } - _NODISCARD constexpr year operator"" y(unsigned long long _Year) noexcept /* strengthened */ { - return year{static_cast(_Year)}; + _NODISCARD constexpr chrono::year operator"" y(unsigned long long _Year) noexcept /* strengthened */ { + return chrono::year{static_cast(_Year)}; } #endif // _HAS_CXX20 } // namespace chrono_literals From 86d854b5e0928157d22dc0c054ead4f78d4ec626 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Wed, 26 Aug 2020 14:03:58 +0100 Subject: [PATCH 074/143] Implement is_clock (and add a newline somewhere) --- stl/inc/chrono | 16 ++++++++++ tests/std/test.lst | 1 + .../env.lst | 4 +++ .../test.cpp | 32 +++++++++++++++++++ 4 files changed, 53 insertions(+) create mode 100644 tests/std/tests/P0355R7_calendars_and_time_zones_dates_clocks/env.lst create mode 100644 tests/std/tests/P0355R7_calendars_and_time_zones_dates_clocks/test.cpp diff --git a/stl/inc/chrono b/stl/inc/chrono index c217603d8cc..3112b082084 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -53,6 +53,21 @@ namespace chrono { } }; + template + concept _Is_Clock = requires { + typename _Clock::rep; + typename _Clock::period; + typename _Clock::duration; + typename _Clock::time_point; + _Clock::is_steady; + _Clock::now(); + }; + + template + struct is_clock : bool_constant<_Is_Clock<_Clock>> {}; + template + inline constexpr bool is_clock_v = _Is_Clock<_Clock>; + // CLASS TEMPLATE duration template > class duration; @@ -1268,6 +1283,7 @@ namespace chrono { chrono::year _Year; chrono::month _Month; chrono::day _Day; + // courtesy of Howard Hinnant // https://howardhinnant.github.io/date_algorithms.html#civil_from_days _NODISCARD static constexpr year_month_day _Civil_from_days(int _Tp) noexcept { diff --git a/tests/std/test.lst b/tests/std/test.lst index 8a552bb5455..6169833ebbe 100644 --- a/tests/std/test.lst +++ b/tests/std/test.lst @@ -219,6 +219,7 @@ tests\P0220R1_searchers tests\P0220R1_string_view tests\P0325R4_to_array tests\P0355R7_calendars_and_time_zones_dates +tests\P0355R7_calendars_and_time_zones_dates_clocks tests\P0355R7_calendars_and_time_zones_dates_literals tests\P0355R7_calendars_and_time_zones_time_point_and_durations tests\P0356R5_bind_front diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates_clocks/env.lst b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_clocks/env.lst new file mode 100644 index 00000000000..642f530ffad --- /dev/null +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_clocks/env.lst @@ -0,0 +1,4 @@ +# Copyright (c) Microsoft Corporation. +# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +RUNALL_INCLUDE ..\usual_latest_matrix.lst diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates_clocks/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_clocks/test.cpp new file mode 100644 index 00000000000..de3100f268d --- /dev/null +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_clocks/test.cpp @@ -0,0 +1,32 @@ +// Copyright (c) Microsoft Corporation. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +#include +#include + +using namespace std::chrono; + +struct _Not_a_clock { + bool rep(); + static char period; + int duration(); + static float time_point; + using is_steady = long; + static int now; +}; + +struct _Real_fake_clock { + using rep = bool; + using period = char; + using duration = float; + using time_point = int; + static long is_steady; + static short now(); +}; + +static_assert(is_clock::value, "steady_clock is not a clock"); +static_assert(is_clock_v, "steady_clock is not a clock"); +static_assert(is_clock_v<_Real_fake_clock>, "_Real_fake_clock is not a clock"); +static_assert(!is_clock_v<_Not_a_clock>, "_Not_a_clock is a clock"); + +int main() {} \ No newline at end of file From f78cf1e6cd9c4baf339b6fa5570bb5a12fd032b0 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Wed, 26 Aug 2020 15:45:31 +0100 Subject: [PATCH 075/143] New line and guard --- stl/inc/chrono | 2 ++ .../P0355R7_calendars_and_time_zones_dates_clocks/test.cpp | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 3112b082084..f6b6d2e96da 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -53,6 +53,7 @@ namespace chrono { } }; +#ifdef _HAS_CXX20 template concept _Is_Clock = requires { typename _Clock::rep; @@ -67,6 +68,7 @@ namespace chrono { struct is_clock : bool_constant<_Is_Clock<_Clock>> {}; template inline constexpr bool is_clock_v = _Is_Clock<_Clock>; +#endif // HAS_CXX20 // CLASS TEMPLATE duration template > diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates_clocks/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_clocks/test.cpp index de3100f268d..9ffaf00e6db 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates_clocks/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_clocks/test.cpp @@ -29,4 +29,4 @@ static_assert(is_clock_v, "steady_clock is not a clock"); static_assert(is_clock_v<_Real_fake_clock>, "_Real_fake_clock is not a clock"); static_assert(!is_clock_v<_Not_a_clock>, "_Not_a_clock is a clock"); -int main() {} \ No newline at end of file +int main() {} From 1fbc15132ff5f398b0733140999415fbad38a25c Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Wed, 26 Aug 2020 18:42:41 +0100 Subject: [PATCH 076/143] Oopsie --- stl/inc/chrono | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index f6b6d2e96da..40fbe044787 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -53,7 +53,7 @@ namespace chrono { } }; -#ifdef _HAS_CXX20 +#if _HAS_CXX20 template concept _Is_Clock = requires { typename _Clock::rep; From 4b97f2f6661cfaa1e52ffedff8d304469c85fba0 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Fri, 4 Sep 2020 15:35:44 +0100 Subject: [PATCH 077/143] Names and comment --- stl/inc/chrono | 8 +++++--- .../test.cpp | 8 ++++---- 2 files changed, 9 insertions(+), 7 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 40fbe044787..17a350a6069 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1519,9 +1519,11 @@ namespace chrono { return true; } - const sys_days _First = year_month_day{_Year, _Month, day{1}}; - const days _Diff = weekday() - chrono::weekday{_First}; - const days _Last = _Diff + days{29}; + // As index() == 5 is not always valid + // Determine the date of the first weekday and check if + days{28} is <= last day of the month + const sys_days _First_of_month = year_month_day{_Year, _Month, day{1}}; + const days _First_weekday = weekday() - chrono::weekday{_First_of_month} + days{1}; + const days _Last = _First_weekday + days{28}; return static_cast(_Last.count()) <= static_cast(_Last_day(_Year, _Month)); } diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates_clocks/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_clocks/test.cpp index 9ffaf00e6db..537ac19fb19 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates_clocks/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_clocks/test.cpp @@ -6,7 +6,7 @@ using namespace std::chrono; -struct _Not_a_clock { +struct not_a_clock { bool rep(); static char period; int duration(); @@ -15,7 +15,7 @@ struct _Not_a_clock { static int now; }; -struct _Real_fake_clock { +struct real_fake_clock { using rep = bool; using period = char; using duration = float; @@ -26,7 +26,7 @@ struct _Real_fake_clock { static_assert(is_clock::value, "steady_clock is not a clock"); static_assert(is_clock_v, "steady_clock is not a clock"); -static_assert(is_clock_v<_Real_fake_clock>, "_Real_fake_clock is not a clock"); -static_assert(!is_clock_v<_Not_a_clock>, "_Not_a_clock is a clock"); +static_assert(is_clock_v<_Real_fake_clock>, "real_fake_clock is not a clock"); +static_assert(!is_clock_v<_Not_a_clock>, "not_a_clock is a clock"); int main() {} From ab15729d148fb13cf5e512f85de15966d8b85263 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sat, 5 Sep 2020 06:54:27 +0100 Subject: [PATCH 078/143] "I don't need find and replace" --- .../P0355R7_calendars_and_time_zones_dates_clocks/test.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates_clocks/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_clocks/test.cpp index 537ac19fb19..75130d58b7f 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates_clocks/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_clocks/test.cpp @@ -26,7 +26,7 @@ struct real_fake_clock { static_assert(is_clock::value, "steady_clock is not a clock"); static_assert(is_clock_v, "steady_clock is not a clock"); -static_assert(is_clock_v<_Real_fake_clock>, "real_fake_clock is not a clock"); -static_assert(!is_clock_v<_Not_a_clock>, "not_a_clock is a clock"); +static_assert(is_clock_v, "real_fake_clock is not a clock"); +static_assert(!is_clock_v, "not_a_clock is a clock"); int main() {} From 77ff6caf420a23e9a3dea519001fae046abdf433 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sun, 6 Sep 2020 14:17:34 +0100 Subject: [PATCH 079/143] Implement hh_mm_ss and make12/24 --- stl/inc/chrono | 88 +++++++++++++++++++++++++++++++ tests/libcxx/expected_results.txt | 13 ----- tests/libcxx/skipped_tests.txt | 13 ----- 3 files changed, 88 insertions(+), 26 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 17a350a6069..98a08ab3cf1 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1817,6 +1817,94 @@ namespace chrono { inline constexpr month October{10}; inline constexpr month November{11}; inline constexpr month December{12}; + + constexpr unsigned _Width(intmax_t _Num, const intmax_t _Den) { + _STL_ASSERT(_Den > 0, "Denominator can't be less than 1."); + unsigned _Result = 0; + // doing everything in for > using a while loop + for (; _Num % _Den != 0 && _Result < 19; _Num = _Num % _Den * 10, ++_Result) { + } + return _Result == 19 ? 6 : _Result; + } + + constexpr intmax_t _Pow10(const int _Exp) { + if (_Exp == 0) { + return 1; + } + return 10 * _Pow10(_Exp - 1); + } + + template + requires _Is_duration_v<_Duration> class hh_mm_ss { + public: + static constexpr unsigned fractional_width = _Width(_Duration::period::num, _Duration::period::den); + using precision = + duration, ratio<1, _Pow10(fractional_width)>>; + + constexpr hh_mm_ss() noexcept : hh_mm_ss{_Duration::zero()} {} + // clang-format off + constexpr explicit hh_mm_ss(_Duration _Dur) + : _Is_neg{_Dur < _Duration::zero()}, + _Hours{duration_cast(_STD chrono::abs(_Dur))}, + _Mins{duration_cast(_STD chrono::abs(_Dur) - hours())}, + _Secs{duration_cast(_STD chrono::abs(_Dur) - hours() - minutes())} { + // clang-format on + if constexpr (treat_as_floating_point_v) { + _Sub_secs = _STD chrono::abs(_Dur) - hours() - minutes() - seconds(); + } else { + _Sub_secs = duration_cast(_STD chrono::abs(_Dur) - hours() - minutes() - seconds()); + } + } + + _NODISCARD constexpr bool is_negative() const noexcept { + return _Is_neg; + } + _NODISCARD constexpr hours hours() const noexcept { + return _Hours; + } + _NODISCARD constexpr minutes minutes() const noexcept { + return _Mins; + } + _NODISCARD constexpr seconds seconds() const noexcept { + return _Secs; + } + _NODISCARD constexpr precision subseconds() const noexcept { + return _Sub_secs; + } + + _NODISCARD constexpr explicit operator precision() const noexcept { + return to_duration(); + } + _NODISCARD constexpr precision to_duration() const noexcept { + const auto _Dur = _Hours + _Mins + _Secs + _Sub_secs; + return _Is_neg ? -_Dur : _Dur; + } + + private: + bool _Is_neg; + chrono::hours _Hours; + chrono::minutes _Mins; + chrono::seconds _Secs; + precision _Sub_secs; + }; + + _NODISCARD constexpr bool is_am(const hours& _Hours) noexcept { + return _Hours >= hours{0} && _Hours <= hours{11}; + } + _NODISCARD constexpr bool is_pm(const hours& _Hours) noexcept { + return _Hours >= hours{12} && _Hours <= hours{23}; + } + + _NODISCARD constexpr hours make12(const hours& _Hours) noexcept { + return _Hours == hours{12} || _Hours == hours{0} ? hours{12} : _Hours % 12; + } + _NODISCARD constexpr hours make24(const hours& _Hours, bool _Is_pm) noexcept { + if (_Is_pm) { + return _Hours == hours{12} ? _Hours : _Hours + hours{12}; + } + return _Hours == hours{12} ? hours{0} : _Hours; + } + #endif // _HAS_CXX20 } // namespace chrono diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt index 4c794437678..5c06dc28b39 100644 --- a/tests/libcxx/expected_results.txt +++ b/tests/libcxx/expected_results.txt @@ -275,19 +275,6 @@ std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp FAIL std/utilities/time/time.clock/time.clock.file/file_time.pass.cpp FAIL std/utilities/time/time.clock/time.clock.file/now.pass.cpp FAIL std/utilities/time/time.clock/time.clock.file/rep_signed.pass.cpp FAIL -std/utilities/time/time.hms/time.12/is_am.pass.cpp FAIL -std/utilities/time/time.hms/time.12/is_pm.pass.cpp FAIL -std/utilities/time/time.hms/time.12/make12.pass.cpp FAIL -std/utilities/time/time.hms/time.12/make24.pass.cpp FAIL -std/utilities/time/time.hms/time.hms.members/hours.pass.cpp FAIL -std/utilities/time/time.hms/time.hms.members/is_negative.pass.cpp FAIL -std/utilities/time/time.hms/time.hms.members/minutes.pass.cpp FAIL -std/utilities/time/time.hms/time.hms.members/precision.pass.cpp FAIL -std/utilities/time/time.hms/time.hms.members/precision_type.pass.cpp FAIL -std/utilities/time/time.hms/time.hms.members/seconds.pass.cpp FAIL -std/utilities/time/time.hms/time.hms.members/subseconds.pass.cpp FAIL -std/utilities/time/time.hms/time.hms.members/to_duration.pass.cpp FAIL -std/utilities/time/time.hms/time.hms.members/width.pass.cpp FAIL # C++20 P0608R3 "Improving variant's Converting Constructor/Assignment" std/utilities/variant/variant.variant/variant.assign/conv.pass.cpp FAIL diff --git a/tests/libcxx/skipped_tests.txt b/tests/libcxx/skipped_tests.txt index a2ee0f73ec7..f3a2d3bf67f 100644 --- a/tests/libcxx/skipped_tests.txt +++ b/tests/libcxx/skipped_tests.txt @@ -277,19 +277,6 @@ utilities\time\time.clock\time.clock.file\consistency.pass.cpp utilities\time\time.clock\time.clock.file\file_time.pass.cpp utilities\time\time.clock\time.clock.file\now.pass.cpp utilities\time\time.clock\time.clock.file\rep_signed.pass.cpp -utilities\time\time.hms\time.12\is_am.pass.cpp -utilities\time\time.hms\time.12\is_pm.pass.cpp -utilities\time\time.hms\time.12\make12.pass.cpp -utilities\time\time.hms\time.12\make24.pass.cpp -utilities\time\time.hms\time.hms.members\hours.pass.cpp -utilities\time\time.hms\time.hms.members\is_negative.pass.cpp -utilities\time\time.hms\time.hms.members\minutes.pass.cpp -utilities\time\time.hms\time.hms.members\precision.pass.cpp -utilities\time\time.hms\time.hms.members\precision_type.pass.cpp -utilities\time\time.hms\time.hms.members\seconds.pass.cpp -utilities\time\time.hms\time.hms.members\subseconds.pass.cpp -utilities\time\time.hms\time.hms.members\to_duration.pass.cpp -utilities\time\time.hms\time.hms.members\width.pass.cpp # C++20 P0608R3 "Improving variant's Converting Constructor/Assignment" utilities\variant\variant.variant\variant.assign\conv.pass.cpp From 4aa79d9b9a5c779336e158786543327e3cc0f9aa Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sun, 6 Sep 2020 14:25:51 +0100 Subject: [PATCH 080/143] dates_clocks -> clocks --- tests/std/test.lst | 2 +- .../env.lst | 0 .../test.cpp | 0 3 files changed, 1 insertion(+), 1 deletion(-) rename tests/std/tests/{P0355R7_calendars_and_time_zones_dates_clocks => P0355R7_calendars_and_time_zones_clocks}/env.lst (100%) rename tests/std/tests/{P0355R7_calendars_and_time_zones_dates_clocks => P0355R7_calendars_and_time_zones_clocks}/test.cpp (100%) diff --git a/tests/std/test.lst b/tests/std/test.lst index 6169833ebbe..5fc8c527650 100644 --- a/tests/std/test.lst +++ b/tests/std/test.lst @@ -218,8 +218,8 @@ tests\P0220R1_sample tests\P0220R1_searchers tests\P0220R1_string_view tests\P0325R4_to_array +tests\P0355R7_calendars_and_time_zones_clocks tests\P0355R7_calendars_and_time_zones_dates -tests\P0355R7_calendars_and_time_zones_dates_clocks tests\P0355R7_calendars_and_time_zones_dates_literals tests\P0355R7_calendars_and_time_zones_time_point_and_durations tests\P0356R5_bind_front diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates_clocks/env.lst b/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/env.lst similarity index 100% rename from tests/std/tests/P0355R7_calendars_and_time_zones_dates_clocks/env.lst rename to tests/std/tests/P0355R7_calendars_and_time_zones_clocks/env.lst diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates_clocks/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.cpp similarity index 100% rename from tests/std/tests/P0355R7_calendars_and_time_zones_dates_clocks/test.cpp rename to tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.cpp From 4726484117f52b4beac47e90a550bb179c9fa767 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Mon, 7 Sep 2020 13:37:47 +0100 Subject: [PATCH 081/143] Add hh_mm_ss tests --- tests/std/test.lst | 1 + .../env.lst | 4 + .../test.cpp | 141 ++++++++++++++++++ 3 files changed, 146 insertions(+) create mode 100644 tests/std/tests/P0355R7_calendars_and_time_zones_hms/env.lst create mode 100644 tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp diff --git a/tests/std/test.lst b/tests/std/test.lst index 5fc8c527650..7db94759d7d 100644 --- a/tests/std/test.lst +++ b/tests/std/test.lst @@ -221,6 +221,7 @@ tests\P0325R4_to_array tests\P0355R7_calendars_and_time_zones_clocks tests\P0355R7_calendars_and_time_zones_dates tests\P0355R7_calendars_and_time_zones_dates_literals +tests\P0355R7_calendars_and_time_zones_hms tests\P0355R7_calendars_and_time_zones_time_point_and_durations tests\P0356R5_bind_front tests\P0357R3_supporting_incomplete_types_in_reference_wrapper diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_hms/env.lst b/tests/std/tests/P0355R7_calendars_and_time_zones_hms/env.lst new file mode 100644 index 00000000000..642f530ffad --- /dev/null +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_hms/env.lst @@ -0,0 +1,4 @@ +# Copyright (c) Microsoft Corporation. +# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +RUNALL_INCLUDE ..\usual_latest_matrix.lst diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp new file mode 100644 index 00000000000..9e06ff023f6 --- /dev/null +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp @@ -0,0 +1,141 @@ +// Copyright (c) Microsoft Corporation. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +#include +#include + +using namespace std; +using namespace std::chrono; + +constexpr void am_pm() { + for (hours i = 0h; i < 12h; ++i) { + assert(is_am(i)); + assert(!is_pm(i)); + } + for (hours i = 12h; i < 24h; ++i) { + assert(!is_am(i)); + assert(is_pm(i)); + } +} + +constexpr void make12_24() { + assert(make12(1h) == 1h); + assert(make12(13h) == 1h); + assert(make12(0h) == 12h); + assert(make12(12h) == 12h); + + assert(make24(12h, true) == 12h); + assert(make24(12h, false) == 0h); + assert(make24(5h, true) == 17h); + assert(make24(5h, false) == 5h); +} + +template +constexpr auto width() { + return hh_mm_ss::fractional_width; +} +template +constexpr auto width() { + return hh_mm_ss>>::fractional_width; +} + +constexpr void fractional_width() { + static_assert(width() == 0); + static_assert(width() == 0); + static_assert(width() == 0); + static_assert(width() == 0); + static_assert(width() == 3); + static_assert(width() == 6); + static_assert(width() == 9); + + static_assert(width<1, 2>() == 1); + static_assert(width<1, 3>() == 6); + static_assert(width<1, 4>() == 2); + static_assert(width<1, 5>() == 1); + static_assert(width<1, 6>() == 6); + static_assert(width<1, 7>() == 6); + static_assert(width<1, 8>() == 3); + static_assert(width<1, 9>() == 6); + static_assert(width<1, 10>() == 1); + static_assert(width<756, 625>() == 4); + static_assert(width<3780, 625>() == 3); +} +constexpr void is_negative() { + assert(hh_mm_ss(days{-1}).is_negative()); + assert(!hh_mm_ss(days{1}).is_negative()); + + assert(hh_mm_ss(-1h).is_negative()); + assert(!hh_mm_ss(1h).is_negative()); + + assert(hh_mm_ss(-1min).is_negative()); + assert(!hh_mm_ss(1min).is_negative()); + + assert(hh_mm_ss(-1s).is_negative()); + assert(!hh_mm_ss(1s).is_negative()); + + assert(hh_mm_ss(-1ms).is_negative()); + assert(!hh_mm_ss(1ms).is_negative()); + + assert(hh_mm_ss(-1us).is_negative()); + assert(!hh_mm_ss(1us).is_negative()); + + assert(hh_mm_ss(-1ns).is_negative()); + assert(!hh_mm_ss(1ns).is_negative()); + +} + +constexpr auto ones = 1h + 1min + 1s + 1ms; + +constexpr void hour() { + assert(hh_mm_ss(days{1}).hours() == 24h); + assert(hh_mm_ss(ones).hours() == 1h); + assert(hh_mm_ss(-ones).hours() == 1h); + assert(hh_mm_ss(59min).hours() == 0h); +} + +constexpr void mins() { + assert(hh_mm_ss(ones).minutes() == 1min); + assert(hh_mm_ss(-ones).minutes() == 1min); + assert(hh_mm_ss(59s).minutes() == 0min); +} + +constexpr void secs() { + assert(hh_mm_ss(ones).seconds() == 1s); + assert(hh_mm_ss(-ones).seconds() == 1s); + assert(hh_mm_ss(999ms).seconds() == 0s); +} + +constexpr void subsecs() { + assert(hh_mm_ss(ones).subseconds() == 1ms); + assert(hh_mm_ss(-ones).subseconds() == 1ms); + assert(hh_mm_ss(999us).subseconds() == 999us); + assert(hh_mm_ss(duration_cast(999us)).subseconds() == 0ms); +} + +constexpr void to_duration() { + assert(hh_mm_ss(ones).to_duration() == ones); + assert(hh_mm_ss(-ones).to_duration() == -ones); + + hh_mm_ss hms(50ms); + milliseconds mili = static_cast(hms); + static_assert(is_same_v); + assert(hms.to_duration() == mili); +} + +constexpr bool test() { + am_pm(); + make12_24(); + fractional_width(); + is_negative(); + hour(); + mins(); + secs(); + subsecs(); + to_duration(); + return true; +} + +int main() { + test(); + static_assert(test()); +} \ No newline at end of file From 0f3f0470dc953b8e0fcaa5c715db18a520c35ca1 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Mon, 7 Sep 2020 13:42:19 +0100 Subject: [PATCH 082/143] Formatting --- stl/inc/chrono | 1 - tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp | 4 ++-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 98a08ab3cf1..c7f9ed165be 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1904,7 +1904,6 @@ namespace chrono { } return _Hours == hours{12} ? hours{0} : _Hours; } - #endif // _HAS_CXX20 } // namespace chrono diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp index 9e06ff023f6..516cf4da9ca 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp @@ -60,6 +60,7 @@ constexpr void fractional_width() { static_assert(width<756, 625>() == 4); static_assert(width<3780, 625>() == 3); } + constexpr void is_negative() { assert(hh_mm_ss(days{-1}).is_negative()); assert(!hh_mm_ss(days{1}).is_negative()); @@ -81,7 +82,6 @@ constexpr void is_negative() { assert(hh_mm_ss(-1ns).is_negative()); assert(!hh_mm_ss(1ns).is_negative()); - } constexpr auto ones = 1h + 1min + 1s + 1ms; @@ -89,7 +89,7 @@ constexpr auto ones = 1h + 1min + 1s + 1ms; constexpr void hour() { assert(hh_mm_ss(days{1}).hours() == 24h); assert(hh_mm_ss(ones).hours() == 1h); - assert(hh_mm_ss(-ones).hours() == 1h); + assert(hh_mm_ss(-ones).hours() == 1h); assert(hh_mm_ss(59min).hours() == 0h); } From 2d082a2a8af92e8b2e9d4fd46c34fdf3cefb419a Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Mon, 7 Sep 2020 13:46:38 +0100 Subject: [PATCH 083/143] Newline --- tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp index 516cf4da9ca..4ea1ec22609 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp @@ -138,4 +138,4 @@ constexpr bool test() { int main() { test(); static_assert(test()); -} \ No newline at end of file +} From 68e23c8366d3613d9d86b3dc2fa24a718602c98e Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Mon, 7 Sep 2020 13:50:11 +0100 Subject: [PATCH 084/143] I should just use VS Code to format... --- stl/inc/chrono | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index c7f9ed165be..52c7a38ea8b 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1844,9 +1844,9 @@ namespace chrono { constexpr hh_mm_ss() noexcept : hh_mm_ss{_Duration::zero()} {} // clang-format off constexpr explicit hh_mm_ss(_Duration _Dur) - : _Is_neg{_Dur < _Duration::zero()}, + : _Is_neg{_Dur < _Duration::zero()}, _Hours{duration_cast(_STD chrono::abs(_Dur))}, - _Mins{duration_cast(_STD chrono::abs(_Dur) - hours())}, + _Mins{duration_cast(_STD chrono::abs(_Dur) - hours())}, _Secs{duration_cast(_STD chrono::abs(_Dur) - hours() - minutes())} { // clang-format on if constexpr (treat_as_floating_point_v) { From a0634de3650d1b061aa063910fcf2d280016a6b9 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sat, 19 Sep 2020 14:16:39 +0100 Subject: [PATCH 085/143] * Literals aren't strengthened * `chrono::duration_cast` * Remove _STD * (sub)seconds.pass.cpp:0 FAIL --- stl/inc/chrono | 14 +++++++------- tests/libcxx/expected_results.txt | 3 +++ tests/libcxx/skipped_tests.txt | 2 ++ 3 files changed, 12 insertions(+), 7 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 52c7a38ea8b..29a759a5740 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1845,14 +1845,14 @@ namespace chrono { // clang-format off constexpr explicit hh_mm_ss(_Duration _Dur) : _Is_neg{_Dur < _Duration::zero()}, - _Hours{duration_cast(_STD chrono::abs(_Dur))}, - _Mins{duration_cast(_STD chrono::abs(_Dur) - hours())}, - _Secs{duration_cast(_STD chrono::abs(_Dur) - hours() - minutes())} { + _Hours{chrono::duration_cast(chrono::abs(_Dur))}, + _Mins{chrono::duration_cast(chrono::abs(_Dur) - hours())}, + _Secs{chrono::duration_cast(chrono::abs(_Dur) - hours() - minutes())} { // clang-format on if constexpr (treat_as_floating_point_v) { - _Sub_secs = _STD chrono::abs(_Dur) - hours() - minutes() - seconds(); + _Sub_secs = chrono::abs(_Dur) - hours() - minutes() - seconds(); } else { - _Sub_secs = duration_cast(_STD chrono::abs(_Dur) - hours() - minutes() - seconds()); + _Sub_secs = chrono::duration_cast(chrono::abs(_Dur) - hours() - minutes() - seconds()); } } @@ -1988,10 +1988,10 @@ inline namespace literals { return chrono::duration(_Val); } #if _HAS_CXX20 - _NODISCARD constexpr chrono::day operator"" d(unsigned long long _Day) noexcept /* strengthened */ { + _NODISCARD constexpr chrono::day operator"" d(unsigned long long _Day) noexcept { return chrono::day{static_cast(_Day)}; } - _NODISCARD constexpr chrono::year operator"" y(unsigned long long _Year) noexcept /* strengthened */ { + _NODISCARD constexpr chrono::year operator"" y(unsigned long long _Year) noexcept { return chrono::year{static_cast(_Year)}; } #endif // _HAS_CXX20 diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt index 5c06dc28b39..1347c13bc77 100644 --- a/tests/libcxx/expected_results.txt +++ b/tests/libcxx/expected_results.txt @@ -275,6 +275,9 @@ std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp FAIL std/utilities/time/time.clock/time.clock.file/file_time.pass.cpp FAIL std/utilities/time/time.clock/time.clock.file/now.pass.cpp FAIL std/utilities/time/time.clock/time.clock.file/rep_signed.pass.cpp FAIL +# conversion from '__int64' to 'long', possible loss of data +std/utilities/time/time.hms/time.hms.members/seconds.pass.cpp:0 FAIL +std/utilities/time/time.hms/time.hms.members/subseconds.pass.cpp:0 FAIL # C++20 P0608R3 "Improving variant's Converting Constructor/Assignment" std/utilities/variant/variant.variant/variant.assign/conv.pass.cpp FAIL diff --git a/tests/libcxx/skipped_tests.txt b/tests/libcxx/skipped_tests.txt index f3a2d3bf67f..1935264e9aa 100644 --- a/tests/libcxx/skipped_tests.txt +++ b/tests/libcxx/skipped_tests.txt @@ -277,6 +277,8 @@ utilities\time\time.clock\time.clock.file\consistency.pass.cpp utilities\time\time.clock\time.clock.file\file_time.pass.cpp utilities\time\time.clock\time.clock.file\now.pass.cpp utilities\time\time.clock\time.clock.file\rep_signed.pass.cpp +utilities\time\time.hms\time.hms.members\seconds.pass.cpp +utilities\time\time.hms\time.hms.members\subseconds.pass.cpp # C++20 P0608R3 "Improving variant's Converting Constructor/Assignment" utilities\variant\variant.variant\variant.assign\conv.pass.cpp From 933e7b1313dd7bab955bf5564781999e58116559 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Fri, 25 Sep 2020 15:02:04 +0100 Subject: [PATCH 086/143] Iterative _Pow10 and comment _Width --- stl/inc/chrono | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 29a759a5740..4594b36324f 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1818,6 +1818,9 @@ namespace chrono { inline constexpr month November{11}; inline constexpr month December{12}; + // Returns the number of fractional digits of _Num / _Den. + // Example: _Width(1, 8) would return 3 for 0.125. + // If it can't be represented 6 is returned. constexpr unsigned _Width(intmax_t _Num, const intmax_t _Den) { _STL_ASSERT(_Den > 0, "Denominator can't be less than 1."); unsigned _Result = 0; @@ -1828,10 +1831,11 @@ namespace chrono { } constexpr intmax_t _Pow10(const int _Exp) { - if (_Exp == 0) { - return 1; + intmax_t _Result = 1; + for (int _Ix = 0; _Ix < _Exp; ++_Ix) { + _Result *= 10; } - return 10 * _Pow10(_Exp - 1); + return _Result; } template From ee8545b86bc824a66bcc57b9e3fe790eb35ad71f Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Fri, 25 Sep 2020 15:02:42 +0100 Subject: [PATCH 087/143] Rename algorithm variables and add range comments --- stl/inc/chrono | 39 +++++++++++++++++++++------------------ 1 file changed, 21 insertions(+), 18 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 4594b36324f..238b6eb2b86 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1291,30 +1291,33 @@ namespace chrono { _NODISCARD static constexpr year_month_day _Civil_from_days(int _Tp) noexcept { static_assert(numeric_limits::digits >= 18); static_assert(numeric_limits::digits >= 20); - const int _Zx = _Tp + 719468; - const int _Era = (_Zx >= 0 ? _Zx : _Zx - 146096) / 146097; - const unsigned _Doe = static_cast(_Zx - _Era * 146097); - const unsigned _Yoe = (_Doe - _Doe / 1460 + _Doe / 36524 - _Doe / 146096) / 365; - const int _Ye = static_cast(_Yoe) + _Era * 400; - const unsigned _Doy = _Doe - (365 * _Yoe + _Yoe / 4 - _Yoe / 100); - const unsigned _Mp = (5 * _Doy + 2) / 153; - const unsigned _Da = _Doy - (153 * _Mp + 2) / 5 + 1; - const unsigned _Mo = _Mp + (_Mp < 10 ? 3 : static_cast(-9)); - return year_month_day(chrono::year{_Ye + (_Mo <= 2)}, chrono::month{_Mo}, chrono::day{_Da}); + const int _Zx = _Tp + 719468; // Shift epoch to 0000-03-01 + const int _Era = (_Zx >= 0 ? _Zx : _Zx - 146096) / 146097; + const unsigned _Day_of_era = static_cast(_Zx - _Era * 146097); // // [0, 146096] + const unsigned _Year_of_era = + (_Day_of_era - _Day_of_era / 1460 + _Day_of_era / 36524 - _Day_of_era / 146096) / 365; // [0, 399] + const int _Year = static_cast(_Year_of_era) + _Era * 400; // Where March is the first month + const unsigned _Day_of_year = + _Day_of_era - (365 * _Year_of_era + _Year_of_era / 4 - _Year_of_era / 100); // // [0, 365] + const unsigned _Mp = (5 * _Day_of_year + 2) / 153; // // [0, 11] + const unsigned _Day = _Day_of_year - (153 * _Mp + 2) / 5 + 1; // // [1, 31] + const unsigned _Month = _Mp + (_Mp < 10 ? 3 : static_cast(-9)); // [1, 12] + return year_month_day(chrono::year{_Year + (_Month <= 2)}, chrono::month{_Month}, chrono::day{_Day}); } // courtesy of Howard Hinnant // https://howardhinnant.github.io/date_algorithms.html#days_from_civil _NODISCARD constexpr days _Days_from_civil() const noexcept { static_assert(numeric_limits::digits >= 18); static_assert(numeric_limits::digits >= 20); - const int _Ye = static_cast(_Year) - (_Month <= chrono::month{2}); - const unsigned _Mo = static_cast(_Month); - const int _Era = (_Ye >= 0 ? _Ye : _Ye - 399) / 400; - const unsigned _Yoe = static_cast(_Ye - _Era * 400); - const unsigned _Doy = - (153 * (_Mo + (_Mo > 2 ? static_cast(-3) : 9)) + 2) / 5 + static_cast(_Day) - 1; - const unsigned _Doe = _Yoe * 365 + _Yoe / 4 - _Yoe / 100 + _Doy; - return days{_Era * 146097 + static_cast(_Doe) - 719468}; + const int _Ye = static_cast(_Year) - (_Month <= chrono::month{2}); + const unsigned _Mo = static_cast(_Month); + const int _Era = (_Ye >= 0 ? _Ye : _Ye - 399) / 400; + const unsigned _Year_of_era = static_cast(_Ye - _Era * 400); // [0, 399] + const unsigned _Day_of_year = (153 * (_Mo + (_Mo > 2 ? static_cast(-3) : 9)) + 2) / 5 + + static_cast(_Day) - 1; // [0, 365] + const unsigned _Day_of_era = + _Year_of_era * 365 + _Year_of_era / 4 - _Year_of_era / 100 + _Day_of_year; // [0, 146096] + return days{_Era * 146097 + static_cast(_Day_of_era) - 719468}; } }; From 2e52d57c07797ae46eeffbf9113a104fb6e2948a Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Fri, 25 Sep 2020 15:33:30 +0100 Subject: [PATCH 088/143] Add test cases for constant evaluation --- .../test.cpp | 35 ++++++++++++++++--- 1 file changed, 31 insertions(+), 4 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 0797d83df18..800dfee5695 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -241,7 +241,13 @@ constexpr void month_weekday_test() { assert(January / Monday[2] == January / Monday[2]); - if (!is_constant_evaluated()) { + if (is_constant_evaluated()) { + static_assert((January / Monday[1]).ok()); + static_assert((January / Monday[5]).ok()); + static_assert(!(January / Monday[6]).ok()); + static_assert(!(January / Monday[0]).ok()); + static_assert(!(month{0} / Monday[1]).ok()); + } else { for (auto m = 0u; m <= 255u; ++m) { for (auto wd = 0u; wd <= 255u; ++wd) { for (auto wdi = 0u; wdi <= 6u; ++wdi) { @@ -301,7 +307,10 @@ constexpr void year_month_test() { assert(ym - years{2} == 2018y / January); - if (!is_constant_evaluated()) { + if (is_constant_evaluated()) { + static_assert((2020y / 01).ok()); + static_assert(!(2020y / 13).ok()); + } else { for (int y = y_min; y <= y_max; y++) { for (auto m = 0u; m <= 255u; ++m) { const auto ym2 = year{y} / month{m}; @@ -384,7 +393,22 @@ constexpr void year_month_day_test() { assert(2020y / January / 1d - years{2} == 2018y / January / 1d); - if (!is_constant_evaluated()) { + if (is_constant_evaluated()) { + static_assert(!(-32768y / 01 / 01).ok()); + static_assert(!(32768y / 01 / 01).ok()); + static_assert((2020y / 01 / 01).ok()); + + static_assert(!(2020y / 00 / 01).ok()); + static_assert(!(2020y / 13 / 01).ok()); + static_assert((2020y / 05 / 01).ok()); + + static_assert(!(2020y / 02 / 30).ok()); + static_assert(!(2019y / 02 / 29).ok()); + static_assert(!(2020y / 01 / 00).ok()); + static_assert(!(2020y / 01 / 32).ok()); + static_assert((2020y / 02 / 29).ok()); + static_assert((2020y / 07 / 31).ok()); + } else { for (int iy = y_min; iy <= y_max; ++iy) { for (auto um = 0u; um <= 255u; ++um) { for (auto ud = 0u; ud <= 32u; ++ud) { @@ -441,7 +465,10 @@ constexpr void year_month_day_last_test() { assert(ymdl - years{2} == 2018y / February / last); - if (!is_constant_evaluated()) { + if (is_constant_evaluated()) { + static_assert((2020y / 01 / last).ok()); + static_assert(!(2020y / 13 / last).ok()); + } else { for (int iy = y_min; iy <= y_max; ++iy) { for (auto m = 0u; m <= 255u; ++m) { const year y{iy}; From 93b39a17104c89594f785b6e1643e02ab26ef38f Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Fri, 25 Sep 2020 15:43:56 +0100 Subject: [PATCH 089/143] _CHRONO --- stl/inc/chrono | 178 +++++++++++++++++++++---------------------- stl/inc/yvals_core.h | 1 + 2 files changed, 90 insertions(+), 89 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 238b6eb2b86..7db1977e76b 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -109,7 +109,7 @@ namespace chrono { int> = 0> constexpr duration(const duration<_Rep2, _Period2>& _Dur) noexcept( is_arithmetic_v<_Rep>&& is_arithmetic_v<_Rep2>) // strengthened - : _MyRep(chrono::duration_cast(_Dur).count()) {} + : _MyRep(_CHRONO duration_cast(_Dur).count()) {} _NODISCARD constexpr _Rep count() const noexcept(is_arithmetic_v<_Rep>) /* strengthened */ { return _MyRep; @@ -262,16 +262,16 @@ struct _Lcm : integral_constant::value) * _Bx> { // STRUCT TEMPLATE common_type SPECIALIZATIONS template -struct common_type, - chrono::duration<_Rep2, _Period2>> { // common type of two durations - using type = chrono::duration, +struct common_type<_CHRONO duration<_Rep1, _Period1>, + _CHRONO duration<_Rep2, _Period2>> { // common type of two durations + using type = _CHRONO duration, ratio<_Gcd<_Period1::num, _Period2::num>::value, _Lcm<_Period1::den, _Period2::den>::value>>; }; template -struct common_type, - chrono::time_point<_Clock, _Duration2>> { // common type of two time points - using type = chrono::time_point<_Clock, common_type_t<_Duration1, _Duration2>>; +struct common_type<_CHRONO time_point<_Clock, _Duration1>, + _CHRONO time_point<_Clock, _Duration2>> { // common type of two time points + using type = _CHRONO time_point<_Clock, common_type_t<_Duration1, _Duration2>>; }; namespace chrono { @@ -442,7 +442,7 @@ namespace chrono { is_arithmetic_v<_Rep>&& is_arithmetic_v) /* strengthened */ { // convert duration to another duration; round towards negative infinity // i.e. the greatest integral result such that the result <= _Dur - const _To _Casted{chrono::duration_cast<_To>(_Dur)}; + const _To _Casted{_CHRONO duration_cast<_To>(_Dur)}; if (_Casted > _Dur) { return _To{_Casted.count() - static_cast(1)}; } @@ -456,7 +456,7 @@ namespace chrono { is_arithmetic_v<_Rep>&& is_arithmetic_v) /* strengthened */ { // convert duration to another duration; round towards positive infinity // i.e. the least integral result such that _Dur <= the result - const _To _Casted{chrono::duration_cast<_To>(_Dur)}; + const _To _Casted{_CHRONO duration_cast<_To>(_Dur)}; if (_Casted < _Dur) { return _To{_Casted.count() + static_cast(1)}; } @@ -476,7 +476,7 @@ namespace chrono { _NODISCARD constexpr _To round(const duration<_Rep, _Period>& _Dur) noexcept( is_arithmetic_v<_Rep>&& is_arithmetic_v) /* strengthened */ { // convert duration to another duration, round to nearest, ties to even - const _To _Floored{chrono::floor<_To>(_Dur)}; + const _To _Floored{_CHRONO floor<_To>(_Dur)}; const _To _Ceiled{_Floored + _To{1}}; const auto _Floor_adjustment = _Dur - _Floored; const auto _Ceil_adjustment = _Ceiled - _Dur; @@ -589,7 +589,7 @@ namespace chrono { _NODISCARD constexpr time_point<_Clock, _To> time_point_cast(const time_point<_Clock, _Duration>& _Time) noexcept( is_arithmetic_v&& is_arithmetic_v) /* strengthened */ { // change the duration type of a time_point; truncate - return time_point<_Clock, _To>(chrono::duration_cast<_To>(_Time.time_since_epoch())); + return time_point<_Clock, _To>(_CHRONO duration_cast<_To>(_Time.time_since_epoch())); } // FUNCTION TEMPLATE floor (for time_point instances) @@ -597,7 +597,7 @@ namespace chrono { _NODISCARD constexpr time_point<_Clock, _To> floor(const time_point<_Clock, _Duration>& _Time) noexcept( is_arithmetic_v&& is_arithmetic_v) /* strengthened */ { // change the duration type of a time_point; round towards negative infinity - return time_point<_Clock, _To>(chrono::floor<_To>(_Time.time_since_epoch())); + return time_point<_Clock, _To>(_CHRONO floor<_To>(_Time.time_since_epoch())); } // FUNCTION TEMPLATE ceil (for time_point instances) @@ -605,7 +605,7 @@ namespace chrono { _NODISCARD constexpr time_point<_Clock, _To> ceil(const time_point<_Clock, _Duration>& _Time) noexcept( is_arithmetic_v&& is_arithmetic_v) /* strengthened */ { // change the duration type of a time_point; round towards positive infinity - return time_point<_Clock, _To>(chrono::ceil<_To>(_Time.time_since_epoch())); + return time_point<_Clock, _To>(_CHRONO ceil<_To>(_Time.time_since_epoch())); } // FUNCTION TEMPLATE round (for time_point instances) @@ -614,7 +614,7 @@ namespace chrono { _NODISCARD constexpr time_point<_Clock, _To> round(const time_point<_Clock, _Duration>& _Time) noexcept( is_arithmetic_v&& is_arithmetic_v) /* strengthened */ { // change the duration type of a time_point; round to nearest, ties to even - return time_point<_Clock, _To>(chrono::round<_To>(_Time.time_since_epoch())); + return time_point<_Clock, _To>(_CHRONO round<_To>(_Time.time_since_epoch())); } // CLOCKS @@ -623,8 +623,8 @@ namespace chrono { using period = ratio_multiply, nano>; - using duration = chrono::duration; - using time_point = chrono::time_point; + using duration = _CHRONO duration; + using time_point = _CHRONO time_point; static constexpr bool is_steady = false; _NODISCARD static time_point now() noexcept { // get current time @@ -652,7 +652,7 @@ namespace chrono { using rep = long long; using period = nano; using duration = nanoseconds; - using time_point = chrono::time_point; + using time_point = _CHRONO time_point; static constexpr bool is_steady = true; _NODISCARD static time_point now() noexcept { // get current time @@ -996,7 +996,7 @@ namespace chrono { } private: - chrono::weekday _Weekday; + _CHRONO weekday _Weekday; unsigned char _Index; }; @@ -1016,7 +1016,7 @@ namespace chrono { } private: - chrono::weekday _Weekday; + _CHRONO weekday _Weekday; }; constexpr bool operator==(const weekday_last& _Left, const weekday_last& _Right) noexcept { @@ -1060,8 +1060,8 @@ namespace chrono { } private: - chrono::month _Month; - chrono::day _Day; + _CHRONO month _Month; + _CHRONO day _Day; }; constexpr bool operator==(const month_day& _Left, const month_day& _Right) noexcept { @@ -1088,7 +1088,7 @@ namespace chrono { } private: - chrono::month _Month; + _CHRONO month _Month; }; constexpr bool operator==(const month_day_last& _Left, const month_day_last& _Right) noexcept { @@ -1115,8 +1115,8 @@ namespace chrono { } private: - chrono::month _Month; - chrono::weekday_indexed _Weekday_index; + _CHRONO month _Month; + _CHRONO weekday_indexed _Weekday_index; }; constexpr bool operator==(const month_weekday& _Left, const month_weekday& _Right) noexcept { @@ -1139,8 +1139,8 @@ namespace chrono { } private: - chrono::month _Month; - chrono::weekday_last _Weekday_last; + _CHRONO month _Month; + _CHRONO weekday_last _Weekday_last; }; constexpr bool operator==(const month_weekday_last& _Left, const month_weekday_last& _Right) noexcept { @@ -1169,8 +1169,8 @@ namespace chrono { } private: - chrono::year _Year; - chrono::month _Month; + _CHRONO year _Year; + _CHRONO month _Month; }; constexpr bool operator==(const year_month& _Left, const year_month& _Right) noexcept { @@ -1278,13 +1278,13 @@ namespace chrono { return false; } - return _Day >= chrono::day{1} && _Day <= _Last_day(_Year, _Month); + return _Day >= _CHRONO day{1} && _Day <= _Last_day(_Year, _Month); } private: - chrono::year _Year; - chrono::month _Month; - chrono::day _Day; + _CHRONO year _Year; + _CHRONO month _Month; + _CHRONO day _Day; // courtesy of Howard Hinnant // https://howardhinnant.github.io/date_algorithms.html#civil_from_days @@ -1302,14 +1302,14 @@ namespace chrono { const unsigned _Mp = (5 * _Day_of_year + 2) / 153; // // [0, 11] const unsigned _Day = _Day_of_year - (153 * _Mp + 2) / 5 + 1; // // [1, 31] const unsigned _Month = _Mp + (_Mp < 10 ? 3 : static_cast(-9)); // [1, 12] - return year_month_day(chrono::year{_Year + (_Month <= 2)}, chrono::month{_Month}, chrono::day{_Day}); + return year_month_day(_CHRONO year{_Year + (_Month <= 2)}, _CHRONO month{_Month}, _CHRONO day{_Day}); } // courtesy of Howard Hinnant // https://howardhinnant.github.io/date_algorithms.html#days_from_civil _NODISCARD constexpr days _Days_from_civil() const noexcept { static_assert(numeric_limits::digits >= 18); static_assert(numeric_limits::digits >= 20); - const int _Ye = static_cast(_Year) - (_Month <= chrono::month{2}); + const int _Ye = static_cast(_Year) - (_Month <= _CHRONO month{2}); const unsigned _Mo = static_cast(_Month); const int _Era = (_Ye >= 0 ? _Ye : _Ye - 399) / 400; const unsigned _Year_of_era = static_cast(_Ye - _Era * 400); // [0, 399] @@ -1414,8 +1414,8 @@ namespace chrono { } private: - chrono::year _Year; - chrono::month_day_last _Month_day_last; + _CHRONO year _Year; + _CHRONO month_day_last _Month_day_last; }; constexpr bool operator==(const year_month_day_last& _Left, const year_month_day_last& _Right) noexcept { @@ -1506,7 +1506,7 @@ namespace chrono { _NODISCARD constexpr operator sys_days() const noexcept { const sys_days _First = year_month_day{_Year, _Month, day{1}}; - const days _Diff = weekday() - chrono::weekday{_First}; + const days _Diff = weekday() - _CHRONO weekday{_First}; const days _Days = _Diff + days{(static_cast(index()) - 1) * 7}; return _First + _Days; } @@ -1525,19 +1525,19 @@ namespace chrono { // As index() == 5 is not always valid // Determine the date of the first weekday and check if + days{28} is <= last day of the month const sys_days _First_of_month = year_month_day{_Year, _Month, day{1}}; - const days _First_weekday = weekday() - chrono::weekday{_First_of_month} + days{1}; + const days _First_weekday = weekday() - _CHRONO weekday{_First_of_month} + days{1}; const days _Last = _First_weekday + days{28}; return static_cast(_Last.count()) <= static_cast(_Last_day(_Year, _Month)); } private: - chrono::year _Year; - chrono::month _Month; - chrono::weekday_indexed _Weekday_index; + _CHRONO year _Year; + _CHRONO month _Month; + _CHRONO weekday_indexed _Weekday_index; _NODISCARD static constexpr year_month_weekday _Ymwd_from_days(days _Dp) noexcept { - const chrono::year_month_day _Ymd = sys_days{_Dp}; - const chrono::weekday _Wd = sys_days{_Dp}; + const _CHRONO year_month_day _Ymd = sys_days{_Dp}; + const _CHRONO weekday _Wd = sys_days{_Dp}; const auto _Idx = ((static_cast(_Ymd.day()) - 1) / 7) + 1; return {_Ymd.year(), _Ymd.month(), _Wd[_Idx]}; } @@ -1614,7 +1614,7 @@ namespace chrono { _NODISCARD constexpr operator sys_days() const noexcept { const sys_days _Last = year_month_day_last{_Year, month_day_last{_Month}}; - const auto _Diff = chrono::weekday{_Last} - weekday(); + const auto _Diff = _CHRONO weekday{_Last} - weekday(); return _Last - _Diff; } _NODISCARD constexpr explicit operator local_days() const noexcept { @@ -1625,9 +1625,9 @@ namespace chrono { } private: - chrono::year _Year; - chrono::month _Month; - chrono::weekday_last _Weekday_last; + _CHRONO year _Year; + _CHRONO month _Month; + _CHRONO weekday_last _Weekday_last; }; constexpr bool operator==(const year_month_weekday_last& _Left, const year_month_weekday_last& _Right) noexcept { @@ -1852,14 +1852,14 @@ namespace chrono { // clang-format off constexpr explicit hh_mm_ss(_Duration _Dur) : _Is_neg{_Dur < _Duration::zero()}, - _Hours{chrono::duration_cast(chrono::abs(_Dur))}, - _Mins{chrono::duration_cast(chrono::abs(_Dur) - hours())}, - _Secs{chrono::duration_cast(chrono::abs(_Dur) - hours() - minutes())} { + _Hours{_CHRONO duration_cast<_CHRONO hours>(_CHRONO abs(_Dur))}, + _Mins{_CHRONO duration_cast<_CHRONO minutes>(_CHRONO abs(_Dur) - hours())}, + _Secs{_CHRONO duration_cast<_CHRONO seconds>(_CHRONO abs(_Dur) - hours() - minutes())} { // clang-format on if constexpr (treat_as_floating_point_v) { - _Sub_secs = chrono::abs(_Dur) - hours() - minutes() - seconds(); + _Sub_secs = _CHRONO abs(_Dur) - hours() - minutes() - seconds(); } else { - _Sub_secs = chrono::duration_cast(chrono::abs(_Dur) - hours() - minutes() - seconds()); + _Sub_secs = _CHRONO duration_cast(_CHRONO abs(_Dur) - hours() - minutes() - seconds()); } } @@ -1889,9 +1889,9 @@ namespace chrono { private: bool _Is_neg; - chrono::hours _Hours; - chrono::minutes _Mins; - chrono::seconds _Secs; + _CHRONO hours _Hours; + _CHRONO minutes _Mins; + _CHRONO seconds _Secs; precision _Sub_secs; }; @@ -1916,23 +1916,23 @@ namespace chrono { // HELPERS template -_NODISCARD bool _To_xtime_10_day_clamped(_CSTD xtime& _Xt, const chrono::duration<_Rep, _Period>& _Rel_time) noexcept( +_NODISCARD bool _To_xtime_10_day_clamped(_CSTD xtime& _Xt, const _CHRONO duration<_Rep, _Period>& _Rel_time) noexcept( is_arithmetic_v<_Rep>) { // Convert duration to xtime, maximum 10 days from now, returns whether clamping occurred. // If clamped, timeouts will be transformed into spurious non-timeout wakes, due to ABI restrictions where // the other side of the DLL boundary overflows int32_t milliseconds. // Every function calling this one is TRANSITION, ABI - constexpr chrono::nanoseconds _Ten_days{chrono::hours{24} * 10}; - constexpr chrono::duration _Ten_days_d{_Ten_days}; - chrono::nanoseconds _Tx0 = chrono::system_clock::now().time_since_epoch(); + constexpr _CHRONO nanoseconds _Ten_days{_CHRONO hours{24} * 10}; + constexpr _CHRONO duration _Ten_days_d{_Ten_days}; + _CHRONO nanoseconds _Tx0 = _CHRONO system_clock::now().time_since_epoch(); const bool _Clamped = _Ten_days_d < _Rel_time; if (_Clamped) { _Tx0 += _Ten_days; } else { - _Tx0 += chrono::duration_cast(_Rel_time); + _Tx0 += _CHRONO duration_cast<_CHRONO nanoseconds>(_Rel_time); } - const auto _Whole_seconds = chrono::duration_cast(_Tx0); + const auto _Whole_seconds = _CHRONO duration_cast<_CHRONO seconds>(_Tx0); _Xt.sec = _Whole_seconds.count(); _Tx0 -= _Whole_seconds; _Xt.nsec = static_cast(_Tx0.count()); @@ -1942,64 +1942,64 @@ _NODISCARD bool _To_xtime_10_day_clamped(_CSTD xtime& _Xt, const chrono::duratio // duration LITERALS inline namespace literals { inline namespace chrono_literals { - _NODISCARD constexpr chrono::hours operator"" h(unsigned long long _Val) noexcept /* strengthened */ { - return chrono::hours(_Val); + _NODISCARD constexpr _CHRONO hours operator"" h(unsigned long long _Val) noexcept /* strengthened */ { + return _CHRONO hours(_Val); } - _NODISCARD constexpr chrono::duration> operator"" h(long double _Val) noexcept + _NODISCARD constexpr _CHRONO duration> operator"" h(long double _Val) noexcept /* strengthened */ { - return chrono::duration>(_Val); + return _CHRONO duration>(_Val); } - _NODISCARD constexpr chrono::minutes(operator"" min)(unsigned long long _Val) noexcept /* strengthened */ { - return chrono::minutes(_Val); + _NODISCARD constexpr _CHRONO minutes(operator"" min)(unsigned long long _Val) noexcept /* strengthened */ { + return _CHRONO minutes(_Val); } - _NODISCARD constexpr chrono::duration>(operator"" min)(long double _Val) noexcept + _NODISCARD constexpr _CHRONO duration>(operator"" min)(long double _Val) noexcept /* strengthened */ { - return chrono::duration>(_Val); + return _CHRONO duration>(_Val); } - _NODISCARD constexpr chrono::seconds operator"" s(unsigned long long _Val) noexcept /* strengthened */ { - return chrono::seconds(_Val); + _NODISCARD constexpr _CHRONO seconds operator"" s(unsigned long long _Val) noexcept /* strengthened */ { + return _CHRONO seconds(_Val); } - _NODISCARD constexpr chrono::duration operator"" s(long double _Val) noexcept /* strengthened */ { - return chrono::duration(_Val); + _NODISCARD constexpr _CHRONO duration operator"" s(long double _Val) noexcept /* strengthened */ { + return _CHRONO duration(_Val); } - _NODISCARD constexpr chrono::milliseconds operator"" ms(unsigned long long _Val) noexcept /* strengthened */ { - return chrono::milliseconds(_Val); + _NODISCARD constexpr _CHRONO milliseconds operator"" ms(unsigned long long _Val) noexcept /* strengthened */ { + return _CHRONO milliseconds(_Val); } - _NODISCARD constexpr chrono::duration operator"" ms(long double _Val) noexcept + _NODISCARD constexpr _CHRONO duration operator"" ms(long double _Val) noexcept /* strengthened */ { - return chrono::duration(_Val); + return _CHRONO duration(_Val); } - _NODISCARD constexpr chrono::microseconds operator"" us(unsigned long long _Val) noexcept /* strengthened */ { - return chrono::microseconds(_Val); + _NODISCARD constexpr _CHRONO microseconds operator"" us(unsigned long long _Val) noexcept /* strengthened */ { + return _CHRONO microseconds(_Val); } - _NODISCARD constexpr chrono::duration operator"" us(long double _Val) noexcept + _NODISCARD constexpr _CHRONO duration operator"" us(long double _Val) noexcept /* strengthened */ { - return chrono::duration(_Val); + return _CHRONO duration(_Val); } - _NODISCARD constexpr chrono::nanoseconds operator"" ns(unsigned long long _Val) noexcept /* strengthened */ { - return chrono::nanoseconds(_Val); + _NODISCARD constexpr _CHRONO nanoseconds operator"" ns(unsigned long long _Val) noexcept /* strengthened */ { + return _CHRONO nanoseconds(_Val); } - _NODISCARD constexpr chrono::duration operator"" ns(long double _Val) noexcept + _NODISCARD constexpr _CHRONO duration operator"" ns(long double _Val) noexcept /* strengthened */ { - return chrono::duration(_Val); + return _CHRONO duration(_Val); } #if _HAS_CXX20 - _NODISCARD constexpr chrono::day operator"" d(unsigned long long _Day) noexcept { - return chrono::day{static_cast(_Day)}; + _NODISCARD constexpr _CHRONO day operator"" d(unsigned long long _Day) noexcept { + return _CHRONO day{static_cast(_Day)}; } - _NODISCARD constexpr chrono::year operator"" y(unsigned long long _Year) noexcept { - return chrono::year{static_cast(_Year)}; + _NODISCARD constexpr _CHRONO year operator"" y(unsigned long long _Year) noexcept { + return _CHRONO year{static_cast(_Year)}; } #endif // _HAS_CXX20 } // namespace chrono_literals diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h index 7eade4bc709..e145a4a3be7 100644 --- a/stl/inc/yvals_core.h +++ b/stl/inc/yvals_core.h @@ -1239,6 +1239,7 @@ compiler option, or define _ALLOW_RTCc_IN_STL to acknowledge that you have recei #define _STD_BEGIN namespace std { #define _STD_END } #define _STD ::std:: +#define _CHRONO ::std::chrono:: #define _RANGES ::std::ranges:: // We use the stdext (standard extension) namespace to contain extensions that are not part of the current standard From b2cba79d8ad5fb40102301fc83027bdeb499bdde Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Fri, 25 Sep 2020 16:08:19 +0100 Subject: [PATCH 090/143] One of these days... --- tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 800dfee5695..91f754027c3 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -407,7 +407,7 @@ constexpr void year_month_day_test() { static_assert(!(2020y / 01 / 00).ok()); static_assert(!(2020y / 01 / 32).ok()); static_assert((2020y / 02 / 29).ok()); - static_assert((2020y / 07 / 31).ok()); + static_assert((2020y / 07 / 31).ok()); } else { for (int iy = y_min; iy <= y_max; ++iy) { for (auto um = 0u; um <= 255u; ++um) { From 47dcd9717804c852e0e6d35cfc4b2fb35e0806d6 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Fri, 25 Sep 2020 18:24:42 +0100 Subject: [PATCH 091/143] [skip ci] Rename _Width --- stl/inc/chrono | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 7db1977e76b..9d21da95bbf 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1822,9 +1822,9 @@ namespace chrono { inline constexpr month December{12}; // Returns the number of fractional digits of _Num / _Den. - // Example: _Width(1, 8) would return 3 for 0.125. + // Example: _Fractional_width(1, 8) would return 3 for 0.125. // If it can't be represented 6 is returned. - constexpr unsigned _Width(intmax_t _Num, const intmax_t _Den) { + constexpr unsigned _Fractional_width(intmax_t _Num, const intmax_t _Den) { _STL_ASSERT(_Den > 0, "Denominator can't be less than 1."); unsigned _Result = 0; // doing everything in for > using a while loop @@ -1844,7 +1844,7 @@ namespace chrono { template requires _Is_duration_v<_Duration> class hh_mm_ss { public: - static constexpr unsigned fractional_width = _Width(_Duration::period::num, _Duration::period::den); + static constexpr unsigned fractional_width = _Fractional_width(_Duration::period::num, _Duration::period::den); using precision = duration, ratio<1, _Pow10(fractional_width)>>; From 95d9c6ae441701cc2d5cccab4bd05b2c18cc9e5d Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Fri, 2 Oct 2020 09:53:01 +0100 Subject: [PATCH 092/143] Use @MattStephanson's implementation. Co-Authored-By: MattStephanson <68978048+MattStephanson@users.noreply.github.com> --- stl/inc/chrono | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 9d21da95bbf..31cba524974 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1903,13 +1903,20 @@ namespace chrono { } _NODISCARD constexpr hours make12(const hours& _Hours) noexcept { - return _Hours == hours{12} || _Hours == hours{0} ? hours{12} : _Hours % 12; + const auto _H_count{_Hours.count()}; + auto _Ret{_H_count == 0 ? 12 : _H_count}; + if (_Ret > 12) { + _Ret -= 12; + } + return hours{_Ret}; } _NODISCARD constexpr hours make24(const hours& _Hours, bool _Is_pm) noexcept { + const auto _H_count{_Hours.count()}; + auto _Ret{_H_count == 12 ? 0 : _H_count}; if (_Is_pm) { - return _Hours == hours{12} ? _Hours : _Hours + hours{12}; + _Ret += 12; } - return _Hours == hours{12} ? hours{0} : _Hours; + return hours{_Ret}; } #endif // _HAS_CXX20 } // namespace chrono From 00dd2373b761544eae5b2e605d831301b0b6d645 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Fri, 2 Oct 2020 10:00:38 +0100 Subject: [PATCH 093/143] Add range for Fractional_width comment and reorder --- stl/inc/chrono | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 31cba524974..5b6e5f1e61d 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1821,9 +1821,9 @@ namespace chrono { inline constexpr month November{11}; inline constexpr month December{12}; - // Returns the number of fractional digits of _Num / _Den. - // Example: _Fractional_width(1, 8) would return 3 for 0.125. + // Returns the number of fractional digits of _Num / _Den in the range [0, 18]. // If it can't be represented 6 is returned. + // Example: _Fractional_width(1, 8) would return 3 for 0.125. constexpr unsigned _Fractional_width(intmax_t _Num, const intmax_t _Den) { _STL_ASSERT(_Den > 0, "Denominator can't be less than 1."); unsigned _Result = 0; From 96f7df42fce3f6f1ffdd801b79d454f4a43da9b3 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Tue, 13 Oct 2020 19:28:09 +0100 Subject: [PATCH 094/143] Apply suggestions from code review Co-authored-by: mnatsuhara <46756417+mnatsuhara@users.noreply.github.com> --- stl/inc/chrono | 43 ++++++++++--------- tests/libcxx/skipped_tests.txt | 2 +- .../test.cpp | 2 +- .../test.cpp | 3 -- .../test.cpp | 3 +- 5 files changed, 25 insertions(+), 28 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 5b6e5f1e61d..1a1a950522e 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -764,7 +764,7 @@ namespace chrono { return *this; } constexpr month operator--(int) noexcept { - month _Temp{*this}; + const month _Temp{*this}; --(*this); return _Temp; } @@ -910,7 +910,8 @@ namespace chrono { return *this += days{1}; } constexpr weekday operator++(int) noexcept { - weekday _Temp{*this}; + const weekday _Temp{*this}; + ++(*this); return _Temp; } @@ -1034,7 +1035,7 @@ namespace chrono { class month_day { public: month_day() = default; - constexpr month_day(const month& _M, const day& _D) noexcept : _Month{_M}, _Day{_D} {} + constexpr month_day(const month& _Month_, const day& _Day_) noexcept : _Month{_Month_}, _Day{_Day_} {} _NODISCARD constexpr month month() const noexcept { return _Month; @@ -1068,7 +1069,7 @@ namespace chrono { return _Left.month() == _Right.month() && _Left.day() == _Right.day(); } constexpr strong_ordering operator<=>(const month_day& _Left, const month_day& _Right) noexcept { - auto _Comp = _Left.month() <=> _Right.month(); + const auto _Comp = _Left.month() <=> _Right.month(); if (_Comp != 0) { return _Comp; } @@ -1177,7 +1178,7 @@ namespace chrono { return _Left.year() == _Right.year() && _Left.month() == _Right.month(); } constexpr strong_ordering operator<=>(const year_month& _Left, const year_month& _Right) noexcept { - auto _Comp = _Left.year() <=> _Right.year(); + const auto _Comp = _Left.year() <=> _Right.year(); if (_Comp != 0) { return _Comp; } @@ -1241,11 +1242,10 @@ namespace chrono { } class year_month_day { - public: year_month_day() = default; - constexpr year_month_day(const year& _Y, const month& _M, const day& _D) noexcept - : _Year{_Y}, _Month{_M}, _Day{_D} {} + constexpr year_month_day(const year& _Year_, const month& _Month_, const day& _Day_) noexcept + : _Year{_Year_}, _Month{_Month_}, _Day{_Day_} {} constexpr year_month_day(const class year_month_day_last& _Ymdl) noexcept; constexpr year_month_day(const sys_days& _Sys_days) noexcept : year_month_day{_Civil_from_days(_Sys_days.time_since_epoch().count())} {} @@ -1293,14 +1293,14 @@ namespace chrono { static_assert(numeric_limits::digits >= 20); const int _Zx = _Tp + 719468; // Shift epoch to 0000-03-01 const int _Era = (_Zx >= 0 ? _Zx : _Zx - 146096) / 146097; - const unsigned _Day_of_era = static_cast(_Zx - _Era * 146097); // // [0, 146096] + const unsigned _Day_of_era = static_cast(_Zx - _Era * 146097); // [0, 146096] const unsigned _Year_of_era = (_Day_of_era - _Day_of_era / 1460 + _Day_of_era / 36524 - _Day_of_era / 146096) / 365; // [0, 399] const int _Year = static_cast(_Year_of_era) + _Era * 400; // Where March is the first month const unsigned _Day_of_year = - _Day_of_era - (365 * _Year_of_era + _Year_of_era / 4 - _Year_of_era / 100); // // [0, 365] - const unsigned _Mp = (5 * _Day_of_year + 2) / 153; // // [0, 11] - const unsigned _Day = _Day_of_year - (153 * _Mp + 2) / 5 + 1; // // [1, 31] + _Day_of_era - (365 * _Year_of_era + _Year_of_era / 4 - _Year_of_era / 100); // [0, 365] + const unsigned _Mp = (5 * _Day_of_year + 2) / 153; // [0, 11] + const unsigned _Day = _Day_of_year - (153 * _Mp + 2) / 5 + 1; // [1, 31] const unsigned _Month = _Mp + (_Mp < 10 ? 3 : static_cast(-9)); // [1, 12] return year_month_day(_CHRONO year{_Year + (_Month <= 2)}, _CHRONO month{_Month}, _CHRONO day{_Day}); } @@ -1382,8 +1382,8 @@ namespace chrono { class year_month_day_last { public: - constexpr year_month_day_last(const year& _Y, const month_day_last& _Mdl) noexcept - : _Year{_Y}, _Month_day_last{_Mdl} {} + constexpr year_month_day_last(const year& _Year_, const month_day_last& _Mdl) noexcept + : _Year{_Year_}, _Month_day_last{_Mdl} {} constexpr year_month_day_last& operator+=(const months& _Months) noexcept; constexpr year_month_day_last& operator-=(const months& _Months) noexcept; @@ -1423,7 +1423,7 @@ namespace chrono { } constexpr strong_ordering operator<=>( const year_month_day_last& _Left, const year_month_day_last& _Right) noexcept { - auto _Comp = _Left.year() <=> _Right.year(); + const auto _Comp = _Left.year() <=> _Right.year(); if (_Comp != 0) { return _Comp; } @@ -1469,15 +1469,16 @@ namespace chrono { *this = *this - _Years; return *this; } - // year + + // year_month_day constexpr year_month_day::year_month_day(const year_month_day_last& _Ymdl) noexcept : _Year{_Ymdl.year()}, _Month{_Ymdl.month()}, _Day{_Ymdl.day()} {} class year_month_weekday { public: year_month_weekday() = default; - constexpr year_month_weekday(const year& _Y, const month& _M, const weekday_indexed& _Wdi) noexcept - : _Year{_Y}, _Month{_M}, _Weekday_index{_Wdi} {} + constexpr year_month_weekday(const year& _Year_, const month& _Month_, const weekday_indexed& _Wdi) noexcept + : _Year{_Year_}, _Month{_Month_}, _Weekday_index{_Wdi} {} constexpr year_month_weekday(const sys_days& _Sys_days) noexcept : year_month_weekday{_Ymwd_from_days(_Sys_days.time_since_epoch())} {} constexpr explicit year_month_weekday(const local_days& _Local_days) noexcept @@ -1590,8 +1591,8 @@ namespace chrono { class year_month_weekday_last { public: - constexpr year_month_weekday_last(const year& _Y, const month& _M, const weekday_last& _Wdl) noexcept - : _Year{_Y}, _Month{_M}, _Weekday_last{_Wdl} {} + constexpr year_month_weekday_last(const year& _Year_, const month& _Month_, const weekday_last& _Wdl) noexcept + : _Year{_Year_}, _Month{_Month_}, _Weekday_last{_Wdl} {} constexpr year_month_weekday_last& operator+=(const months& _Months) noexcept; constexpr year_month_weekday_last& operator-=(const months& _Months) noexcept; @@ -1822,7 +1823,7 @@ namespace chrono { inline constexpr month December{12}; // Returns the number of fractional digits of _Num / _Den in the range [0, 18]. - // If it can't be represented 6 is returned. + // If it can't be represented, 6 is returned. // Example: _Fractional_width(1, 8) would return 3 for 0.125. constexpr unsigned _Fractional_width(intmax_t _Num, const intmax_t _Den) { _STL_ASSERT(_Den > 0, "Denominator can't be less than 1."); diff --git a/tests/libcxx/skipped_tests.txt b/tests/libcxx/skipped_tests.txt index 8ac052ec12c..9e6170b95d3 100644 --- a/tests/libcxx/skipped_tests.txt +++ b/tests/libcxx/skipped_tests.txt @@ -258,7 +258,7 @@ utilities\memory\default.allocator\allocator.members\allocate.verify.cpp utilities\time\time.cal\time.cal.day\time.cal.day.nonmembers\streaming.pass.cpp utilities\time\time.cal\time.cal.md\time.cal.md.nonmembers\streaming.pass.cpp utilities\time\time.cal\time.cal.mdlast\streaming.pass.cpp -# --month{14} should be 1 not 13 as the test expects +# --month{14} should be 1, not 13 as the test expects utilities\time\time.cal\time.cal.month\time.cal.month.members\decrement.pass.cpp utilities\time\time.cal\time.cal.month\time.cal.month.nonmembers\streaming.pass.cpp # test is broken due to month_weekday not being default constructible diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.cpp index 75130d58b7f..fa1aeb03f56 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.cpp @@ -29,4 +29,4 @@ static_assert(is_clock_v, "steady_clock is not a clock"); static_assert(is_clock_v, "real_fake_clock is not a clock"); static_assert(!is_clock_v, "not_a_clock is a clock"); -int main() {} +int main() {} // COMPILE-ONLY diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 91f754027c3..5d40dabc40e 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -43,7 +43,6 @@ constexpr void day_test() { } constexpr void month_test() { - month m{1u}; assert(static_cast(m) == 1u); assert(m == January); @@ -74,7 +73,6 @@ constexpr void month_test() { assert(February + months{11} == January); assert(months{11} + February == January); assert(February - months{2} == December); - assert(January - February == months{11}); } @@ -299,7 +297,6 @@ constexpr void year_month_test() { assert(months{2} + ym == 2020y / March); assert(ym - months{2} == 2019y / November); - assert(ym - 2019y / January == months{12}); assert(ym + years{2} == 2022y / January); diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.cpp index a41d135f14a..b7dbae2d67f 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.cpp @@ -78,8 +78,8 @@ TYPE_ASSERT(month_weekday, Monday[1] / 1) TYPE_ASSERT(month_weekday_last, January / Monday[last]) TYPE_ASSERT(month_weekday_last, 1 / Monday[last]) -TYPE_ASSERT(month_weekday_last, Monday[last] / 1) TYPE_ASSERT(month_weekday_last, Monday[last] / January) +TYPE_ASSERT(month_weekday_last, Monday[last] / 1) TYPE_ASSERT(year_month_day, 2020y / January / 1d) TYPE_ASSERT(year_month_day, 2020y / January / 1) @@ -122,7 +122,6 @@ TYPE_ASSERT(year_month_weekday_last, Monday[last] / 1 / 2020) TYPE_ASSERT(year_month_weekday_last, Monday[last] / January / 2020) TYPE_ASSERT(year_month_weekday_last, Monday[last] / January / 2020y) - #define VALUE_ASSERT(VALUE, EXPECTED) static_assert(VALUE == EXPECTED, "chrono::" #VALUE " is not " #EXPECTED); VALUE_ASSERT(month{1}, January) VALUE_ASSERT(month{2}, February) From afffe87303204cce0001c3b9e114f3257ee87a33 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Thu, 15 Oct 2020 12:24:46 +0100 Subject: [PATCH 095/143] Small fixes * _NODISCARD * private _Fractional_width * unsigned int * new lines --- stl/inc/chrono | 316 +++++++++--------- .../test.cpp | 16 +- 2 files changed, 173 insertions(+), 159 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 1a1a950522e..61639aa30c7 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -688,7 +688,7 @@ namespace chrono { class day { public: day() = default; - constexpr explicit day(unsigned _Val) noexcept : _Day{static_cast(_Val)} {} + constexpr explicit day(unsigned int _Val) noexcept : _Day{static_cast(_Val)} {} constexpr day& operator++() noexcept { ++_Day; @@ -714,7 +714,7 @@ namespace chrono { return *this; } - _NODISCARD constexpr explicit operator unsigned() const noexcept { + _NODISCARD constexpr explicit operator unsigned int() const noexcept { return _Day; } _NODISCARD constexpr bool ok() const noexcept { @@ -725,30 +725,31 @@ namespace chrono { unsigned char _Day; }; - constexpr bool operator==(const day& _Left, const day& _Right) noexcept { - return static_cast(_Left) == static_cast(_Right); + _NODISCARD constexpr bool operator==(const day& _Left, const day& _Right) noexcept { + return static_cast(_Left) == static_cast(_Right); } - constexpr strong_ordering operator<=>(const day& _Left, const day& _Right) noexcept { - return static_cast(_Left) <=> static_cast(_Right); + _NODISCARD constexpr strong_ordering operator<=>(const day& _Left, const day& _Right) noexcept { + return static_cast(_Left) <=> static_cast(_Right); } - constexpr day operator+(const day& _Left, const days& _Right) noexcept { - return day{static_cast(_Left) + _Right.count()}; + _NODISCARD constexpr day operator+(const day& _Left, const days& _Right) noexcept { + return day{static_cast(_Left) + _Right.count()}; } - constexpr day operator+(const days& _Left, const day& _Right) noexcept { + _NODISCARD constexpr day operator+(const days& _Left, const day& _Right) noexcept { return _Right + _Left; } - constexpr day operator-(const day& _Left, const days& _Right) noexcept { - return day{static_cast(_Left) - _Right.count()}; + _NODISCARD constexpr day operator-(const day& _Left, const days& _Right) noexcept { + return day{static_cast(_Left) - _Right.count()}; } - constexpr days operator-(const day& _Left, const day& _Right) noexcept { - return days{static_cast(static_cast(_Left)) - static_cast(static_cast(_Right))}; + _NODISCARD constexpr days operator-(const day& _Left, const day& _Right) noexcept { + return days{ + static_cast(static_cast(_Left)) - static_cast(static_cast(_Right))}; } class month { public: month() = default; - constexpr explicit month(unsigned _Val) noexcept : _Month{static_cast(_Val)} {} + constexpr explicit month(unsigned int _Val) noexcept : _Month{static_cast(_Val)} {} constexpr month& operator++() noexcept { *this += months{1}; @@ -772,8 +773,8 @@ namespace chrono { constexpr month& operator+=(const months& _Months) noexcept; constexpr month& operator-=(const months& _Months) noexcept; - _NODISCARD constexpr explicit operator unsigned() const noexcept { - return static_cast(_Month); + _NODISCARD constexpr explicit operator unsigned int() const noexcept { + return static_cast(_Month); } _NODISCARD constexpr bool ok() const noexcept { return _Month >= 1 && _Month <= 12; @@ -783,26 +784,26 @@ namespace chrono { unsigned char _Month; }; - constexpr bool operator==(const month& _Left, const month& _Right) noexcept { - return static_cast(_Left) == static_cast(_Right); + _NODISCARD constexpr bool operator==(const month& _Left, const month& _Right) noexcept { + return static_cast(_Left) == static_cast(_Right); } - constexpr strong_ordering operator<=>(const month& _Left, const month& _Right) noexcept { - return static_cast(_Left) <=> static_cast(_Right); + _NODISCARD constexpr strong_ordering operator<=>(const month& _Left, const month& _Right) noexcept { + return static_cast(_Left) <=> static_cast(_Right); } - constexpr month operator+(const month& _Left, const months& _Right) noexcept { - const auto _Mo = static_cast(static_cast(_Left)) + (_Right.count() - 1); + _NODISCARD constexpr month operator+(const month& _Left, const months& _Right) noexcept { + const auto _Mo = static_cast(static_cast(_Left)) + (_Right.count() - 1); const auto _Div = (_Mo >= 0 ? _Mo : _Mo - 11) / 12; - return month{static_cast(_Mo - _Div * 12 + 1)}; + return month{static_cast(_Mo - _Div * 12 + 1)}; } - constexpr month operator+(const months& _Left, const month& _Right) noexcept { + _NODISCARD constexpr month operator+(const months& _Left, const month& _Right) noexcept { return _Right + _Left; } - constexpr month operator-(const month& _Left, const months& _Right) noexcept { + _NODISCARD constexpr month operator-(const month& _Left, const months& _Right) noexcept { return _Left + -_Right; } - constexpr months operator-(const month& _Left, const month& _Right) noexcept { - const auto _Mo = static_cast(_Left) - static_cast(_Right); + _NODISCARD constexpr months operator-(const month& _Left, const month& _Right) noexcept { + const auto _Mo = static_cast(_Left) - static_cast(_Right); return months{_Mo <= 11 ? _Mo : _Mo + 12}; } @@ -876,30 +877,30 @@ namespace chrono { static constexpr int _Year_max = 32767; }; - constexpr bool operator==(const year& _Left, const year& _Right) noexcept { + _NODISCARD constexpr bool operator==(const year& _Left, const year& _Right) noexcept { return static_cast(_Left) == static_cast(_Right); } - constexpr strong_ordering operator<=>(const year& _Left, const year& _Right) noexcept { + _NODISCARD constexpr strong_ordering operator<=>(const year& _Left, const year& _Right) noexcept { return static_cast(_Left) <=> static_cast(_Right); } - constexpr year operator+(const year& _Left, const years& _Right) noexcept { + _NODISCARD constexpr year operator+(const year& _Left, const years& _Right) noexcept { return year{static_cast(_Left) + _Right.count()}; } - constexpr year operator+(const years& _Left, const year& _Right) noexcept { + _NODISCARD constexpr year operator+(const years& _Left, const year& _Right) noexcept { return _Right + _Left; } - constexpr year operator-(const year& _Left, const years& _Right) noexcept { + _NODISCARD constexpr year operator-(const year& _Left, const years& _Right) noexcept { return _Left + -_Right; } - constexpr years operator-(const year& _Left, const year& _Right) noexcept { + _NODISCARD constexpr years operator-(const year& _Left, const year& _Right) noexcept { return years{static_cast(_Left) - static_cast(_Right)}; } class weekday { public: weekday() = default; - constexpr explicit weekday(unsigned _Val) noexcept + constexpr explicit weekday(unsigned int _Val) noexcept : _Weekday{static_cast(_Val == 7 ? 0 : _Val)} {} constexpr weekday(const sys_days& _Sys_day) noexcept : _Weekday{static_cast(_Weekday_from_days(_Sys_day.time_since_epoch().count()))} {} @@ -911,7 +912,6 @@ namespace chrono { } constexpr weekday operator++(int) noexcept { const weekday _Temp{*this}; - ++(*this); return _Temp; } @@ -927,17 +927,17 @@ namespace chrono { constexpr weekday& operator+=(const days& _Days) noexcept; constexpr weekday& operator-=(const days& _Days) noexcept; - _NODISCARD constexpr unsigned c_encoding() const noexcept { + _NODISCARD constexpr unsigned int c_encoding() const noexcept { return _Weekday; } - _NODISCARD constexpr unsigned iso_encoding() const noexcept { + _NODISCARD constexpr unsigned int iso_encoding() const noexcept { return _Weekday == 0u ? 7u : _Weekday; } _NODISCARD constexpr bool ok() const noexcept { return _Weekday <= 6; } - _NODISCARD constexpr class weekday_indexed operator[](unsigned _Index) const noexcept; + _NODISCARD constexpr class weekday_indexed operator[](unsigned int _Index) const noexcept; _NODISCARD constexpr class weekday_last operator[](last_spec) const noexcept; private: @@ -945,27 +945,27 @@ namespace chrono { // courtesy of Howard Hinnant // https://howardhinnant.github.io/date_algorithms.html#weekday_from_days - _NODISCARD static constexpr unsigned _Weekday_from_days(int _Tp) noexcept { - return static_cast(_Tp >= -4 ? (_Tp + 4) % 7 : (_Tp + 5) % 7 + 6); + _NODISCARD static constexpr unsigned int _Weekday_from_days(int _Tp) noexcept { + return static_cast(_Tp >= -4 ? (_Tp + 4) % 7 : (_Tp + 5) % 7 + 6); } }; - constexpr bool operator==(const weekday& _Left, const weekday& _Right) noexcept { + _NODISCARD constexpr bool operator==(const weekday& _Left, const weekday& _Right) noexcept { return _Left.c_encoding() == _Right.c_encoding(); } - constexpr weekday operator+(const weekday& _Left, const days& _Right) noexcept { + _NODISCARD constexpr weekday operator+(const weekday& _Left, const days& _Right) noexcept { const auto _Wd = static_cast(_Left.c_encoding()) + _Right.count(); const auto _Div = (_Wd >= 0 ? _Wd : _Wd - 6) / 7; - return weekday{static_cast(_Wd - _Div * 7)}; + return weekday{static_cast(_Wd - _Div * 7)}; } - constexpr weekday operator+(const days& _Left, const weekday& _Right) noexcept { + _NODISCARD constexpr weekday operator+(const days& _Left, const weekday& _Right) noexcept { return _Right + _Left; } - constexpr weekday operator-(const weekday& _Left, const days& _Right) noexcept { + _NODISCARD constexpr weekday operator-(const weekday& _Left, const days& _Right) noexcept { return _Left + -_Right; } - constexpr days operator-(const weekday& _Left, const weekday& _Right) noexcept { + _NODISCARD constexpr days operator-(const weekday& _Left, const weekday& _Right) noexcept { const auto _Wd = _Left.c_encoding() - _Right.c_encoding(); const auto _Wk = _Wd <= 6 ? _Wd : _Wd + 7; return days{_Wk}; @@ -983,13 +983,13 @@ namespace chrono { class weekday_indexed { public: weekday_indexed() = default; - constexpr weekday_indexed(const weekday& _Wd, unsigned _Idx) noexcept + constexpr weekday_indexed(const weekday& _Wd, unsigned int _Idx) noexcept : _Weekday{_Wd}, _Index{static_cast(_Idx)} {} _NODISCARD constexpr weekday weekday() const noexcept { return _Weekday; } - _NODISCARD constexpr unsigned index() const noexcept { + _NODISCARD constexpr unsigned int index() const noexcept { return _Index; } _NODISCARD constexpr bool ok() const noexcept { @@ -1001,7 +1001,7 @@ namespace chrono { unsigned char _Index; }; - constexpr bool operator==(const weekday_indexed& _Left, const weekday_indexed& _Right) noexcept { + _NODISCARD constexpr bool operator==(const weekday_indexed& _Left, const weekday_indexed& _Right) noexcept { return _Left.weekday() == _Right.weekday() && _Left.index() == _Right.index(); } @@ -1020,15 +1020,15 @@ namespace chrono { _CHRONO weekday _Weekday; }; - constexpr bool operator==(const weekday_last& _Left, const weekday_last& _Right) noexcept { + _NODISCARD constexpr bool operator==(const weekday_last& _Left, const weekday_last& _Right) noexcept { return _Left.weekday() == _Right.weekday(); } // weekday - constexpr weekday_indexed weekday::operator[](unsigned _Index) const noexcept { + _NODISCARD constexpr weekday_indexed weekday::operator[](unsigned int _Index) const noexcept { return {*this, _Index}; } - constexpr weekday_last weekday::operator[](last_spec) const noexcept { + _NODISCARD constexpr weekday_last weekday::operator[](last_spec) const noexcept { return weekday_last{*this}; } @@ -1048,8 +1048,8 @@ namespace chrono { return false; } - const auto _Da = static_cast(_Day); - const auto _Mo = static_cast(_Month); + const auto _Da = static_cast(_Day); + const auto _Mo = static_cast(_Month); if (_Mo == 2 && _Da > 29) { return false; } @@ -1065,10 +1065,10 @@ namespace chrono { _CHRONO day _Day; }; - constexpr bool operator==(const month_day& _Left, const month_day& _Right) noexcept { + _NODISCARD constexpr bool operator==(const month_day& _Left, const month_day& _Right) noexcept { return _Left.month() == _Right.month() && _Left.day() == _Right.day(); } - constexpr strong_ordering operator<=>(const month_day& _Left, const month_day& _Right) noexcept { + _NODISCARD constexpr strong_ordering operator<=>(const month_day& _Left, const month_day& _Right) noexcept { const auto _Comp = _Left.month() <=> _Right.month(); if (_Comp != 0) { return _Comp; @@ -1092,10 +1092,11 @@ namespace chrono { _CHRONO month _Month; }; - constexpr bool operator==(const month_day_last& _Left, const month_day_last& _Right) noexcept { + _NODISCARD constexpr bool operator==(const month_day_last& _Left, const month_day_last& _Right) noexcept { return _Left.month() == _Right.month(); } - constexpr strong_ordering operator<=>(const month_day_last& _Left, const month_day_last& _Right) noexcept { + _NODISCARD constexpr strong_ordering operator<=>( + const month_day_last& _Left, const month_day_last& _Right) noexcept { return _Left.month() <=> _Right.month(); } @@ -1120,7 +1121,7 @@ namespace chrono { _CHRONO weekday_indexed _Weekday_index; }; - constexpr bool operator==(const month_weekday& _Left, const month_weekday& _Right) noexcept { + _NODISCARD constexpr bool operator==(const month_weekday& _Left, const month_weekday& _Right) noexcept { return _Left.month() == _Right.month() && _Left.weekday_indexed() == _Right.weekday_indexed(); } @@ -1144,7 +1145,7 @@ namespace chrono { _CHRONO weekday_last _Weekday_last; }; - constexpr bool operator==(const month_weekday_last& _Left, const month_weekday_last& _Right) noexcept { + _NODISCARD constexpr bool operator==(const month_weekday_last& _Left, const month_weekday_last& _Right) noexcept { return _Left.month() == _Right.month() && _Left.weekday_last() == _Right.weekday_last(); } @@ -1174,10 +1175,10 @@ namespace chrono { _CHRONO month _Month; }; - constexpr bool operator==(const year_month& _Left, const year_month& _Right) noexcept { + _NODISCARD constexpr bool operator==(const year_month& _Left, const year_month& _Right) noexcept { return _Left.year() == _Right.year() && _Left.month() == _Right.month(); } - constexpr strong_ordering operator<=>(const year_month& _Left, const year_month& _Right) noexcept { + _NODISCARD constexpr strong_ordering operator<=>(const year_month& _Left, const year_month& _Right) noexcept { const auto _Comp = _Left.year() <=> _Right.year(); if (_Comp != 0) { return _Comp; @@ -1186,34 +1187,34 @@ namespace chrono { return _Left.month() <=> _Right.month(); } - constexpr year_month operator+(const year_month& _Left, const months& _Right) noexcept { - const auto _Mo = static_cast(static_cast(_Left.month())) + (_Right.count() - 1); + _NODISCARD constexpr year_month operator+(const year_month& _Left, const months& _Right) noexcept { + const auto _Mo = static_cast(static_cast(_Left.month())) + (_Right.count() - 1); const auto _Div = (_Mo >= 0 ? _Mo : _Mo - 11) / 12; - return year_month{_Left.year() + years{_Div}, month{static_cast(_Mo - _Div * 12 + 1)}}; + return year_month{_Left.year() + years{_Div}, month{static_cast(_Mo - _Div * 12 + 1)}}; } - constexpr year_month operator+(const months& _Left, const year_month& _Right) noexcept { + _NODISCARD constexpr year_month operator+(const months& _Left, const year_month& _Right) noexcept { return _Right + _Left; } - constexpr year_month operator-(const year_month& _Left, const months& _Right) noexcept { + _NODISCARD constexpr year_month operator-(const year_month& _Left, const months& _Right) noexcept { return _Left + -_Right; } - constexpr months operator-(const year_month& _Left, const year_month& _Right) noexcept { + _NODISCARD constexpr months operator-(const year_month& _Left, const year_month& _Right) noexcept { return _Left.year() - _Right.year() - + months{static_cast(static_cast(_Left.month())) - - static_cast(static_cast(_Right.month()))}; + + months{static_cast(static_cast(_Left.month())) + - static_cast(static_cast(_Right.month()))}; } - constexpr year_month operator+(const year_month& _Left, const years& _Right) noexcept { + _NODISCARD constexpr year_month operator+(const year_month& _Left, const years& _Right) noexcept { return {year{_Left.year() + _Right}, _Left.month()}; } - constexpr year_month operator+(const years& _Left, const year_month& _Right) noexcept { + _NODISCARD constexpr year_month operator+(const years& _Left, const year_month& _Right) noexcept { return _Right + _Left; } - constexpr year_month operator-(const year_month& _Left, const years& _Right) noexcept { + _NODISCARD constexpr year_month operator-(const year_month& _Left, const years& _Right) noexcept { return _Left + -_Right; } @@ -1234,11 +1235,11 @@ namespace chrono { return *this; } - constexpr inline day _Last_day(const year& _Year, const month& _Month) { + _NODISCARD constexpr inline day _Last_day(const year& _Year, const month& _Month) { constexpr day _Days[] = { day{31}, day{28}, day{31}, day{30}, day{31}, day{30}, day{31}, day{31}, day{30}, day{31}, day{30}, day{31}}; - return _Month == month{2} && _Year.is_leap() ? _Days[static_cast(_Month) - 1] + days{1} - : _Days[static_cast(_Month) - 1]; + return _Month == month{2} && _Year.is_leap() ? _Days[static_cast(_Month) - 1] + days{1} + : _Days[static_cast(_Month) - 1]; } class year_month_day { @@ -1289,42 +1290,43 @@ namespace chrono { // courtesy of Howard Hinnant // https://howardhinnant.github.io/date_algorithms.html#civil_from_days _NODISCARD static constexpr year_month_day _Civil_from_days(int _Tp) noexcept { - static_assert(numeric_limits::digits >= 18); + static_assert(numeric_limits::digits >= 18); static_assert(numeric_limits::digits >= 20); - const int _Zx = _Tp + 719468; // Shift epoch to 0000-03-01 - const int _Era = (_Zx >= 0 ? _Zx : _Zx - 146096) / 146097; - const unsigned _Day_of_era = static_cast(_Zx - _Era * 146097); // [0, 146096] - const unsigned _Year_of_era = + const int _Zx = _Tp + 719468; // Shift epoch to 0000-03-01 + const int _Era = (_Zx >= 0 ? _Zx : _Zx - 146096) / 146097; + const unsigned int _Day_of_era = static_cast(_Zx - _Era * 146097); // [0, 146096] + const unsigned int _Year_of_era = (_Day_of_era - _Day_of_era / 1460 + _Day_of_era / 36524 - _Day_of_era / 146096) / 365; // [0, 399] const int _Year = static_cast(_Year_of_era) + _Era * 400; // Where March is the first month - const unsigned _Day_of_year = + const unsigned int _Day_of_year = _Day_of_era - (365 * _Year_of_era + _Year_of_era / 4 - _Year_of_era / 100); // [0, 365] - const unsigned _Mp = (5 * _Day_of_year + 2) / 153; // [0, 11] - const unsigned _Day = _Day_of_year - (153 * _Mp + 2) / 5 + 1; // [1, 31] - const unsigned _Month = _Mp + (_Mp < 10 ? 3 : static_cast(-9)); // [1, 12] + const unsigned int _Mp = (5 * _Day_of_year + 2) / 153; // [0, 11] + const unsigned int _Day = _Day_of_year - (153 * _Mp + 2) / 5 + 1; // [1, 31] + const unsigned int _Month = _Mp + (_Mp < 10 ? 3 : static_cast(-9)); // [1, 12] return year_month_day(_CHRONO year{_Year + (_Month <= 2)}, _CHRONO month{_Month}, _CHRONO day{_Day}); } // courtesy of Howard Hinnant // https://howardhinnant.github.io/date_algorithms.html#days_from_civil _NODISCARD constexpr days _Days_from_civil() const noexcept { - static_assert(numeric_limits::digits >= 18); + static_assert(numeric_limits::digits >= 18); static_assert(numeric_limits::digits >= 20); - const int _Ye = static_cast(_Year) - (_Month <= _CHRONO month{2}); - const unsigned _Mo = static_cast(_Month); - const int _Era = (_Ye >= 0 ? _Ye : _Ye - 399) / 400; - const unsigned _Year_of_era = static_cast(_Ye - _Era * 400); // [0, 399] - const unsigned _Day_of_year = (153 * (_Mo + (_Mo > 2 ? static_cast(-3) : 9)) + 2) / 5 - + static_cast(_Day) - 1; // [0, 365] - const unsigned _Day_of_era = + const int _Ye = static_cast(_Year) - (_Month <= _CHRONO month{2}); + const unsigned int _Mo = static_cast(_Month); + const int _Era = (_Ye >= 0 ? _Ye : _Ye - 399) / 400; + const unsigned int _Year_of_era = static_cast(_Ye - _Era * 400); // [0, 399] + const unsigned int _Day_of_year = (153 * (_Mo + (_Mo > 2 ? static_cast(-3) : 9)) + 2) / 5 + + static_cast(_Day) - 1; // [0, 365] + const unsigned int _Day_of_era = _Year_of_era * 365 + _Year_of_era / 4 - _Year_of_era / 100 + _Day_of_year; // [0, 146096] return days{_Era * 146097 + static_cast(_Day_of_era) - 719468}; } }; - constexpr bool operator==(const year_month_day& _Left, const year_month_day& _Right) noexcept { + _NODISCARD constexpr bool operator==(const year_month_day& _Left, const year_month_day& _Right) noexcept { return _Left.year() == _Right.year() && _Left.month() == _Right.month() && _Left.day() == _Right.day(); } - constexpr strong_ordering operator<=>(const year_month_day& _Left, const year_month_day& _Right) noexcept { + _NODISCARD constexpr strong_ordering operator<=>( + const year_month_day& _Left, const year_month_day& _Right) noexcept { auto _Comp = _Left.year() <=> _Right.year(); if (_Comp != 0) { return _Comp; @@ -1338,28 +1340,28 @@ namespace chrono { return _Left.day() <=> _Right.day(); } - constexpr year_month_day operator+(const year_month_day& _Left, const months& _Right) noexcept { + _NODISCARD constexpr year_month_day operator+(const year_month_day& _Left, const months& _Right) noexcept { const auto _Ym = year_month{_Left.year(), _Left.month()} + _Right; return {_Ym.year(), _Ym.month(), _Left.day()}; } - constexpr year_month_day operator+(const months& _Left, const year_month_day& _Right) noexcept { + _NODISCARD constexpr year_month_day operator+(const months& _Left, const year_month_day& _Right) noexcept { return _Right + _Left; } - constexpr year_month_day operator-(const year_month_day& _Left, const months& _Right) noexcept { + _NODISCARD constexpr year_month_day operator-(const year_month_day& _Left, const months& _Right) noexcept { return _Left + (-_Right); } - constexpr year_month_day operator+(const year_month_day& _Left, const years& _Right) noexcept { + _NODISCARD constexpr year_month_day operator+(const year_month_day& _Left, const years& _Right) noexcept { return {_Left.year() + _Right, _Left.month(), _Left.day()}; } - constexpr year_month_day operator+(const years& _Left, const year_month_day& _Right) noexcept { + _NODISCARD constexpr year_month_day operator+(const years& _Left, const year_month_day& _Right) noexcept { return _Right + _Left; } - constexpr year_month_day operator-(const year_month_day& _Left, const years& _Right) noexcept { + _NODISCARD constexpr year_month_day operator-(const year_month_day& _Left, const years& _Right) noexcept { return _Left + (-_Right); } @@ -1418,10 +1420,10 @@ namespace chrono { _CHRONO month_day_last _Month_day_last; }; - constexpr bool operator==(const year_month_day_last& _Left, const year_month_day_last& _Right) noexcept { + _NODISCARD constexpr bool operator==(const year_month_day_last& _Left, const year_month_day_last& _Right) noexcept { return _Left.year() == _Right.year() && _Left.month_day_last() == _Right.month_day_last(); } - constexpr strong_ordering operator<=>( + _NODISCARD constexpr strong_ordering operator<=>( const year_month_day_last& _Left, const year_month_day_last& _Right) noexcept { const auto _Comp = _Left.year() <=> _Right.year(); if (_Comp != 0) { @@ -1431,25 +1433,28 @@ namespace chrono { return _Left.month_day_last() <=> _Right.month_day_last(); } - constexpr year_month_day_last operator+(const year_month_day_last& _Left, const months& _Right) noexcept { + _NODISCARD constexpr year_month_day_last operator+( + const year_month_day_last& _Left, const months& _Right) noexcept { const auto _Ym = year_month{_Left.year(), _Left.month()} + _Right; return {_Ym.year(), month_day_last{_Ym.month()}}; } - constexpr year_month_day_last operator+(const months& _Left, const year_month_day_last& _Right) noexcept { + _NODISCARD constexpr year_month_day_last operator+( + const months& _Left, const year_month_day_last& _Right) noexcept { return _Right + _Left; } - constexpr year_month_day_last operator-(const year_month_day_last& _Left, const months& _Right) noexcept { + _NODISCARD constexpr year_month_day_last operator-( + const year_month_day_last& _Left, const months& _Right) noexcept { return _Left + (-_Right); } - constexpr year_month_day_last operator+(const year_month_day_last& _Left, const years& _Right) noexcept { + _NODISCARD constexpr year_month_day_last operator+(const year_month_day_last& _Left, const years& _Right) noexcept { return {_Left.year() + _Right, _Left.month_day_last()}; } - constexpr year_month_day_last operator+(const years& _Left, const year_month_day_last& _Right) noexcept { + _NODISCARD constexpr year_month_day_last operator+(const years& _Left, const year_month_day_last& _Right) noexcept { return _Right + _Left; } - constexpr year_month_day_last operator-(const year_month_day_last& _Left, const years& _Right) noexcept { + _NODISCARD constexpr year_month_day_last operator-(const year_month_day_last& _Left, const years& _Right) noexcept { return _Left + (-_Right); } @@ -1498,7 +1503,7 @@ namespace chrono { _NODISCARD constexpr weekday weekday() const noexcept { return _Weekday_index.weekday(); } - _NODISCARD constexpr unsigned index() const noexcept { + _NODISCARD constexpr unsigned int index() const noexcept { return _Weekday_index.index(); } _NODISCARD constexpr weekday_indexed weekday_indexed() const noexcept { @@ -1528,7 +1533,7 @@ namespace chrono { const sys_days _First_of_month = year_month_day{_Year, _Month, day{1}}; const days _First_weekday = weekday() - _CHRONO weekday{_First_of_month} + days{1}; const days _Last = _First_weekday + days{28}; - return static_cast(_Last.count()) <= static_cast(_Last_day(_Year, _Month)); + return static_cast(_Last.count()) <= static_cast(_Last_day(_Year, _Month)); } private: @@ -1539,36 +1544,36 @@ namespace chrono { _NODISCARD static constexpr year_month_weekday _Ymwd_from_days(days _Dp) noexcept { const _CHRONO year_month_day _Ymd = sys_days{_Dp}; const _CHRONO weekday _Wd = sys_days{_Dp}; - const auto _Idx = ((static_cast(_Ymd.day()) - 1) / 7) + 1; + const auto _Idx = ((static_cast(_Ymd.day()) - 1) / 7) + 1; return {_Ymd.year(), _Ymd.month(), _Wd[_Idx]}; } }; - constexpr bool operator==(const year_month_weekday& _Left, const year_month_weekday& _Right) noexcept { + _NODISCARD constexpr bool operator==(const year_month_weekday& _Left, const year_month_weekday& _Right) noexcept { return _Left.year() == _Right.year() && _Left.month() == _Right.month() && _Left.weekday_indexed() == _Right.weekday_indexed(); } - constexpr year_month_weekday operator+(const year_month_weekday& _Left, const months& _Right) noexcept { + _NODISCARD constexpr year_month_weekday operator+(const year_month_weekday& _Left, const months& _Right) noexcept { const auto _Ym = year_month{_Left.year(), _Left.month()} + _Right; return {_Ym.year(), _Ym.month(), _Left.weekday_indexed()}; } - constexpr year_month_weekday operator+(const months& _Left, const year_month_weekday& _Right) noexcept { + _NODISCARD constexpr year_month_weekday operator+(const months& _Left, const year_month_weekday& _Right) noexcept { return _Right + _Left; } - constexpr year_month_weekday operator-(const year_month_weekday& _Left, const months& _Right) noexcept { + _NODISCARD constexpr year_month_weekday operator-(const year_month_weekday& _Left, const months& _Right) noexcept { return _Left + (-_Right); } - constexpr year_month_weekday operator+(const year_month_weekday& _Left, const years& _Right) noexcept { + _NODISCARD constexpr year_month_weekday operator+(const year_month_weekday& _Left, const years& _Right) noexcept { return year_month_weekday{_Left.year() + _Right, _Left.month(), _Left.weekday_indexed()}; } - constexpr year_month_weekday operator+(const years& _Left, const year_month_weekday& _Right) noexcept { + _NODISCARD constexpr year_month_weekday operator+(const years& _Left, const year_month_weekday& _Right) noexcept { return _Right + _Left; } - constexpr year_month_weekday operator-(const year_month_weekday& _Left, const years& _Right) noexcept { + _NODISCARD constexpr year_month_weekday operator-(const year_month_weekday& _Left, const years& _Right) noexcept { return _Left + (-_Right); } @@ -1631,31 +1636,38 @@ namespace chrono { _CHRONO weekday_last _Weekday_last; }; - constexpr bool operator==(const year_month_weekday_last& _Left, const year_month_weekday_last& _Right) noexcept { + _NODISCARD constexpr bool operator==( + const year_month_weekday_last& _Left, const year_month_weekday_last& _Right) noexcept { return _Left.year() == _Right.year() && _Left.month() == _Right.month() && _Left.weekday_last() == _Right.weekday_last(); } - constexpr year_month_weekday_last operator+(const year_month_weekday_last& _Left, const months& _Right) noexcept { + _NODISCARD constexpr year_month_weekday_last operator+( + const year_month_weekday_last& _Left, const months& _Right) noexcept { const auto _Ym = year_month{_Left.year(), _Left.month()} + _Right; return {_Ym.year(), _Ym.month(), _Left.weekday_last()}; } - constexpr year_month_weekday_last operator+(const months& _Left, const year_month_weekday_last& _Right) noexcept { + _NODISCARD constexpr year_month_weekday_last operator+( + const months& _Left, const year_month_weekday_last& _Right) noexcept { return _Right + _Left; } - constexpr year_month_weekday_last operator-(const year_month_weekday_last& _Left, const months& _Right) noexcept { + _NODISCARD constexpr year_month_weekday_last operator-( + const year_month_weekday_last& _Left, const months& _Right) noexcept { return _Left + (-_Right); } - constexpr year_month_weekday_last operator+(const year_month_weekday_last& _Left, const years& _Right) noexcept { + _NODISCARD constexpr year_month_weekday_last operator+( + const year_month_weekday_last& _Left, const years& _Right) noexcept { return {_Left.year() + _Right, _Left.month(), _Left.weekday_last()}; } - constexpr year_month_weekday_last operator+(const years& _Left, const year_month_weekday_last& _Right) noexcept { + _NODISCARD constexpr year_month_weekday_last operator+( + const years& _Left, const year_month_weekday_last& _Right) noexcept { return _Right + _Left; } - constexpr year_month_weekday_last operator-(const year_month_weekday_last& _Left, const years& _Right) noexcept { + _NODISCARD constexpr year_month_weekday_last operator-( + const year_month_weekday_last& _Left, const years& _Right) noexcept { return _Left + (-_Right); } @@ -1681,64 +1693,64 @@ namespace chrono { return {_Year, _Month}; } _NODISCARD constexpr year_month operator/(const year& _Year, int _Month) noexcept { - return _Year / month{static_cast(_Month)}; + return _Year / month{static_cast(_Month)}; } _NODISCARD constexpr month_day operator/(const month& _Month, const day& _Day) noexcept { return {_Month, _Day}; } _NODISCARD constexpr month_day operator/(const month& _Month, int _Day) noexcept { - return _Month / day{static_cast(_Day)}; + return _Month / day{static_cast(_Day)}; } _NODISCARD constexpr month_day operator/(int _Month, const day& _Day) noexcept { - return month{static_cast(_Month)} / _Day; + return month{static_cast(_Month)} / _Day; } _NODISCARD constexpr month_day operator/(const day& _Day, const month& _Month) noexcept { return _Month / _Day; } _NODISCARD constexpr month_day operator/(const day& _Day, int _Month) noexcept { - return month{static_cast(_Month)} / _Day; + return month{static_cast(_Month)} / _Day; } _NODISCARD constexpr month_day_last operator/(const month& _Month, last_spec) noexcept { return month_day_last{_Month}; } _NODISCARD constexpr month_day_last operator/(int _Month, last_spec) noexcept { - return month{static_cast(_Month)} / last; + return month{static_cast(_Month)} / last; } _NODISCARD constexpr month_day_last operator/(last_spec, const month& _Month) noexcept { return _Month / last; } _NODISCARD constexpr month_day_last operator/(last_spec, int _Month) noexcept { - return month{static_cast(_Month)} / last; + return month{static_cast(_Month)} / last; } _NODISCARD constexpr month_weekday operator/(const month& _Month, const weekday_indexed& _Wdi) noexcept { return {_Month, _Wdi}; } _NODISCARD constexpr month_weekday operator/(int _Month, const weekday_indexed& _Wdi) noexcept { - return month{static_cast(_Month)} / _Wdi; + return month{static_cast(_Month)} / _Wdi; } _NODISCARD constexpr month_weekday operator/(const weekday_indexed& _Wdi, const month& _Month) noexcept { return _Month / _Wdi; } _NODISCARD constexpr month_weekday operator/(const weekday_indexed& _Wdi, int _Month) noexcept { - return month{static_cast(_Month)} / _Wdi; + return month{static_cast(_Month)} / _Wdi; } _NODISCARD constexpr month_weekday_last operator/(const month& _Month, const weekday_last& _Wdl) noexcept { return {_Month, _Wdl}; } _NODISCARD constexpr month_weekday_last operator/(int _Month, const weekday_last& _Wdl) noexcept { - return month{static_cast(_Month)} / _Wdl; + return month{static_cast(_Month)} / _Wdl; } _NODISCARD constexpr month_weekday_last operator/(const weekday_last& _Wdl, const month& _Month) noexcept { return _Month / _Wdl; } _NODISCARD constexpr month_weekday_last operator/(const weekday_last& _Wdl, int _Month) noexcept { - return month{static_cast(_Month)} / _Wdl; + return month{static_cast(_Month)} / _Wdl; } _NODISCARD constexpr year_month_day operator/(const year_month& _Ym, const day& _Day) noexcept { return {_Ym.year(), _Ym.month(), _Day}; } _NODISCARD constexpr year_month_day operator/(const year_month& _Ym, int _Day) noexcept { - return _Ym / day{static_cast(_Day)}; + return _Ym / day{static_cast(_Day)}; } _NODISCARD constexpr year_month_day operator/(const year& _Year, const month_day& _Md) noexcept { return _Year / _Md.month() / _Md.day(); @@ -1822,18 +1834,6 @@ namespace chrono { inline constexpr month November{11}; inline constexpr month December{12}; - // Returns the number of fractional digits of _Num / _Den in the range [0, 18]. - // If it can't be represented, 6 is returned. - // Example: _Fractional_width(1, 8) would return 3 for 0.125. - constexpr unsigned _Fractional_width(intmax_t _Num, const intmax_t _Den) { - _STL_ASSERT(_Den > 0, "Denominator can't be less than 1."); - unsigned _Result = 0; - // doing everything in for > using a while loop - for (; _Num % _Den != 0 && _Result < 19; _Num = _Num % _Den * 10, ++_Result) { - } - return _Result == 19 ? 6 : _Result; - } - constexpr intmax_t _Pow10(const int _Exp) { intmax_t _Result = 1; for (int _Ix = 0; _Ix < _Exp; ++_Ix) { @@ -1845,7 +1845,8 @@ namespace chrono { template requires _Is_duration_v<_Duration> class hh_mm_ss { public: - static constexpr unsigned fractional_width = _Fractional_width(_Duration::period::num, _Duration::period::den); + static constexpr unsigned int fractional_width = + _Fractional_width(_Duration::period::num, _Duration::period::den); using precision = duration, ratio<1, _Pow10(fractional_width)>>; @@ -1889,6 +1890,17 @@ namespace chrono { } private: + // Returns the number of fractional digits of _Num / _Den in the range [0, 18]. + // If it can't be represented, 6 is returned. + // Example: _Fractional_width(1, 8) would return 3 for 0.125. + static constexpr unsigned int _Fractional_width(intmax_t _Num, const intmax_t _Den) { + _STL_ASSERT(_Num > 0 && _Den > 0, "Numerator and denominator can't be less than 1."); + unsigned int _Result = 0; + for (; _Num % _Den != 0 && _Result < 19; _Num = _Num % _Den * 10, ++_Result) { + } + return _Result == 19 ? 6 : _Result; + } + bool _Is_neg; _CHRONO hours _Hours; _CHRONO minutes _Mins; @@ -1909,6 +1921,7 @@ namespace chrono { if (_Ret > 12) { _Ret -= 12; } + return hours{_Ret}; } _NODISCARD constexpr hours make24(const hours& _Hours, bool _Is_pm) noexcept { @@ -1917,6 +1930,7 @@ namespace chrono { if (_Is_pm) { _Ret += 12; } + return hours{_Ret}; } #endif // _HAS_CXX20 @@ -2004,7 +2018,7 @@ inline namespace literals { } #if _HAS_CXX20 _NODISCARD constexpr _CHRONO day operator"" d(unsigned long long _Day) noexcept { - return _CHRONO day{static_cast(_Day)}; + return _CHRONO day{static_cast(_Day)}; } _NODISCARD constexpr _CHRONO year operator"" y(unsigned long long _Year) noexcept { return _CHRONO year{static_cast(_Year)}; diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 5d40dabc40e..8aa1865e569 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -13,7 +13,7 @@ constexpr int y_max = 32767; constexpr void day_test() { day d{0u}; - assert(static_cast(d) == 0u); + assert(static_cast(d) == 0u); assert(d == 0d); assert(++d == 1d); assert(d++ == 1d); @@ -44,7 +44,7 @@ constexpr void day_test() { constexpr void month_test() { month m{1u}; - assert(static_cast(m) == 1u); + assert(static_cast(m) == 1u); assert(m == January); assert(++m == February); assert(m++ == February); @@ -59,7 +59,7 @@ constexpr void month_test() { m -= months{2}; assert(m == January); - for (unsigned i = 0; i <= 255; ++i) { + for (unsigned int i = 0; i <= 255; ++i) { if (i >= 1 && i <= 12) { assert(month{i}.ok()); } else { @@ -143,7 +143,7 @@ constexpr void weekday_test() { assert(Sunday.c_encoding() == 0u); assert(Sunday.iso_encoding() == 7u); - for (unsigned i = 0; i <= 255; ++i) { + for (unsigned int i = 0; i <= 255; ++i) { if (i <= 7) { assert(weekday{i}.ok()); } else { @@ -166,7 +166,7 @@ constexpr void weekday_indexed_test() { assert(wdi1 == wdi2); assert(!weekday_indexed(Sunday, 0).ok()); - for (unsigned i = 1; i <= 5; i++) { + for (unsigned int i = 1; i <= 5; i++) { assert(weekday_indexed(Sunday, i).ok()); assert(weekday_indexed(Monday, i).ok()); assert(weekday_indexed(Tuesday, i).ok()); @@ -197,9 +197,9 @@ constexpr void month_day_test() { assert(month_day(December, 25d) > md); assert(md == month_day(January, 1d)); - for (unsigned i = 1; i <= 12; ++i) { + for (unsigned int i = 1; i <= 12; ++i) { month m{i}; - for (unsigned d = 0; d <= 32; ++d) { + for (unsigned int d = 0; d <= 32; ++d) { if (d == 0) { assert(!month_day(m, day{d}).ok()); } else if (d == 30 && m == February) { @@ -219,7 +219,7 @@ constexpr void month_day_test() { constexpr void month_day_last_test() { assert((February / last).month() == February); - unsigned i = 0; + unsigned int i = 0; assert(!(month{i++} / last).ok()); for (; i <= 12; ++i) { assert((month{i} / last).ok()); From 5104167b4f84c3b73d74ce2d00c116f56865eadd Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sat, 17 Oct 2020 20:06:15 +0100 Subject: [PATCH 096/143] Add noexcept tests --- .../test.cpp | 323 +++++++++++++++++- .../test.cpp | 41 +++ 2 files changed, 354 insertions(+), 10 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 8aa1865e569..c81469090f3 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -13,6 +13,31 @@ constexpr int y_max = 32767; constexpr void day_test() { day d{0u}; + + static_assert(noexcept(day{})); + static_assert(noexcept(day{0u})); + + static_assert(noexcept(++d)); + static_assert(noexcept(d++)); + static_assert(noexcept(--d)); + static_assert(noexcept(d--)); + static_assert(noexcept(d += days{})); + static_assert(noexcept(d -= days{})); + + static_assert(noexcept(static_cast(d))); + static_assert(noexcept(d.ok())); + + static_assert(noexcept(d == d)); + static_assert(noexcept(d <=> d)); + + static_assert(noexcept(d + days{})); + static_assert(noexcept(days{} + d)); + + static_assert(noexcept(d - days{})); + static_assert(noexcept(d - d)); + + static_assert(noexcept(0d)); + assert(static_cast(d) == 0u); assert(d == 0d); assert(++d == 1d); @@ -44,6 +69,29 @@ constexpr void day_test() { constexpr void month_test() { month m{1u}; + + static_assert(noexcept(month{})); + static_assert(noexcept(month{0u})); + + static_assert(noexcept(++m)); + static_assert(noexcept(m++)); + static_assert(noexcept(--m)); + static_assert(noexcept(m--)); + static_assert(noexcept(m += months{})); + static_assert(noexcept(m -= months{})); + + static_assert(noexcept(static_cast(m))); + static_assert(noexcept(m.ok())); + + static_assert(noexcept(m == m)); + static_assert(noexcept(m <=> m)); + + static_assert(noexcept(m + months{})); + static_assert(noexcept(months{0} + m)); + + static_assert(noexcept(m - months{})); + static_assert(noexcept(m - m)); + assert(static_cast(m) == 1u); assert(m == January); assert(++m == February); @@ -78,6 +126,36 @@ constexpr void month_test() { constexpr void year_test() { year y{1}; + + static_assert(noexcept(year{})); + static_assert(noexcept(year{0})); + + static_assert(noexcept(++y)); + static_assert(noexcept(y++)); + static_assert(noexcept(--y)); + static_assert(noexcept(y--)); + static_assert(noexcept(y += years{})); + static_assert(noexcept(y -= years{})); + static_assert(noexcept(+y)); + static_assert(noexcept(-y)); + + static_assert(noexcept(y.is_leap())); + static_assert(noexcept(static_cast(y))); + static_assert(noexcept(y.ok())); + static_assert(noexcept(y.min())); + static_assert(noexcept(y.max())); + + static_assert(noexcept(y == y)); + static_assert(noexcept(y <=> y)); + + static_assert(noexcept(y + years{})); + static_assert(noexcept(years{} + y)); + + static_assert(noexcept(y - years{})); + static_assert(noexcept(y - y)); + + static_assert(noexcept(0y)); + assert(static_cast(y) == 1); assert(y == 1y); assert(++y == 2y); @@ -121,11 +199,38 @@ constexpr void year_test() { } constexpr void weekday_test() { + weekday wd{0u}; + + static_assert(noexcept(weekday{})); + static_assert(noexcept(weekday{0u})); + static_assert(noexcept(weekday{sys_days{}})); + static_assert(noexcept(weekday{local_days{}})); + + static_assert(noexcept(++wd)); + static_assert(noexcept(wd++)); + static_assert(noexcept(--wd)); + static_assert(noexcept(wd--)); + static_assert(noexcept(wd += days{})); + static_assert(noexcept(wd -= days{})); + + static_assert(noexcept(wd.c_encoding())); + static_assert(noexcept(wd.iso_encoding())); + static_assert(noexcept(wd.ok())); + static_assert(noexcept(wd[0u])); + static_assert(noexcept(wd[last])); + + static_assert(noexcept(wd == wd)); + + static_assert(noexcept(wd + days{})); + static_assert(noexcept(days{} + wd)); + + static_assert(noexcept(wd - days{})); + static_assert(noexcept(wd - wd)); + assert(weekday{7} == Sunday); assert(weekday{sys_days{}} == Thursday); assert(weekday{local_days{}} == sys_days{local_days{}.time_since_epoch()}); - weekday wd{0u}; assert(wd == Sunday); assert(++wd == Monday); assert(wd++ == Monday); @@ -155,7 +260,17 @@ constexpr void weekday_test() { } constexpr void weekday_indexed_test() { - weekday_indexed wdi1{Monday, 2}; + const weekday_indexed wdi1{Monday, 2}; + + static_assert(noexcept(weekday_indexed{})); + static_assert(noexcept(weekday_indexed{weekday{}, 0u})); + + static_assert(noexcept(wdi1.weekday())); + static_assert(noexcept(wdi1.index())); + static_assert(noexcept(wdi1.ok())); + + static_assert(noexcept(wdi1 == wdi1)); + assert(wdi1.weekday() == Monday); assert(wdi1.index() == 2); @@ -179,15 +294,35 @@ constexpr void weekday_indexed_test() { } constexpr void weekday_last_test() { - assert(weekday_last{Monday}.ok()); + const weekday_last wdl{Monday}; + + static_assert(noexcept(weekday_last{weekday{}})); + + static_assert(noexcept(wdl.weekday())); + static_assert(noexcept(wdl.ok())); + + static_assert(noexcept(wdl == wdl)); + + assert(wdl.ok()); assert(Monday[last].ok()); assert(Monday[last].weekday() == Monday); - assert(weekday_last{Monday}.weekday() == Monday); - assert(weekday_last{Monday} == weekday_last{Monday}); + assert(wdl.weekday() == Monday); + assert(wdl == weekday_last{Monday}); } constexpr void month_day_test() { - month_day md{January, 1d}; + const month_day md{January, 1d}; + + static_assert(noexcept(month_day{})); + static_assert(noexcept(month_day{month{}, day{}})); + + static_assert(noexcept(md.month())); + static_assert(noexcept(md.day())); + static_assert(noexcept(md.ok())); + + static_assert(noexcept(md == md)); + static_assert(noexcept(md <=> md)); + assert(md.month() == January); assert(md.day() == 1d); @@ -217,14 +352,22 @@ constexpr void month_day_test() { } constexpr void month_day_last_test() { + const month_day_last mdl{January}; + + static_assert(noexcept(month_day_last{month{}})); + static_assert(noexcept(mdl.month())); + static_assert(noexcept(mdl.ok())); + + static_assert(noexcept(mdl == mdl)); + static_assert(noexcept(mdl <=> mdl)); + assert((February / last).month() == February); - unsigned int i = 0; - assert(!(month{i++} / last).ok()); - for (; i <= 12; ++i) { + assert(!(month{0} / last).ok()); + for (unsigned int i = 1; i <= 12; ++i) { assert((month{i} / last).ok()); } - assert(!(month{i} / last).ok()); + assert(!(month{13} / last).ok()); assert(January / last == January / last); assert(January / last < February / last); @@ -233,6 +376,15 @@ constexpr void month_day_last_test() { constexpr void month_weekday_test() { const auto mwd1 = January / Monday[2]; + + static_assert(noexcept(month_weekday{month{}, weekday_indexed{Sunday, 0u}})); + + static_assert(noexcept(mwd1.month())); + static_assert(noexcept(mwd1.weekday_indexed())); + static_assert(noexcept(mwd1.ok())); + + static_assert(noexcept(mwd1 == mwd1)); + assert(mwd1.month() == January); assert(mwd1.weekday_indexed().weekday() == Monday); assert(mwd1.weekday_indexed().index() == 2); @@ -263,6 +415,14 @@ constexpr void month_weekday_test() { constexpr void month_weekday_last_test() { const auto mwdl = January / Monday[last]; + + static_assert(noexcept(month_weekday_last{month{}, weekday_last{Sunday}})); + static_assert(noexcept(mwdl.month())); + static_assert(noexcept(mwdl.weekday_last())); + static_assert(noexcept(mwdl.ok())); + + static_assert(noexcept(mwdl == mwdl)); + assert(mwdl.month() == January); assert(mwdl.weekday_last().weekday() == Monday); assert(mwdl == January / Monday[last]); @@ -270,6 +430,32 @@ constexpr void month_weekday_last_test() { constexpr void year_month_test() { auto ym = 2020y / January; + + static_assert(noexcept(year_month{})); + static_assert(noexcept(year_month{year{}, month{}})); + + static_assert(noexcept(ym.year())); + static_assert(noexcept(ym.month())); + + static_assert(noexcept(ym += months{})); + static_assert(noexcept(ym -= months{})); + static_assert(noexcept(ym += years{})); + static_assert(noexcept(ym -= years{})); + + static_assert(noexcept(ym.ok())); + + static_assert(noexcept(ym == ym)); + static_assert(noexcept(ym <=> ym)); + + static_assert(noexcept(ym + months{})); + static_assert(noexcept(months{} + ym)); + static_assert(noexcept(ym - months{})); + + static_assert(noexcept(ym - ym)); + static_assert(noexcept(ym + years{})); + static_assert(noexcept(years{} + ym)); + static_assert(noexcept(ym - years{})); + assert(ym.year() == 2020y); assert(ym.month() == January); @@ -323,6 +509,37 @@ constexpr void year_month_test() { constexpr void year_month_day_test() { year_month_day ymd1{2020y / January / 1d}; + + static_assert(noexcept(year_month_day{})); + static_assert(noexcept(year_month_day{year{}, month{}, day{}})); + static_assert(noexcept(year_month_day{year_month_day_last{year{}, month_day_last{January}}})); + static_assert(noexcept(year_month_day{sys_days{}})); + static_assert(noexcept(year_month_day{local_days{}})); + + static_assert(noexcept(ymd1 += months{})); + static_assert(noexcept(ymd1 -= months{})); + static_assert(noexcept(ymd1 += years{})); + static_assert(noexcept(ymd1 -= years{})); + + static_assert(noexcept(ymd1.year())); + static_assert(noexcept(ymd1.month())); + static_assert(noexcept(ymd1.day())); + + static_assert(noexcept(static_cast(ymd1))); + static_assert(noexcept(static_cast(ymd1))); + static_assert(noexcept(ymd1.ok())); + + static_assert(noexcept(ymd1 == ymd1)); + static_assert(noexcept(ymd1 <=> ymd1)); + + static_assert(noexcept(ymd1 + months{})); + static_assert(noexcept(months{} + ymd1)); + static_assert(noexcept(ymd1 - months{})); + + static_assert(noexcept(ymd1 + years{})); + static_assert(noexcept(years{} + ymd1)); + static_assert(noexcept(ymd1 - years{})); + assert(ymd1.year() == 2020y); assert(ymd1.month() == January); assert(ymd1.day() == 1d); @@ -425,6 +642,34 @@ constexpr void year_month_day_test() { constexpr void year_month_day_last_test() { auto ymdl = 2020y / February / last; + + static_assert(noexcept(year_month_day_last{year{}, month_day_last{January}})); + + static_assert(noexcept(ymdl += months{})); + static_assert(noexcept(ymdl -= months{})); + static_assert(noexcept(ymdl += years{})); + static_assert(noexcept(ymdl -= years{})); + + static_assert(noexcept(ymdl.year())); + static_assert(noexcept(ymdl.month())); + static_assert(noexcept(ymdl.month_day_last())); + static_assert(noexcept(ymdl.day())); + + static_assert(noexcept(static_cast(ymdl))); + static_assert(noexcept(static_cast(ymdl))); + static_assert(noexcept(ymdl.ok())); + + static_assert(noexcept(ymdl == ymdl)); + static_assert(noexcept(ymdl <=> ymdl)); + + static_assert(noexcept(ymdl + months{})); + static_assert(noexcept(months{} + ymdl)); + static_assert(noexcept(ymdl - months{})); + + static_assert(noexcept(ymdl + years{})); + static_assert(noexcept(years{} + ymdl)); + static_assert(noexcept(ymdl - years{})); + assert(ymdl == 2020y / February / last); assert(ymdl == 2020y / February / 29d); assert(ymdl.year() == 2020y); @@ -482,6 +727,37 @@ constexpr void year_month_day_last_test() { constexpr void year_month_weekday_test() { auto ymwd = 2020y / April / Tuesday[2]; + + static_assert(noexcept(year_month_weekday{})); + static_assert(noexcept(year_month_weekday{year{}, month{}, weekday_indexed{}})); + static_assert(noexcept(year_month_weekday{sys_days{}})); + static_assert(noexcept(year_month_weekday{local_days{}})); + + static_assert(noexcept(ymwd += months{})); + static_assert(noexcept(ymwd -= months{})); + static_assert(noexcept(ymwd += years{})); + static_assert(noexcept(ymwd -= years{})); + + static_assert(noexcept(ymwd.year())); + static_assert(noexcept(ymwd.month())); + static_assert(noexcept(ymwd.weekday())); + static_assert(noexcept(ymwd.index())); + static_assert(noexcept(ymwd.weekday_indexed())); + + static_assert(noexcept(static_cast(ymwd))); + static_assert(noexcept(static_cast(ymwd))); + static_assert(noexcept(ymwd.ok())); + + static_assert(noexcept(ymwd == ymwd)); + + static_assert(noexcept(ymwd + months{})); + static_assert(noexcept(months{} + ymwd)); + static_assert(noexcept(ymwd - months{})); + + static_assert(noexcept(ymwd + years{})); + static_assert(noexcept(years{} + ymwd)); + static_assert(noexcept(ymwd - years{})); + assert(ymwd == 2020y / April / Tuesday[2]); assert(ymwd.year() == 2020y); assert(ymwd.month() == April); @@ -531,6 +807,33 @@ constexpr void year_month_weekday_test() { constexpr void year_month_weekday_last_test() { auto ymwdl = 2020y / January / Monday[last]; + + static_assert(noexcept(year_month_weekday_last{year{}, month{}, weekday_last{Sunday}})); + + static_assert(noexcept(ymwdl += months{})); + static_assert(noexcept(ymwdl -= months{})); + static_assert(noexcept(ymwdl += years{})); + static_assert(noexcept(ymwdl -= years{})); + + static_assert(noexcept(ymwdl.year())); + static_assert(noexcept(ymwdl.month())); + static_assert(noexcept(ymwdl.weekday())); + static_assert(noexcept(ymwdl.weekday_last())); + + static_assert(noexcept(static_cast(ymwdl))); + static_assert(noexcept(static_cast(ymwdl))); + static_assert(noexcept(ymwdl.ok())); + + static_assert(noexcept(ymwdl == ymwdl)); + + static_assert(noexcept(ymwdl + months{})); + static_assert(noexcept(months{} + ymwdl)); + static_assert(noexcept(ymwdl - months{})); + + static_assert(noexcept(ymwdl + years{})); + static_assert(noexcept(years{} + ymwdl)); + static_assert(noexcept(ymwdl - years{})); + assert(ymwdl == 2020y / January / Monday[last]); assert(ymwdl.year() == 2020y); assert(ymwdl.month() == January); diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.cpp index b7dbae2d67f..b4e9b2e69bd 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.cpp @@ -9,6 +9,47 @@ using namespace std::chrono; int main() {} // COMPILE-ONLY +static_assert(noexcept(year{} / month{})); +static_assert(noexcept(year{} / 0)); +static_assert(noexcept(month{} / day{})); +static_assert(noexcept(month{} / 0)); +static_assert(noexcept(0 / day{})); +static_assert(noexcept(day{} / month{})); +static_assert(noexcept(day{} / 0)); +static_assert(noexcept(month{} / last)); +static_assert(noexcept(0 / last)); +static_assert(noexcept(last / month{})); +static_assert(noexcept(last / 0)); +static_assert(noexcept(month{} / Sunday[1])); +static_assert(noexcept(0 / Sunday[1])); +static_assert(noexcept(Sunday[1] / month{})); +static_assert(noexcept(Sunday[1] / 0)); +static_assert(noexcept(month{} / Sunday[last])); +static_assert(noexcept(0 / Sunday[last])); +static_assert(noexcept(Sunday[last] / month{})); +static_assert(noexcept(Sunday[last] / 0)); +static_assert(noexcept(year_month{} / day{})); +static_assert(noexcept(year_month{} / 0)); +static_assert(noexcept(year{} / month_day{})); +static_assert(noexcept(0 / month_day{})); +static_assert(noexcept(month_day{} / year{})); +static_assert(noexcept(month_day{} / 0)); +static_assert(noexcept(year_month{} / last)); +static_assert(noexcept(year{} / month_day_last{January})); +static_assert(noexcept(0 / month_day_last{January})); +static_assert(noexcept(month_day_last{January} / year{})); +static_assert(noexcept(month_day_last{January} / 0)); +static_assert(noexcept(year_month{} / Sunday[1])); +static_assert(noexcept(year{} / month_weekday{January, Sunday[1]})); +static_assert(noexcept(0 / month_weekday{January, Sunday[1]})); +static_assert(noexcept(month_weekday{January, Sunday[1]} / year{})); +static_assert(noexcept(month_weekday{January, Sunday[1]} / 0)); +static_assert(noexcept(year_month{} / Sunday[last])); +static_assert(noexcept(year{} / month_weekday_last{January, Sunday[last]})); +static_assert(noexcept(0 / month_weekday_last{January, Sunday[last]})); +static_assert(noexcept(month_weekday_last{January, Sunday[last]} / year{})); +static_assert(noexcept(month_weekday_last{January, Sunday[last]} / 0)); + #define TRIVIAL_COPY_STANDARD_LAYOUT(TYPE) \ static_assert(is_trivially_copyable_v, "chrono::" #TYPE " is not trivially copyable"); \ static_assert(is_standard_layout_v, "chrono::" #TYPE " is not standard layout"); From eab7728f27d718d2c661f4bcf3a86631ebb6d440 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sun, 18 Oct 2020 10:00:08 +0100 Subject: [PATCH 097/143] Un-private _Fractional_width --- stl/inc/chrono | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index b5d2d53d930..a2c7f5d1b14 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1832,6 +1832,17 @@ namespace chrono { inline constexpr month November{11}; inline constexpr month December{12}; + // Returns the number of fractional digits of _Num / _Den in the range [0, 18]. + // If it can't be represented, 6 is returned. + // Example: _Fractional_width(1, 8) would return 3 for 0.125. + constexpr unsigned int _Fractional_width(intmax_t _Num, const intmax_t _Den) { + _STL_ASSERT(_Num > 0 && _Den > 0, "Numerator and denominator can't be less than 1."); + unsigned int _Result = 0; + for (; _Num % _Den != 0 && _Result < 19; _Num = _Num % _Den * 10, ++_Result) { + } + return _Result == 19 ? 6 : _Result; + } + constexpr intmax_t _Pow10(const int _Exp) { intmax_t _Result = 1; for (int _Ix = 0; _Ix < _Exp; ++_Ix) { @@ -1888,17 +1899,6 @@ namespace chrono { } private: - // Returns the number of fractional digits of _Num / _Den in the range [0, 18]. - // If it can't be represented, 6 is returned. - // Example: _Fractional_width(1, 8) would return 3 for 0.125. - static constexpr unsigned int _Fractional_width(intmax_t _Num, const intmax_t _Den) { - _STL_ASSERT(_Num > 0 && _Den > 0, "Numerator and denominator can't be less than 1."); - unsigned int _Result = 0; - for (; _Num % _Den != 0 && _Result < 19; _Num = _Num % _Den * 10, ++_Result) { - } - return _Result == 19 ? 6 : _Result; - } - bool _Is_neg; _CHRONO hours _Hours; _CHRONO minutes _Mins; From 59a5c1e6f86640dad42698300ea2d832be0aadf8 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sun, 18 Oct 2020 14:40:24 +0100 Subject: [PATCH 098/143] noexcept Part 2 Featuring the Platinum Band --- .../test.cpp | 37 ++++++++++++++++++- 1 file changed, 35 insertions(+), 2 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp index 4ea1ec22609..61156b356cf 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp @@ -7,7 +7,12 @@ using namespace std; using namespace std::chrono; +using hms_hours = hh_mm_ss; + constexpr void am_pm() { + static_assert(noexcept(is_am(hours{}))); + static_assert(noexcept(is_pm(hours{}))); + for (hours i = 0h; i < 12h; ++i) { assert(is_am(i)); assert(!is_pm(i)); @@ -19,6 +24,9 @@ constexpr void am_pm() { } constexpr void make12_24() { + static_assert(noexcept(make12(hours{}))); + static_assert(noexcept(make24(hours{}, true))); + assert(make12(1h) == 1h); assert(make12(13h) == 1h); assert(make12(0h) == 12h); @@ -61,7 +69,18 @@ constexpr void fractional_width() { static_assert(width<3780, 625>() == 3); } +constexpr void constructor() { + static_assert(noexcept(hms_hours{})); + + assert(hms_hours{}.hours() == hms_hours{hours::zero()}.hours()); + assert(hms_hours{}.minutes() == hms_hours{hours::zero()}.minutes()); + assert(hms_hours{}.seconds() == hms_hours{hours::zero()}.seconds()); + assert(hms_hours{}.subseconds() == hms_hours{hours::zero()}.subseconds()); +} + constexpr void is_negative() { + static_assert(noexcept(hms_hours{}.is_negative())); + assert(hh_mm_ss(days{-1}).is_negative()); assert(!hh_mm_ss(days{1}).is_negative()); @@ -87,6 +106,8 @@ constexpr void is_negative() { constexpr auto ones = 1h + 1min + 1s + 1ms; constexpr void hour() { + static_assert(noexcept(hms_hours{}.hours())); + assert(hh_mm_ss(days{1}).hours() == 24h); assert(hh_mm_ss(ones).hours() == 1h); assert(hh_mm_ss(-ones).hours() == 1h); @@ -94,18 +115,24 @@ constexpr void hour() { } constexpr void mins() { + static_assert(noexcept(hms_hours{}.minutes())); + assert(hh_mm_ss(ones).minutes() == 1min); assert(hh_mm_ss(-ones).minutes() == 1min); assert(hh_mm_ss(59s).minutes() == 0min); } constexpr void secs() { + static_assert(noexcept(hms_hours{}.seconds())); + assert(hh_mm_ss(ones).seconds() == 1s); assert(hh_mm_ss(-ones).seconds() == 1s); assert(hh_mm_ss(999ms).seconds() == 0s); } constexpr void subsecs() { + static_assert(noexcept(hms_hours{}.subseconds())); + assert(hh_mm_ss(ones).subseconds() == 1ms); assert(hh_mm_ss(-ones).subseconds() == 1ms); assert(hh_mm_ss(999us).subseconds() == 999us); @@ -113,19 +140,25 @@ constexpr void subsecs() { } constexpr void to_duration() { + using precision = hms_hours::precision; + + static_assert(noexcept(hms_hours{}.to_duration())); + static_assert(noexcept(static_cast(hms_hours{}))); + assert(hh_mm_ss(ones).to_duration() == ones); assert(hh_mm_ss(-ones).to_duration() == -ones); hh_mm_ss hms(50ms); - milliseconds mili = static_cast(hms); + milliseconds milli = static_cast(hms); static_assert(is_same_v); - assert(hms.to_duration() == mili); + assert(hms.to_duration() == milli); } constexpr bool test() { am_pm(); make12_24(); fractional_width(); + constructor(); is_negative(); hour(); mins(); From aa7c2a316e54493858fc94cff3d5923e52eb3522 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Mon, 19 Oct 2020 18:31:49 +0100 Subject: [PATCH 099/143] And this time, we're gonna get funky * Add mores tests using the full range of valid values * Test `month + months` when `!month.ok()` * Test unrary `operator+/-` on a `year` that holds a negative value * Add missing tests for non-member +/- operations * Add a couple more tests for `weekday +/-` * Test `sys_days` constructors condition --- .../test.cpp | 67 +++++++++++++------ 1 file changed, 47 insertions(+), 20 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index c81469090f3..e64f31cecd1 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -56,14 +56,17 @@ constexpr void day_test() { assert(d < 2d); assert(2d > d); - day d2{0u}; - assert(!d2.ok()); - ++d2; - for (int i = 1; i <= 31; ++i, ++d2) { - assert(d2.ok()); + for (unsigned int i = 0; i <= 255; ++i) { + if (i > 0 && i <= 31) { + assert(day{i}.ok()); + } else { + assert(!day{i}.ok()); + } } - assert(!d2.ok()); + assert(5d + days{5} == 10d); + assert(days{5} + 5d == 10d); + assert(10d - days{5} == 5d); assert(10d - 2d == days{8}); } @@ -120,6 +123,9 @@ constexpr void month_test() { assert(February + months{11} == January); assert(months{11} + February == January); + assert(month{0} + months{1} == January); + assert(month{13} + months{1} == February); + assert(month{23} + months{1} == December); assert(February - months{2} == December); assert(January - February == months{11}); } @@ -173,6 +179,9 @@ constexpr void year_test() { assert(+y == 1y); assert(-y == -1y); + auto y2 = -y; + assert(-y2 == y); + assert(+y2 == -y); assert(year::min() == year{y_min}); assert(year::max() == year{y_max}); @@ -196,6 +205,8 @@ constexpr void year_test() { assert(years{4} + y == 5y); assert(y - years{4} == -3y); + assert(year{10} - year{5} == years{5}); + assert(year{-5} - year{-10} == years{5}); } constexpr void weekday_test() { @@ -256,7 +267,11 @@ constexpr void weekday_test() { } } assert(Monday + days{6} == Sunday); + assert(Monday + days{8} == Tuesday); + assert(Wednesday + days{14} == Wednesday); assert(Sunday - Monday == days{6}); + assert(Sunday - Tuesday == days{5}); + assert(Wednesday - Thursday == days{6}); } constexpr void weekday_indexed_test() { @@ -291,6 +306,7 @@ constexpr void weekday_indexed_test() { assert(weekday_indexed(Saturday, i).ok()); } assert(!weekday_indexed(Sunday, 6).ok()); + assert(!weekday_indexed(Sunday, 7).ok()); } constexpr void weekday_last_test() { @@ -332,20 +348,29 @@ constexpr void month_day_test() { assert(month_day(December, 25d) > md); assert(md == month_day(January, 1d)); - for (unsigned int i = 1; i <= 12; ++i) { - month m{i}; - for (unsigned int d = 0; d <= 32; ++d) { - if (d == 0) { - assert(!month_day(m, day{d}).ok()); - } else if (d == 30 && m == February) { - assert(!month_day(m, day{d}).ok()); - break; - } else if (d == 31 && (m == April || m == June || m == September || m == November)) { - assert(!month_day(m, day{d}).ok()); - } else if (d == 32) { - assert(!month_day(m, day{d}).ok()); - } else { - assert(month_day(m, day{d}).ok()); + if (is_constant_evaluated()) { + static_assert((January / 31).ok()); + static_assert((February / 29).ok()); + static_assert((April / 30).ok()); + static_assert(!(January / 32).ok()); + static_assert(!(February / 30).ok()); + static_assert(!(April / 31).ok()); + } else { + for (unsigned int i = 0; i <= 255; ++i) { + month m{i}; + for (unsigned int d = 0; d <= 255; ++d) { + if (d < 1 || d > 31 || i < 1 || i > 12) { + assert(!month_day(m, day{d}).ok()); + } else if (d == 30 && m == February) { + assert(!month_day(m, day{d}).ok()); + break; + } else if (d == 31 && (m == April || m == June || m == September || m == November)) { + assert(!month_day(m, day{d}).ok()); + } else if (d == 32) { + assert(!month_day(m, day{d}).ok()); + } else { + assert(month_day(m, day{d}).ok()); + } } } } @@ -550,6 +575,7 @@ constexpr void year_month_day_test() { assert(ymd2.day() == 31d); year_month_day epoch{sys_days{}}; + assert(epoch == year_month_day{sys_days{epoch}}); assert(epoch.year() == 1970y); assert(epoch.month() == January); assert(epoch.day() == 1d); @@ -766,6 +792,7 @@ constexpr void year_month_weekday_test() { assert(ymwd.weekday_indexed() == Tuesday[2]); const year_month_weekday epoch{sys_days{}}; + assert(epoch == year_month_weekday{sys_days{epoch}}); assert(epoch == 1970y / January / Thursday[1]); local_days ldp; From 8ab6173ff1a2eef5c1eeafb46294c902c2596bec Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sat, 24 Oct 2020 17:18:50 +0100 Subject: [PATCH 100/143] Changes * Turn _Fractional_width into an immediately invoked lambda. * Add _NODISCARD and use unsigned int for _Pow10 to match the expected argument type. * Consistently use pre-increment in loops. * Add more is_clock tests. * const the temp variable in weekday::operator--(int) * Test !ymd.ok() when !ymd.year.ok() * Pre-emptively address GH-1395 --- stl/inc/chrono | 30 +++---- .../test.compile.pass.cpp | 87 +++++++++++++++++++ .../test.cpp | 32 ------- .../test.cpp | 11 ++- .../{test.cpp => test.compile.pass.cpp} | 0 5 files changed, 108 insertions(+), 52 deletions(-) create mode 100644 tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.compile.pass.cpp delete mode 100644 tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.cpp rename tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/{test.cpp => test.compile.pass.cpp} (100%) diff --git a/stl/inc/chrono b/stl/inc/chrono index a2c7f5d1b14..46d91415ea6 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -917,7 +917,7 @@ namespace chrono { return *this -= days{1}; } constexpr weekday operator--(int) noexcept { - weekday _Temp{*this}; + const weekday _Temp{*this}; --(*this); return _Temp; } @@ -1832,20 +1832,9 @@ namespace chrono { inline constexpr month November{11}; inline constexpr month December{12}; - // Returns the number of fractional digits of _Num / _Den in the range [0, 18]. - // If it can't be represented, 6 is returned. - // Example: _Fractional_width(1, 8) would return 3 for 0.125. - constexpr unsigned int _Fractional_width(intmax_t _Num, const intmax_t _Den) { - _STL_ASSERT(_Num > 0 && _Den > 0, "Numerator and denominator can't be less than 1."); - unsigned int _Result = 0; - for (; _Num % _Den != 0 && _Result < 19; _Num = _Num % _Den * 10, ++_Result) { - } - return _Result == 19 ? 6 : _Result; - } - - constexpr intmax_t _Pow10(const int _Exp) { + _NODISCARD constexpr intmax_t _Pow10(const unsigned int _Exp) { intmax_t _Result = 1; - for (int _Ix = 0; _Ix < _Exp; ++_Ix) { + for (unsigned int _Ix = 0; _Ix < _Exp; ++_Ix) { _Result *= 10; } return _Result; @@ -1854,8 +1843,17 @@ namespace chrono { template requires _Is_duration_v<_Duration> class hh_mm_ss { public: - static constexpr unsigned int fractional_width = - _Fractional_width(_Duration::period::num, _Duration::period::den); + static constexpr unsigned int fractional_width = [_Num = _Duration::period::num, + &_Den = as_const(_Duration::period::den)]() mutable { + // Returns the number of fractional digits of _Num / _Den in the range [0, 18]. + // If it can't be represented, 6 is returned. + // Example: _Fractional_width(1, 8) would return 3 for 0.125. + _STL_ASSERT(_Num > 0 && _Den > 0, "Numerator and denominator can't be less than 1."); + unsigned int _Result = 0; + for (; _Num % _Den != 0 && _Result < 19; _Num = _Num % _Den * 10, ++_Result) { + } + return _Result == 19 ? 6 : _Result; + }(); using precision = duration, ratio<1, _Pow10(fractional_width)>>; diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.compile.pass.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.compile.pass.cpp new file mode 100644 index 00000000000..af4db9cba79 --- /dev/null +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.compile.pass.cpp @@ -0,0 +1,87 @@ +// Copyright (c) Microsoft Corporation. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +#include +#include + +using namespace std::chrono; + +struct not_a_clock { + bool rep(); + static char period; + int duration(); + static float time_point; + using is_steady = long; + static int now; +}; + +struct real_fake_clock { + using rep = bool; + using period = char; + using duration = float; + using time_point = int; + static long is_steady; + static short now(); +}; + +struct no_rep { + using period = char; + using duration = float; + using time_point = int; + static long is_steady; + static short now(); +}; + +struct no_period { + using period = char; + using duration = float; + using time_point = int; + static long is_steady; + static short now(); +}; + +struct no_duration { + using rep = bool; + using period = char; + using time_point = int; + static long is_steady; + static short now(); +}; + +struct no_time_point { + using rep = bool; + using period = char; + using duration = float; + static long is_steady; + static short now(); +}; + +struct no_steady { + using rep = bool; + using period = char; + using duration = float; + using time_point = int; + static short now(); +}; + +struct no_now { + using rep = bool; + using period = char; + using duration = float; + using time_point = int; + static long is_steady; +}; + +static_assert(is_clock::value, "steady_clock is not a clock"); +static_assert(is_clock_v, "steady_clock is not a clock"); +static_assert(is_clock_v, "real_fake_clock is not a clock"); +static_assert(!is_clock_v, "not_a_clock is a clock"); + +static_assert(!is_clock_v, "no_rep is a clock"); +static_assert(!is_clock_v, "no_period is a clock"); +static_assert(!is_clock_v, "no_duration is a clock"); +static_assert(!is_clock_v, "no_time_point is a clock"); +static_assert(!is_clock_v, "no_steady is a clock"); +static_assert(!is_clock_v, "no_now is a clock"); + +int main() {} // COMPILE-ONLY diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.cpp deleted file mode 100644 index fa1aeb03f56..00000000000 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.cpp +++ /dev/null @@ -1,32 +0,0 @@ -// Copyright (c) Microsoft Corporation. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception - -#include -#include - -using namespace std::chrono; - -struct not_a_clock { - bool rep(); - static char period; - int duration(); - static float time_point; - using is_steady = long; - static int now; -}; - -struct real_fake_clock { - using rep = bool; - using period = char; - using duration = float; - using time_point = int; - static long is_steady; - static short now(); -}; - -static_assert(is_clock::value, "steady_clock is not a clock"); -static_assert(is_clock_v, "steady_clock is not a clock"); -static_assert(is_clock_v, "real_fake_clock is not a clock"); -static_assert(!is_clock_v, "not_a_clock is a clock"); - -int main() {} // COMPILE-ONLY diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index e64f31cecd1..f2b1508514b 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -189,7 +189,7 @@ constexpr void year_test() { assert(!year{y_min - 1}.ok()); assert(!year{y_max + 1}.ok()); - for (int i = y_min; i <= y_max; i++) { + for (int i = y_min; i <= y_max; ++i) { assert(year{i}.ok()); if (i % 4 == 0 && (i % 100 != 0 || i % 400 == 0)) { assert(year{i}.is_leap()); @@ -296,7 +296,7 @@ constexpr void weekday_indexed_test() { assert(wdi1 == wdi2); assert(!weekday_indexed(Sunday, 0).ok()); - for (unsigned int i = 1; i <= 5; i++) { + for (unsigned int i = 1; i <= 5; ++i) { assert(weekday_indexed(Sunday, i).ok()); assert(weekday_indexed(Monday, i).ok()); assert(weekday_indexed(Tuesday, i).ok()); @@ -518,11 +518,14 @@ constexpr void year_month_test() { if (is_constant_evaluated()) { static_assert((2020y / 01).ok()); static_assert(!(2020y / 13).ok()); + static_assert(!(32768y / 01).ok()); } else { - for (int y = y_min; y <= y_max; y++) { + for (int y = y_min - 1; y <= y_max + 1; ++y) { for (auto m = 0u; m <= 255u; ++m) { const auto ym2 = year{y} / month{m}; - if (m >= 1 && m <= 12) { + if (y == y_min - 1 || y == y_max + 1) { + assert(!ym2.ok()); + } else if (m >= 1 && m <= 12) { assert(ym2.ok()); } else { assert(!ym2.ok()); diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.compile.pass.cpp similarity index 100% rename from tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.cpp rename to tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.compile.pass.cpp From 2b9d23e146a90ab4d9b17af015985d74d2ba9511 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sat, 24 Oct 2020 17:31:39 +0100 Subject: [PATCH 101/143] The ONE file I forget to double check with clang-format --- .../test.compile.pass.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.compile.pass.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.compile.pass.cpp index af4db9cba79..4b25142393d 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.compile.pass.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.compile.pass.cpp @@ -49,9 +49,9 @@ struct no_duration { }; struct no_time_point { - using rep = bool; - using period = char; - using duration = float; + using rep = bool; + using period = char; + using duration = float; static long is_steady; static short now(); }; From 188cbee184dc17226da4155bf83dd9418c043e9c Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sat, 24 Oct 2020 17:38:41 +0100 Subject: [PATCH 102/143] Deleting the correct member would be a good idea. --- .../test.compile.pass.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.compile.pass.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.compile.pass.cpp index 4b25142393d..d51d2d6b8ac 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.compile.pass.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.compile.pass.cpp @@ -33,7 +33,7 @@ struct no_rep { }; struct no_period { - using period = char; + using rep = bool; using duration = float; using time_point = int; static long is_steady; From 58d2df716577f49054115776b6ef79a9bc9699ed Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Thu, 29 Oct 2020 15:50:40 +0000 Subject: [PATCH 103/143] Undo rename --- .../{test.compile.pass.cpp => test.cpp} | 0 .../{test.compile.pass.cpp => test.cpp} | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename tests/std/tests/P0355R7_calendars_and_time_zones_clocks/{test.compile.pass.cpp => test.cpp} (100%) rename tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/{test.compile.pass.cpp => test.cpp} (100%) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.compile.pass.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.cpp similarity index 100% rename from tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.compile.pass.cpp rename to tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.cpp diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.compile.pass.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.cpp similarity index 100% rename from tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.compile.pass.cpp rename to tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.cpp From ed8be650c0cc88b2a2cd5a2325ede84e368687d4 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Fri, 30 Oct 2020 12:30:58 +0000 Subject: [PATCH 104/143] _Is_Clock -> _Is_clock --- stl/inc/chrono | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 46d91415ea6..30ab96941df 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -55,7 +55,7 @@ namespace chrono { #if _HAS_CXX20 template - concept _Is_Clock = requires { + concept _Is_clock = requires { typename _Clock::rep; typename _Clock::period; typename _Clock::duration; @@ -65,9 +65,9 @@ namespace chrono { }; template - struct is_clock : bool_constant<_Is_Clock<_Clock>> {}; + struct is_clock : bool_constant<_Is_clock<_Clock>> {}; template - inline constexpr bool is_clock_v = _Is_Clock<_Clock>; + inline constexpr bool is_clock_v = _Is_clock<_Clock>; #endif // HAS_CXX20 // CLASS TEMPLATE duration From ba14ddbb0f2c942a3a70db6531064ccff1033628 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Tue, 3 Nov 2020 07:40:28 +0000 Subject: [PATCH 105/143] Address STL's comment --- stl/inc/chrono | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 30ab96941df..9870dd3e091 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1233,11 +1233,12 @@ namespace chrono { return *this; } + inline constexpr day _Last_day_table[] = { + day{31}, day{28}, day{31}, day{30}, day{31}, day{30}, day{31}, day{31}, day{30}, day{31}, day{30}, day{31}}; + _NODISCARD constexpr inline day _Last_day(const year& _Year, const month& _Month) { - constexpr day _Days[] = { - day{31}, day{28}, day{31}, day{30}, day{31}, day{30}, day{31}, day{31}, day{30}, day{31}, day{30}, day{31}}; - return _Month == month{2} && _Year.is_leap() ? _Days[static_cast(_Month) - 1] + days{1} - : _Days[static_cast(_Month) - 1]; + return _Month == month{2} && _Year.is_leap() ? _Last_day_table[static_cast(_Month) - 1] + days{1} + : _Last_day_table[static_cast(_Month) - 1]; } class year_month_day { From 317a604612c1342ee92df08961cb64d061866269 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Fri, 6 Nov 2020 14:23:22 +0000 Subject: [PATCH 106/143] STL's feedback --- stl/inc/chrono | 18 +++++++++--------- .../test.cpp | 6 ++++++ .../test.cpp | 6 ++++++ 3 files changed, 21 insertions(+), 9 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 9870dd3e091..0376f6f3ac2 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -68,7 +68,7 @@ namespace chrono { struct is_clock : bool_constant<_Is_clock<_Clock>> {}; template inline constexpr bool is_clock_v = _Is_clock<_Clock>; -#endif // HAS_CXX20 +#endif // _HAS_CXX20 // CLASS TEMPLATE duration template > @@ -217,18 +217,18 @@ namespace chrono { } #if _HAS_CXX20 - constexpr time_point& operator++() { + constexpr time_point& operator++() noexcept(is_arithmetic_v) /* strengthened */ { ++_MyDur; return *this; } - constexpr time_point operator++(int) { + constexpr time_point operator++(int) noexcept(is_arithmetic_v) /* strengthened */ { return time_point{_MyDur++}; } - constexpr time_point& operator--() { + constexpr time_point& operator--() noexcept(is_arithmetic_v) /* strengthened */ { --_MyDur; return *this; } - constexpr time_point operator--(int) { + constexpr time_point operator--(int) noexcept(is_arithmetic_v) /* strengthened */ { return time_point{_MyDur--}; } #endif // _HAS_CXX20 @@ -763,7 +763,7 @@ namespace chrono { return *this; } constexpr month operator--(int) noexcept { - const month _Temp{*this}; + month _Temp{*this}; --(*this); return _Temp; } @@ -772,7 +772,7 @@ namespace chrono { constexpr month& operator-=(const months& _Months) noexcept; _NODISCARD constexpr explicit operator unsigned int() const noexcept { - return static_cast(_Month); + return _Month; } _NODISCARD constexpr bool ok() const noexcept { return _Month >= 1 && _Month <= 12; @@ -909,7 +909,7 @@ namespace chrono { return *this += days{1}; } constexpr weekday operator++(int) noexcept { - const weekday _Temp{*this}; + weekday _Temp{*this}; ++(*this); return _Temp; } @@ -917,7 +917,7 @@ namespace chrono { return *this -= days{1}; } constexpr weekday operator--(int) noexcept { - const weekday _Temp{*this}; + weekday _Temp{*this}; --(*this); return _Temp; } diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index f2b1508514b..fb57b122a74 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -177,6 +177,12 @@ constexpr void year_test() { y -= years{2}; assert(y == 1y); + year extreme{-30'000}; + extreme += years{60'000}; + assert(extreme == 30'000y); + extreme -= years{60'000}; + assert(extreme == -30'000y); + assert(+y == 1y); assert(-y == -1y); auto y2 = -y; diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_and_durations/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_and_durations/test.cpp index cc71ed5f1a6..2d118dc1322 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_and_durations/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_and_durations/test.cpp @@ -35,6 +35,12 @@ static_assert(is_same_v>, constexpr bool test() { steady_clock::time_point tp1; + + static_assert(noexcept(++tp1)); // strengthened + static_assert(noexcept(tp1++)); // strengthened + static_assert(noexcept(--tp1)); // strengthened + static_assert(noexcept(tp1--)); // strengthened + auto tp2 = tp1++; assert(tp1.time_since_epoch().count() == 1); assert(tp2.time_since_epoch().count() == 0); From 657a99b64b51e9cd3f87395b6a2fd5eb6e8b5c51 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sat, 7 Nov 2020 08:36:30 +0000 Subject: [PATCH 107/143] Use a temp int --- stl/inc/chrono | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 3af82f967a8..6346b5ddd44 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -916,11 +916,15 @@ namespace chrono { } constexpr year& operator+=(const years& _Years) noexcept { - _Year += static_cast(_Years.count()); + int _Temp = _Year; // TRANSITION, EDG bug not yet reported + _Temp += _Years.count(); + _Year = static_cast(_Temp); return *this; } constexpr year& operator-=(const years& _Years) noexcept { - _Year -= static_cast(_Years.count()); + int _Temp = _Year; // TRANSITION, EDG bug not yet reported + _Temp -= _Years.count(); + _Year = static_cast(_Temp); return *this; } From 21df61e8bd5506a3a9e24c63b26175b6e5fafd1e Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sun, 8 Nov 2020 09:12:54 +0000 Subject: [PATCH 108/143] Condense year::operator+= --- stl/inc/chrono | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 6346b5ddd44..68bc799c941 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -916,15 +916,11 @@ namespace chrono { } constexpr year& operator+=(const years& _Years) noexcept { - int _Temp = _Year; // TRANSITION, EDG bug not yet reported - _Temp += _Years.count(); - _Year = static_cast(_Temp); + _Year = static_cast(_Year + _Years.count()); // TRANSITION, EDG bug not yet reported return *this; } constexpr year& operator-=(const years& _Years) noexcept { - int _Temp = _Year; // TRANSITION, EDG bug not yet reported - _Temp -= _Years.count(); - _Year = static_cast(_Temp); + _Year = static_cast(_Year - _Years.count()); // TRANSITION, EDG bug not yet reported return *this; } From dbd45b0f03be3a6b7652e5c6dbc747113ff2e29c Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sun, 15 Nov 2020 14:03:53 +0000 Subject: [PATCH 109/143] remove leading 0's --- .../test.cpp | 36 +++++++++---------- 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index fb57b122a74..dd896128290 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -522,9 +522,9 @@ constexpr void year_month_test() { assert(ym - years{2} == 2018y / January); if (is_constant_evaluated()) { - static_assert((2020y / 01).ok()); + static_assert((2020y / 1).ok()); static_assert(!(2020y / 13).ok()); - static_assert(!(32768y / 01).ok()); + static_assert(!(32768y / 1).ok()); } else { for (int y = y_min - 1; y <= y_max + 1; ++y) { for (auto m = 0u; m <= 255u; ++m) { @@ -614,7 +614,7 @@ constexpr void year_month_day_test() { assert(ymd1.month() == January); assert(ymd1.day() == 1d); - assert(2020y / April / 06d == sys_days{days{18'358}}); + assert(2020y / April / 6d == sys_days{days{18'358}}); assert(sys_days{2017y / January / 0} == 2016y / December / 31); assert(sys_days{2017y / January / 31} == 2017y / January / 31); assert(sys_days{2017y / January / 32} == 2017y / February / 1); @@ -643,20 +643,20 @@ constexpr void year_month_day_test() { assert(2020y / January / 1d - years{2} == 2018y / January / 1d); if (is_constant_evaluated()) { - static_assert(!(-32768y / 01 / 01).ok()); - static_assert(!(32768y / 01 / 01).ok()); - static_assert((2020y / 01 / 01).ok()); - - static_assert(!(2020y / 00 / 01).ok()); - static_assert(!(2020y / 13 / 01).ok()); - static_assert((2020y / 05 / 01).ok()); - - static_assert(!(2020y / 02 / 30).ok()); - static_assert(!(2019y / 02 / 29).ok()); - static_assert(!(2020y / 01 / 00).ok()); - static_assert(!(2020y / 01 / 32).ok()); - static_assert((2020y / 02 / 29).ok()); - static_assert((2020y / 07 / 31).ok()); + static_assert(!(-32768y / 1 / 1).ok()); + static_assert(!(32768y / 1 / 1).ok()); + static_assert((2020y / 1 / 1).ok()); + + static_assert(!(2020y / 0 / 1).ok()); + static_assert(!(2020y / 13 / 1).ok()); + static_assert((2020y / 5 / 1).ok()); + + static_assert(!(2020y / 2 / 30).ok()); + static_assert(!(2019y / 2 / 29).ok()); + static_assert(!(2020y / 1 / 0).ok()); + static_assert(!(2020y / 1 / 32).ok()); + static_assert((2020y / 2 / 29).ok()); + static_assert((2020y / 7 / 31).ok()); } else { for (int iy = y_min; iy <= y_max; ++iy) { for (auto um = 0u; um <= 255u; ++um) { @@ -743,7 +743,7 @@ constexpr void year_month_day_last_test() { assert(ymdl - years{2} == 2018y / February / last); if (is_constant_evaluated()) { - static_assert((2020y / 01 / last).ok()); + static_assert((2020y / 1 / last).ok()); static_assert(!(2020y / 13 / last).ok()); } else { for (int iy = y_min; iy <= y_max; ++iy) { From f5f3865370123504c7005001387fe24cf9b7a067 Mon Sep 17 00:00:00 2001 From: Curtis Jacques Bezault Date: Sat, 5 Dec 2020 09:35:03 -0800 Subject: [PATCH 110/143] Rename compile-only tests --- .../{test.cpp => test.compile.pass.cpp} | 0 .../{test.cpp => test.compile.pass.cpp} | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename tests/std/tests/P0355R7_calendars_and_time_zones_clocks/{test.cpp => test.compile.pass.cpp} (100%) rename tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/{test.cpp => test.compile.pass.cpp} (100%) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.compile.pass.cpp similarity index 100% rename from tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.cpp rename to tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.compile.pass.cpp diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.compile.pass.cpp similarity index 100% rename from tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.cpp rename to tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.compile.pass.cpp From 2984f7184fc688b96b2125920afae0fe2a41b268 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Sat, 12 Dec 2020 11:38:27 +0000 Subject: [PATCH 111/143] Run clang-format --- stl/inc/chrono | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 68bc799c941..1507cba1a26 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1281,8 +1281,8 @@ namespace chrono { _NODISCARD constexpr months operator-(const year_month& _Left, const year_month& _Right) noexcept { return _Left.year() - _Right.year() - + months{static_cast(static_cast(_Left.month())) - - static_cast(static_cast(_Right.month()))}; + + months{static_cast(static_cast(_Left.month())) + - static_cast(static_cast(_Right.month()))}; } _NODISCARD constexpr year_month operator+(const year_month& _Left, const years& _Right) noexcept { @@ -1395,7 +1395,7 @@ namespace chrono { const int _Era = (_Ye >= 0 ? _Ye : _Ye - 399) / 400; const unsigned int _Year_of_era = static_cast(_Ye - _Era * 400); // [0, 399] const unsigned int _Day_of_year = (153 * (_Mo + (_Mo > 2 ? static_cast(-3) : 9)) + 2) / 5 - + static_cast(_Day) - 1; // [0, 365] + + static_cast(_Day) - 1; // [0, 365] const unsigned int _Day_of_era = _Year_of_era * 365 + _Year_of_era / 4 - _Year_of_era / 100 + _Day_of_year; // [0, 146096] return days{_Era * 146097 + static_cast(_Day_of_era) - 719468}; @@ -1631,7 +1631,7 @@ namespace chrono { _NODISCARD constexpr bool operator==(const year_month_weekday& _Left, const year_month_weekday& _Right) noexcept { return _Left.year() == _Right.year() && _Left.month() == _Right.month() - && _Left.weekday_indexed() == _Right.weekday_indexed(); + && _Left.weekday_indexed() == _Right.weekday_indexed(); } _NODISCARD constexpr year_month_weekday operator+(const year_month_weekday& _Left, const months& _Right) noexcept { @@ -1719,7 +1719,7 @@ namespace chrono { _NODISCARD constexpr bool operator==( const year_month_weekday_last& _Left, const year_month_weekday_last& _Right) noexcept { return _Left.year() == _Right.year() && _Left.month() == _Right.month() - && _Left.weekday_last() == _Right.weekday_last(); + && _Left.weekday_last() == _Right.weekday_last(); } _NODISCARD constexpr year_month_weekday_last operator+( From d7f300cc6469ea6611ebe01e6393183507bf81dd Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Fri, 22 Jan 2021 19:39:05 -0800 Subject: [PATCH 112/143] Adjust paper title in yvals_core.h. --- stl/inc/yvals_core.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h index 85d8829fb07..cb6379b7566 100644 --- a/stl/inc/yvals_core.h +++ b/stl/inc/yvals_core.h @@ -138,7 +138,7 @@ // P0318R1 unwrap_reference, unwrap_ref_decay // P0325R4 to_array() // P0339R6 polymorphic_allocator<> -// P0355R7 Calendars And Time Zones +// P0355R7 Calendars And Time Zones // (partially implemented) // P0356R5 bind_front() // P0357R3 Supporting Incomplete Types In reference_wrapper From 91dd9c63f1a5e5512e2de7e006f2081032a03c92 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Fri, 22 Jan 2021 19:40:06 -0800 Subject: [PATCH 113/143] Organize libcxx skips due to bogus tests. --- tests/libcxx/expected_results.txt | 29 ++++++++++++++++++++++++----- tests/libcxx/skipped_tests.txt | 30 ++++++++++++++++++++++++------ tests/libcxx/usual_matrix.lst | 2 +- 3 files changed, 49 insertions(+), 12 deletions(-) diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt index 3b0259a1aa3..f87033a4b49 100644 --- a/tests/libcxx/expected_results.txt +++ b/tests/libcxx/expected_results.txt @@ -289,9 +289,7 @@ std/strings/string.view/string.view.io/stream_insert_decl_present.compile.pass.c std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/streaming.pass.cpp FAIL std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/streaming.pass.cpp FAIL std/utilities/time/time.cal/time.cal.mdlast/streaming.pass.cpp FAIL -std/utilities/time/time.cal/time.cal.month/time.cal.month.members/decrement.pass.cpp FAIL std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/streaming.pass.cpp FAIL -std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/month.pass.cpp FAIL std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/streaming.pass.cpp FAIL std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/streaming.pass.cpp FAIL std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/streaming.pass.cpp FAIL @@ -307,9 +305,6 @@ std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp FAIL std/utilities/time/time.clock/time.clock.file/file_time.pass.cpp FAIL std/utilities/time/time.clock/time.clock.file/now.pass.cpp FAIL std/utilities/time/time.clock/time.clock.file/rep_signed.pass.cpp FAIL -# conversion from '__int64' to 'long', possible loss of data -std/utilities/time/time.hms/time.hms.members/seconds.pass.cpp:0 FAIL -std/utilities/time/time.hms/time.hms.members/subseconds.pass.cpp:0 FAIL # C++20 P0608R3 "Improving variant's Converting Constructor/Assignment" std/utilities/variant/variant.variant/variant.assign/conv.pass.cpp FAIL @@ -634,6 +629,30 @@ std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp F # They shouldn't behave differently. Both of them should probably return NaN. std/numerics/c.math/c.math.lerp/c.math.lerp.pass.cpp FAIL +# --month{14} should be 1, not 13 as the test expects +std/utilities/time/time.cal/time.cal.month/time.cal.month.members/decrement.pass.cpp FAIL + +# test is broken due to month_weekday not being default constructible +std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/month.pass.cpp FAIL + +# conversion from '__int64' to 'long', possible loss of data +std/utilities/time/time.hms/time.hms.members/seconds.pass.cpp:0 FAIL +std/utilities/time/time.hms/time.hms.members/subseconds.pass.cpp:0 FAIL + +# Code: `for (int i = 1000; i < 20; ++i)` +# warning C6294: Ill-defined for-loop: initial condition does not satisfy test. Loop body not executed. +std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/comparisons.pass.cpp:0 FAIL +std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/comparisons.pass.cpp:0 FAIL +std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/comparisons.pass.cpp:0 FAIL +std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/comparisons.pass.cpp:0 FAIL +std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/comparisons.pass.cpp:0 FAIL +std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/comparisons.pass.cpp:0 FAIL + +# Tests are manually declaring printf, which appears to be unused. +# warning C28301: No annotations for first declaration of 'printf'. +std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/minus.pass.cpp:0 FAIL +std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/minus.pass.cpp:0 FAIL + # *** LIKELY STL BUGS *** # Not yet analyzed, likely STL bugs. Assertions and other runtime failures. diff --git a/tests/libcxx/skipped_tests.txt b/tests/libcxx/skipped_tests.txt index 433f7ca848c..a087a941415 100644 --- a/tests/libcxx/skipped_tests.txt +++ b/tests/libcxx/skipped_tests.txt @@ -289,11 +289,7 @@ strings\string.view\string.view.io\stream_insert_decl_present.compile.pass.cpp utilities\time\time.cal\time.cal.day\time.cal.day.nonmembers\streaming.pass.cpp utilities\time\time.cal\time.cal.md\time.cal.md.nonmembers\streaming.pass.cpp utilities\time\time.cal\time.cal.mdlast\streaming.pass.cpp -# --month{14} should be 1, not 13 as the test expects -utilities\time\time.cal\time.cal.month\time.cal.month.members\decrement.pass.cpp utilities\time\time.cal\time.cal.month\time.cal.month.nonmembers\streaming.pass.cpp -# test is broken due to month_weekday not being default constructible -utilities\time\time.cal\time.cal.mwd\time.cal.mwd.members\month.pass.cpp utilities\time\time.cal\time.cal.mwd\time.cal.mwd.nonmembers\streaming.pass.cpp utilities\time\time.cal\time.cal.mwdlast\time.cal.mwdlast.nonmembers\streaming.pass.cpp utilities\time\time.cal\time.cal.wdidx\time.cal.wdidx.nonmembers\streaming.pass.cpp @@ -309,8 +305,6 @@ utilities\time\time.clock\time.clock.file\consistency.pass.cpp utilities\time\time.clock\time.clock.file\file_time.pass.cpp utilities\time\time.clock\time.clock.file\now.pass.cpp utilities\time\time.clock\time.clock.file\rep_signed.pass.cpp -utilities\time\time.hms\time.hms.members\seconds.pass.cpp -utilities\time\time.hms\time.hms.members\subseconds.pass.cpp # C++20 P0608R3 "Improving variant's Converting Constructor/Assignment" utilities\variant\variant.variant\variant.assign\conv.pass.cpp @@ -635,6 +629,30 @@ numerics\rand\rand.dis\rand.dist.samp\rand.dist.samp.plinear\eval.pass.cpp # They shouldn't behave differently. Both of them should probably return NaN. numerics\c.math\c.math.lerp\c.math.lerp.pass.cpp +# --month{14} should be 1, not 13 as the test expects +utilities\time\time.cal\time.cal.month\time.cal.month.members\decrement.pass.cpp + +# test is broken due to month_weekday not being default constructible +utilities\time\time.cal\time.cal.mwd\time.cal.mwd.members\month.pass.cpp + +# conversion from '__int64' to 'long', possible loss of data +utilities\time\time.hms\time.hms.members\seconds.pass.cpp +utilities\time\time.hms\time.hms.members\subseconds.pass.cpp + +# Code: `for (int i = 1000; i < 20; ++i)` +# warning C6294: Ill-defined for-loop: initial condition does not satisfy test. Loop body not executed. +utilities\time\time.cal\time.cal.month\time.cal.month.nonmembers\comparisons.pass.cpp +utilities\time\time.cal\time.cal.ym\time.cal.ym.nonmembers\comparisons.pass.cpp +utilities\time\time.cal\time.cal.ymd\time.cal.ymd.nonmembers\comparisons.pass.cpp +utilities\time\time.cal\time.cal.ymdlast\time.cal.ymdlast.nonmembers\comparisons.pass.cpp +utilities\time\time.cal\time.cal.ymwd\time.cal.ymwd.nonmembers\comparisons.pass.cpp +utilities\time\time.cal\time.cal.ymwdlast\time.cal.ymwdlast.nonmembers\comparisons.pass.cpp + +# Tests are manually declaring printf, which appears to be unused. +# warning C28301: No annotations for first declaration of 'printf'. +utilities\time\time.cal\time.cal.weekday\time.cal.weekday.nonmembers\minus.pass.cpp +utilities\time\time.cal\time.cal.year\time.cal.year.nonmembers\minus.pass.cpp + # *** LIKELY STL BUGS *** # Not yet analyzed, likely STL bugs. Assertions and other runtime failures. diff --git a/tests/libcxx/usual_matrix.lst b/tests/libcxx/usual_matrix.lst index 68a33696a78..a5dd5afec7f 100644 --- a/tests/libcxx/usual_matrix.lst +++ b/tests/libcxx/usual_matrix.lst @@ -3,7 +3,7 @@ RUNALL_INCLUDE ..\universal_prefix.lst RUNALL_CROSSLIST -PM_CL="/EHsc /MTd /std:c++latest /permissive- /FImsvc_stdlib_force_include.h /wd4643 /wd6294 /wd28301" +PM_CL="/EHsc /MTd /std:c++latest /permissive- /FImsvc_stdlib_force_include.h /wd4643" RUNALL_CROSSLIST PM_CL="/analyze:autolog- /Zc:preprocessor" PM_COMPILER="clang-cl" PM_CL="-fno-ms-compatibility -fno-delayed-template-parsing" From 94aab5b6ee647190e4fca560bcae9983992ccbe5 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Fri, 22 Jan 2021 20:46:39 -0800 Subject: [PATCH 114/143] Code review feedback (trivial test changes). --- .../test.compile.pass.cpp | 1 - .../test.compile.pass.cpp | 2 +- .../tests/P0355R7_calendars_and_time_zones_hms/test.cpp | 7 +++++-- .../test.cpp | 2 +- 4 files changed, 7 insertions(+), 5 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.compile.pass.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.compile.pass.cpp index d51d2d6b8ac..26ac91006b0 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.compile.pass.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_clocks/test.compile.pass.cpp @@ -1,7 +1,6 @@ // Copyright (c) Microsoft Corporation. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -#include #include using namespace std::chrono; diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.compile.pass.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.compile.pass.cpp index b4e9b2e69bd..f0512320f08 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.compile.pass.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates_literals/test.compile.pass.cpp @@ -52,7 +52,7 @@ static_assert(noexcept(month_weekday_last{January, Sunday[last]} / 0)); #define TRIVIAL_COPY_STANDARD_LAYOUT(TYPE) \ static_assert(is_trivially_copyable_v, "chrono::" #TYPE " is not trivially copyable"); \ - static_assert(is_standard_layout_v, "chrono::" #TYPE " is not standard layout"); + static_assert(is_standard_layout_v, "chrono::" #TYPE " is not standard-layout"); TRIVIAL_COPY_STANDARD_LAYOUT(day) TRIVIAL_COPY_STANDARD_LAYOUT(month) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp index 61156b356cf..a1e3dde2767 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp @@ -3,6 +3,9 @@ #include #include +#include +#include +#include using namespace std; using namespace std::chrono; @@ -149,9 +152,9 @@ constexpr void to_duration() { assert(hh_mm_ss(-ones).to_duration() == -ones); hh_mm_ss hms(50ms); - milliseconds milli = static_cast(hms); + milliseconds milli_val = static_cast(hms); static_assert(is_same_v); - assert(hms.to_duration() == milli); + assert(hms.to_duration() == milli_val); } constexpr bool test() { diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_and_durations/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_and_durations/test.cpp index 2d118dc1322..66bec4ea7da 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_and_durations/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_time_point_and_durations/test.cpp @@ -27,7 +27,7 @@ static_assert(is_same_v>, static_assert(is_same_v>, "sys_days is not time_point."); -static_assert( is_same_v>, +static_assert(is_same_v>, "local_seconds is not time_point."); static_assert(is_same_v>, "local_days is not time_point."); From 3b47eb535893bfb3eaf7b03547da7c0e81764fd7 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Fri, 22 Jan 2021 20:49:07 -0800 Subject: [PATCH 115/143] Fix fractional_width() test. --- tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp index a1e3dde2767..0155643c9a9 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp @@ -51,9 +51,9 @@ constexpr auto width() { } constexpr void fractional_width() { + static_assert(width() == 0); static_assert(width() == 0); static_assert(width() == 0); - static_assert(width() == 0); static_assert(width() == 0); static_assert(width() == 3); static_assert(width() == 6); From 057fa2814e099d61fc68e88c5bfde5cf51ab9e4d Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Mon, 25 Jan 2021 10:47:44 +0000 Subject: [PATCH 116/143] statementreply's feedback --- .../test.cpp | 2 +- .../test.cpp | 40 +++++++++++++------ 2 files changed, 28 insertions(+), 14 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index dd896128290..00db50a54f5 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -184,7 +184,7 @@ constexpr void year_test() { assert(extreme == -30'000y); assert(+y == 1y); - assert(-y == -1y); + assert(-y == year{-1}); auto y2 = -y; assert(-y2 == y); assert(+y2 == -y); diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp index 0155643c9a9..b7dd27cca66 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp @@ -45,9 +45,9 @@ template constexpr auto width() { return hh_mm_ss::fractional_width; } -template +template constexpr auto width() { - return hh_mm_ss>>::fractional_width; + return hh_mm_ss>>::fractional_width; } constexpr void fractional_width() { @@ -59,17 +59,31 @@ constexpr void fractional_width() { static_assert(width() == 6); static_assert(width() == 9); - static_assert(width<1, 2>() == 1); - static_assert(width<1, 3>() == 6); - static_assert(width<1, 4>() == 2); - static_assert(width<1, 5>() == 1); - static_assert(width<1, 6>() == 6); - static_assert(width<1, 7>() == 6); - static_assert(width<1, 8>() == 3); - static_assert(width<1, 9>() == 6); - static_assert(width<1, 10>() == 1); - static_assert(width<756, 625>() == 4); - static_assert(width<3780, 625>() == 3); + static_assert(width() == 1); + static_assert(width() == 6); + static_assert(width() == 2); + static_assert(width() == 1); + static_assert(width() == 6); + static_assert(width() == 6); + static_assert(width() == 3); + static_assert(width() == 6); + static_assert(width() == 1); + static_assert(width() == 4); + static_assert(width() == 3); + static_assert(width() == 6); + + static_assert(width() == 1); + static_assert(width() == 6); + static_assert(width() == 2); + static_assert(width() == 1); + static_assert(width() == 6); + static_assert(width() == 6); + static_assert(width() == 3); + static_assert(width() == 6); + static_assert(width() == 1); + static_assert(width() == 4); + static_assert(width() == 3); + static_assert(width() == 6); } constexpr void constructor() { From e8c2922d75907facee9ee02415eab1a8329545b5 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Mon, 25 Jan 2021 14:30:27 +0000 Subject: [PATCH 117/143] More floating point --- .../test.cpp | 32 +++++++++++++++++-- 1 file changed, 30 insertions(+), 2 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp index b7dd27cca66..2b3da91a522 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp @@ -10,7 +10,9 @@ using namespace std; using namespace std::chrono; -using hms_hours = hh_mm_ss; +using hms_hours = hh_mm_ss; +using f_hours = duration>; +using f_hms_hours = hh_mm_ss; constexpr void am_pm() { static_assert(noexcept(is_am(hours{}))); @@ -71,6 +73,7 @@ constexpr void fractional_width() { static_assert(width() == 4); static_assert(width() == 3); static_assert(width() == 6); + // static_assert(width() == 6); overflows static_assert(width() == 1); static_assert(width() == 6); @@ -84,19 +87,27 @@ constexpr void fractional_width() { static_assert(width() == 4); static_assert(width() == 3); static_assert(width() == 6); + // static_assert(width() == 6); overflows } constexpr void constructor() { static_assert(noexcept(hms_hours{})); + static_assert(noexcept(f_hms_hours{})); assert(hms_hours{}.hours() == hms_hours{hours::zero()}.hours()); assert(hms_hours{}.minutes() == hms_hours{hours::zero()}.minutes()); assert(hms_hours{}.seconds() == hms_hours{hours::zero()}.seconds()); assert(hms_hours{}.subseconds() == hms_hours{hours::zero()}.subseconds()); + + assert(f_hms_hours{}.hours() == f_hms_hours{hours::zero()}.hours()); + assert(f_hms_hours{}.minutes() == f_hms_hours{hours::zero()}.minutes()); + assert(f_hms_hours{}.seconds() == f_hms_hours{hours::zero()}.seconds()); + assert(f_hms_hours{}.subseconds() == f_hms_hours{hours::zero()}.subseconds()); } constexpr void is_negative() { static_assert(noexcept(hms_hours{}.is_negative())); + static_assert(noexcept(f_hms_hours{}.is_negative())); assert(hh_mm_ss(days{-1}).is_negative()); assert(!hh_mm_ss(days{1}).is_negative()); @@ -118,52 +129,69 @@ constexpr void is_negative() { assert(hh_mm_ss(-1ns).is_negative()); assert(!hh_mm_ss(1ns).is_negative()); + + assert(f_hms_hours(f_hours(-1.f)).is_negative()); + assert(!f_hms_hours(f_hours(1.f)).is_negative()); } constexpr auto ones = 1h + 1min + 1s + 1ms; constexpr void hour() { static_assert(noexcept(hms_hours{}.hours())); + static_assert(noexcept(f_hms_hours{}.hours())); assert(hh_mm_ss(days{1}).hours() == 24h); assert(hh_mm_ss(ones).hours() == 1h); assert(hh_mm_ss(-ones).hours() == 1h); assert(hh_mm_ss(59min).hours() == 0h); + assert(f_hms_hours(f_hours(1.f)).hours() == 1h); } constexpr void mins() { static_assert(noexcept(hms_hours{}.minutes())); + static_assert(noexcept(f_hms_hours{}.minutes())); assert(hh_mm_ss(ones).minutes() == 1min); assert(hh_mm_ss(-ones).minutes() == 1min); assert(hh_mm_ss(59s).minutes() == 0min); + assert(f_hms_hours(f_hours(0.0166667f)).minutes() == 1min); } constexpr void secs() { static_assert(noexcept(hms_hours{}.seconds())); + static_assert(noexcept(f_hms_hours{}.seconds())); assert(hh_mm_ss(ones).seconds() == 1s); assert(hh_mm_ss(-ones).seconds() == 1s); assert(hh_mm_ss(999ms).seconds() == 0s); + assert(f_hms_hours(f_hours(0.000277778f)).seconds() == 1s); } constexpr void subsecs() { static_assert(noexcept(hms_hours{}.subseconds())); + static_assert(noexcept(f_hms_hours{}.subseconds())); assert(hh_mm_ss(ones).subseconds() == 1ms); assert(hh_mm_ss(-ones).subseconds() == 1ms); assert(hh_mm_ss(999us).subseconds() == 999us); assert(hh_mm_ss(duration_cast(999us)).subseconds() == 0ms); + using f_hms_milli = hh_mm_ss>; + assert(f_hms_milli(1ms).subseconds() == 1ms); } constexpr void to_duration() { - using precision = hms_hours::precision; + using precision = hms_hours::precision; + using f_precision = f_hms_hours::precision; static_assert(noexcept(hms_hours{}.to_duration())); static_assert(noexcept(static_cast(hms_hours{}))); + static_assert(noexcept(f_hms_hours{}.to_duration())); + static_assert(noexcept(static_cast(f_hms_hours{}))); assert(hh_mm_ss(ones).to_duration() == ones); assert(hh_mm_ss(-ones).to_duration() == -ones); + assert(f_hms_hours(f_hours(1.f)).to_duration() == 1h); + assert(f_hms_hours(f_hours(-1.f)).to_duration() == -1h); hh_mm_ss hms(50ms); milliseconds milli_val = static_cast(hms); From e2cce70a66cd0021b846e61723ae6369ba8627f9 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Tue, 26 Jan 2021 19:28:44 -0800 Subject: [PATCH 118/143] Rename _M and _Y identifiers. --- stl/inc/chrono | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 1507cba1a26..6bd46f1de83 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1158,7 +1158,7 @@ namespace chrono { class month_day_last { public: - constexpr explicit month_day_last(const month& _M) noexcept : _Month{_M} {} + constexpr explicit month_day_last(const month& _Month_) noexcept : _Month{_Month_} {} _NODISCARD constexpr month month() const noexcept { return _Month; @@ -1181,8 +1181,8 @@ namespace chrono { class month_weekday { public: - constexpr month_weekday(const month& _M, const weekday_indexed& _Wdi) noexcept - : _Month{_M}, _Weekday_index{_Wdi} {} + constexpr month_weekday(const month& _Month_, const weekday_indexed& _Wdi) noexcept + : _Month{_Month_}, _Weekday_index{_Wdi} {} _NODISCARD constexpr month month() const noexcept { return _Month; @@ -1206,8 +1206,8 @@ namespace chrono { class month_weekday_last { public: - constexpr month_weekday_last(const month& _M, const weekday_last& _Wdl) noexcept - : _Month{_M}, _Weekday_last{_Wdl} {} + constexpr month_weekday_last(const month& _Month_, const weekday_last& _Wdl) noexcept + : _Month{_Month_}, _Weekday_last{_Wdl} {} _NODISCARD constexpr month month() const noexcept { return _Month; @@ -1231,7 +1231,7 @@ namespace chrono { class year_month { public: year_month() = default; - constexpr year_month(const year& _Y, const month& _M) noexcept : _Year{_Y}, _Month{_M} {} + constexpr year_month(const year& _Year_, const month& _Month_) noexcept : _Year{_Year_}, _Month{_Month_} {} _NODISCARD constexpr year year() const noexcept { return _Year; From c976e34214bdd8ea45790cdd646524cf9ee639c1 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Tue, 26 Jan 2021 19:40:41 -0800 Subject: [PATCH 119/143] For functions, constexpr implies inline. --- stl/inc/chrono | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 6bd46f1de83..957a39777c5 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1317,7 +1317,7 @@ namespace chrono { inline constexpr day _Last_day_table[] = { day{31}, day{28}, day{31}, day{30}, day{31}, day{30}, day{31}, day{31}, day{30}, day{31}, day{30}, day{31}}; - _NODISCARD constexpr inline day _Last_day(const year& _Year, const month& _Month) { + _NODISCARD constexpr day _Last_day(const year& _Year, const month& _Month) { return _Month == month{2} && _Year.is_leap() ? _Last_day_table[static_cast(_Month) - 1] + days{1} : _Last_day_table[static_cast(_Month) - 1]; } From 096f859aa76fc3c0a2b060f42a05854d0cf48478 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Tue, 26 Jan 2021 19:59:29 -0800 Subject: [PATCH 120/143] Remove unnecessary as_const(). --- stl/inc/chrono | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 957a39777c5..af12ab26afb 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1926,7 +1926,7 @@ namespace chrono { requires _Is_duration_v<_Duration> class hh_mm_ss { public: static constexpr unsigned int fractional_width = [_Num = _Duration::period::num, - &_Den = as_const(_Duration::period::den)]() mutable { + &_Den = _Duration::period::den]() mutable { // Returns the number of fractional digits of _Num / _Den in the range [0, 18]. // If it can't be represented, 6 is returned. // Example: _Fractional_width(1, 8) would return 3 for 0.125. From 606492925b02221eab6b36f81c363e65abb3209e Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Tue, 26 Jan 2021 20:41:23 -0800 Subject: [PATCH 121/143] Use static member function syntax. --- .../std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 00db50a54f5..2410e8b6c68 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -148,8 +148,8 @@ constexpr void year_test() { static_assert(noexcept(y.is_leap())); static_assert(noexcept(static_cast(y))); static_assert(noexcept(y.ok())); - static_assert(noexcept(y.min())); - static_assert(noexcept(y.max())); + static_assert(noexcept(year::min())); + static_assert(noexcept(year::max())); static_assert(noexcept(y == y)); static_assert(noexcept(y <=> y)); From 97c14eb22e4c079de3ccbc0652cd0ab6ea22ba56 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Tue, 26 Jan 2021 21:01:29 -0800 Subject: [PATCH 122/143] Construct temporaries with braces. Need extra parens for assert. --- .../test.cpp | 40 +++++++++---------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 2410e8b6c68..f860356ecc5 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -301,18 +301,18 @@ constexpr void weekday_indexed_test() { assert(wdi1 == wdi2); - assert(!weekday_indexed(Sunday, 0).ok()); + assert((!weekday_indexed{Sunday, 0}.ok())); for (unsigned int i = 1; i <= 5; ++i) { - assert(weekday_indexed(Sunday, i).ok()); - assert(weekday_indexed(Monday, i).ok()); - assert(weekday_indexed(Tuesday, i).ok()); - assert(weekday_indexed(Wednesday, i).ok()); - assert(weekday_indexed(Thursday, i).ok()); - assert(weekday_indexed(Friday, i).ok()); - assert(weekday_indexed(Saturday, i).ok()); + assert((weekday_indexed{Sunday, i}.ok())); + assert((weekday_indexed{Monday, i}.ok())); + assert((weekday_indexed{Tuesday, i}.ok())); + assert((weekday_indexed{Wednesday, i}.ok())); + assert((weekday_indexed{Thursday, i}.ok())); + assert((weekday_indexed{Friday, i}.ok())); + assert((weekday_indexed{Saturday, i}.ok())); } - assert(!weekday_indexed(Sunday, 6).ok()); - assert(!weekday_indexed(Sunday, 7).ok()); + assert((!weekday_indexed{Sunday, 6}.ok())); + assert((!weekday_indexed{Sunday, 7}.ok())); } constexpr void weekday_last_test() { @@ -348,11 +348,11 @@ constexpr void month_day_test() { assert(md.month() == January); assert(md.day() == 1d); - assert(md < month_day(January, 2d)); - assert(month_day(January, 2d) > md); - assert(md < month_day(December, 25d)); - assert(month_day(December, 25d) > md); - assert(md == month_day(January, 1d)); + assert((md < month_day{January, 2d})); + assert((month_day{January, 2d} > md)); + assert((md < month_day{December, 25d})); + assert((month_day{December, 25d} > md)); + assert((md == month_day{January, 1d})); if (is_constant_evaluated()) { static_assert((January / 31).ok()); @@ -366,16 +366,16 @@ constexpr void month_day_test() { month m{i}; for (unsigned int d = 0; d <= 255; ++d) { if (d < 1 || d > 31 || i < 1 || i > 12) { - assert(!month_day(m, day{d}).ok()); + assert((!month_day{m, day{d}}.ok())); } else if (d == 30 && m == February) { - assert(!month_day(m, day{d}).ok()); + assert((!month_day{m, day{d}}.ok())); break; } else if (d == 31 && (m == April || m == June || m == September || m == November)) { - assert(!month_day(m, day{d}).ok()); + assert((!month_day{m, day{d}}.ok())); } else if (d == 32) { - assert(!month_day(m, day{d}).ok()); + assert((!month_day{m, day{d}}.ok())); } else { - assert(month_day(m, day{d}).ok()); + assert((month_day{m, day{d}}.ok())); } } } From 72c5fa32890efa8b65c2d06980ecd1d8a9e09f71 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Tue, 26 Jan 2021 21:06:24 -0800 Subject: [PATCH 123/143] Remove unnecessary assert parens. --- .../test.cpp | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index f860356ecc5..257e634e4f3 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -592,7 +592,7 @@ constexpr void year_month_day_test() { local_days ldp; sys_days sys{ldp.time_since_epoch()}; year_month_day ymld{ldp}; - assert((ymld == year_month_day{sys})); + assert(ymld == year_month_day{sys}); ymd1 += months{2}; assert(ymd1.year() == 2020y); @@ -665,9 +665,9 @@ constexpr void year_month_day_test() { const month m{um}; const day d{ud}; if (y.ok() && m.ok() && d >= 1d && d <= (y / m / last).day()) { - assert(((y / m / d).ok())); + assert((y / m / d).ok()); } else { - assert((!(y / m / d).ok())); + assert(!(y / m / d).ok()); } } } @@ -753,7 +753,7 @@ constexpr void year_month_day_last_test() { if (y.ok() && mdl.ok()) { assert((y / mdl).ok()); } else { - assert((!(y / mdl).ok())); + assert(!(y / mdl).ok()); } } } @@ -807,7 +807,7 @@ constexpr void year_month_weekday_test() { local_days ldp; sys_days sys{ldp.time_since_epoch()}; year_month_weekday ymlwd{ldp}; - assert((ymlwd == year_month_weekday{sys})); + assert(ymlwd == year_month_weekday{sys}); ymwd += months{2}; assert(ymwd == 2020y / June / Tuesday[2]); @@ -886,8 +886,8 @@ constexpr void year_month_weekday_last_test() { ymwdl -= years{2}; assert(ymwdl == 2020y / January / Monday[last]); - assert((static_cast(ymwdl) == sys_days{days{18'288}})); - assert((static_cast(ymwdl) == local_days{ymwdl})); + assert(static_cast(ymwdl) == sys_days{days{18'288}}); + assert(static_cast(ymwdl) == local_days{ymwdl}); assert((2020y / April / Wednesday[last]).ok()); assert(!(-32768y / April / Wednesday[last]).ok()); From 8f8678c14c02c4d61d93123fd073706b08633ac5 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Tue, 26 Jan 2021 21:23:12 -0800 Subject: [PATCH 124/143] Cleanup month_day tests. Instead of breaking after Feb 30, mark Feb 31 as !ok. d == 32 is already handled by d > 31 above. --- .../tests/P0355R7_calendars_and_time_zones_dates/test.cpp | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 257e634e4f3..dbe13999e40 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -369,10 +369,7 @@ constexpr void month_day_test() { assert((!month_day{m, day{d}}.ok())); } else if (d == 30 && m == February) { assert((!month_day{m, day{d}}.ok())); - break; - } else if (d == 31 && (m == April || m == June || m == September || m == November)) { - assert((!month_day{m, day{d}}.ok())); - } else if (d == 32) { + } else if (d == 31 && (m == February || m == April || m == June || m == September || m == November)) { assert((!month_day{m, day{d}}.ok())); } else { assert((month_day{m, day{d}}.ok())); From ca40783d9bce47367c2137408ff362d4ce2686e3 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Tue, 26 Jan 2021 23:44:48 -0800 Subject: [PATCH 125/143] Replace lambda init-captures. This is simpler (now the lambda doesn't need to be mutable) and should be more optimizer-friendly (since MSVC has difficulty seeing through data members). --- stl/inc/chrono | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index af12ab26afb..d23cab1e1a6 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1925,8 +1925,9 @@ namespace chrono { template requires _Is_duration_v<_Duration> class hh_mm_ss { public: - static constexpr unsigned int fractional_width = [_Num = _Duration::period::num, - &_Den = _Duration::period::den]() mutable { + static constexpr unsigned int fractional_width = [] { + auto _Num = _Duration::period::num; + constexpr auto _Den = _Duration::period::den; // Returns the number of fractional digits of _Num / _Den in the range [0, 18]. // If it can't be represented, 6 is returned. // Example: _Fractional_width(1, 8) would return 3 for 0.125. From 39a183c544e4b184321d5a52188234c249d10b90 Mon Sep 17 00:00:00 2001 From: Daniel Marshall Date: Wed, 27 Jan 2021 09:35:46 +0000 Subject: [PATCH 126/143] Additional test and minor fixes --- .../test.cpp | 48 +++++++++++-------- 1 file changed, 27 insertions(+), 21 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp index 2b3da91a522..05d0320e311 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_hms/test.cpp @@ -11,7 +11,7 @@ using namespace std; using namespace std::chrono; using hms_hours = hh_mm_ss; -using f_hours = duration>; +using f_hours = duration>; using f_hms_hours = hh_mm_ss; constexpr void am_pm() { @@ -112,26 +112,26 @@ constexpr void is_negative() { assert(hh_mm_ss(days{-1}).is_negative()); assert(!hh_mm_ss(days{1}).is_negative()); - assert(hh_mm_ss(-1h).is_negative()); - assert(!hh_mm_ss(1h).is_negative()); + assert(hh_mm_ss{-1h}.is_negative()); + assert(!hh_mm_ss{1h}.is_negative()); - assert(hh_mm_ss(-1min).is_negative()); - assert(!hh_mm_ss(1min).is_negative()); + assert(hh_mm_ss{-1min}.is_negative()); + assert(!hh_mm_ss{1min}.is_negative()); - assert(hh_mm_ss(-1s).is_negative()); - assert(!hh_mm_ss(1s).is_negative()); + assert(hh_mm_ss{-1s}.is_negative()); + assert(!hh_mm_ss{1s}.is_negative()); - assert(hh_mm_ss(-1ms).is_negative()); - assert(!hh_mm_ss(1ms).is_negative()); + assert(hh_mm_ss{-1ms}.is_negative()); + assert(!hh_mm_ss{1ms}.is_negative()); - assert(hh_mm_ss(-1us).is_negative()); - assert(!hh_mm_ss(1us).is_negative()); + assert(hh_mm_ss{-1us}.is_negative()); + assert(!hh_mm_ss{1us}.is_negative()); - assert(hh_mm_ss(-1ns).is_negative()); - assert(!hh_mm_ss(1ns).is_negative()); + assert(hh_mm_ss{-1ns}.is_negative()); + assert(!hh_mm_ss{1ns}.is_negative()); - assert(f_hms_hours(f_hours(-1.f)).is_negative()); - assert(!f_hms_hours(f_hours(1.f)).is_negative()); + assert(f_hms_hours{f_hours{-1.f}}.is_negative()); + assert(!f_hms_hours{f_hours{1.f}}.is_negative()); } constexpr auto ones = 1h + 1min + 1s + 1ms; @@ -144,7 +144,7 @@ constexpr void hour() { assert(hh_mm_ss(ones).hours() == 1h); assert(hh_mm_ss(-ones).hours() == 1h); assert(hh_mm_ss(59min).hours() == 0h); - assert(f_hms_hours(f_hours(1.f)).hours() == 1h); + assert(f_hms_hours{f_hours{1.f}}.hours() == 1h); } constexpr void mins() { @@ -154,7 +154,7 @@ constexpr void mins() { assert(hh_mm_ss(ones).minutes() == 1min); assert(hh_mm_ss(-ones).minutes() == 1min); assert(hh_mm_ss(59s).minutes() == 0min); - assert(f_hms_hours(f_hours(0.0166667f)).minutes() == 1min); + assert(f_hms_hours{f_hours{0.0166667f}}.minutes() == 1min); } constexpr void secs() { @@ -164,7 +164,7 @@ constexpr void secs() { assert(hh_mm_ss(ones).seconds() == 1s); assert(hh_mm_ss(-ones).seconds() == 1s); assert(hh_mm_ss(999ms).seconds() == 0s); - assert(f_hms_hours(f_hours(0.000277778f)).seconds() == 1s); + assert(f_hms_hours{f_hours{0.000277778f}}.seconds() == 1s); } constexpr void subsecs() { @@ -176,7 +176,7 @@ constexpr void subsecs() { assert(hh_mm_ss(999us).subseconds() == 999us); assert(hh_mm_ss(duration_cast(999us)).subseconds() == 0ms); using f_hms_milli = hh_mm_ss>; - assert(f_hms_milli(1ms).subseconds() == 1ms); + assert(f_hms_milli{1ms}.subseconds() == 1ms); } constexpr void to_duration() { @@ -190,13 +190,19 @@ constexpr void to_duration() { assert(hh_mm_ss(ones).to_duration() == ones); assert(hh_mm_ss(-ones).to_duration() == -ones); - assert(f_hms_hours(f_hours(1.f)).to_duration() == 1h); - assert(f_hms_hours(f_hours(-1.f)).to_duration() == -1h); + assert(f_hms_hours{f_hours{1.f}}.to_duration() == 1h); + assert(f_hms_hours{f_hours{-1.f}}.to_duration() == -1h); hh_mm_ss hms(50ms); milliseconds milli_val = static_cast(hms); static_assert(is_same_v); assert(hms.to_duration() == milli_val); + + f_hms_hours fhms{f_hours{1}}; + auto fhours_val = static_cast(fhms); + static_assert(is_same_v); + static_assert(is_same_v, f_precision>); + assert(fhms.to_duration() == fhours_val); } constexpr bool test() { From a5e8029a5ce442a2e4571ce6a08f8b13d37e5a9c Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 27 Jan 2021 00:54:04 -0800 Subject: [PATCH 127/143] Rename prev to previous. --- .../std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index dbe13999e40..88c7efef825 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -817,8 +817,8 @@ constexpr void year_month_weekday_test() { assert(ymwd == 2020y / April / Tuesday[2]); assert(static_cast(epoch) == sys_days{}); - const auto prev = 1970y / January / Thursday[0]; - assert(static_cast(prev) == (sys_days{} - days{7})); + const auto previous = 1970y / January / Thursday[0]; + assert(static_cast(previous) == (sys_days{} - days{7})); assert(static_cast(ymwd) == local_days{ymwd}); From f1b69e7144cf612ea8f7a3390967cfdb5b82f674 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 27 Jan 2021 01:12:04 -0800 Subject: [PATCH 128/143] Limit extreme loop iterations. --- .../std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 88c7efef825..e51e7d1a1f1 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -655,8 +655,8 @@ constexpr void year_month_day_test() { static_assert((2020y / 2 / 29).ok()); static_assert((2020y / 7 / 31).ok()); } else { - for (int iy = y_min; iy <= y_max; ++iy) { - for (auto um = 0u; um <= 255u; ++um) { + for (int iy = -3000; iy <= 3000; ++iy) { // instead of [y_min, y_max], to limit the number of iterations + for (auto um = 0u; um <= 13u; ++um) { // instead of [0, 255], to limit the number of iterations for (auto ud = 0u; ud <= 32u; ++ud) { const year y{iy}; const month m{um}; From 72b2583710bc2a77c4578cef849478a2aaf2dda9 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 27 Jan 2021 01:48:49 -0800 Subject: [PATCH 129/143] Verify that the "conventional syntax operators" are noexcept. --- .../test.cpp | 58 +++++++++++++++++++ 1 file changed, 58 insertions(+) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index e51e7d1a1f1..71e074bfc56 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -902,6 +902,63 @@ constexpr void year_month_weekday_last_test() { assert(ymwdl - years{2} == 2018y / January / Monday[last]); } +constexpr void operator_noexcept_test() { + constexpr year y{2021}; + constexpr int y_int{2021}; + constexpr month m{1}; + constexpr int m_int{1}; + constexpr day d{27}; + constexpr int d_int{27}; + constexpr weekday_indexed wdi{Wednesday[4]}; + constexpr weekday_last wdl{Wednesday[last]}; + constexpr year_month ym{y / m}; + constexpr month_day md{m / d}; + constexpr month_day_last mdl{m / last}; + constexpr month_weekday mwd{m / wdi}; + constexpr month_weekday_last mwdl{m / wdl}; + + static_assert(noexcept(y / m)); + static_assert(noexcept(y / m_int)); + static_assert(noexcept(m / d)); + static_assert(noexcept(m / d_int)); + static_assert(noexcept(m_int / d)); + static_assert(noexcept(d / m)); + static_assert(noexcept(d / m_int)); + static_assert(noexcept(m / last)); + static_assert(noexcept(m_int / last)); + static_assert(noexcept(last / m)); + static_assert(noexcept(last / m_int)); + static_assert(noexcept(m / wdi)); + static_assert(noexcept(m_int / wdi)); + static_assert(noexcept(wdi / m)); + static_assert(noexcept(wdi / m_int)); + static_assert(noexcept(m / wdl)); + static_assert(noexcept(m_int / wdl)); + static_assert(noexcept(wdl / m)); + static_assert(noexcept(wdl / m_int)); + static_assert(noexcept(ym / d)); + static_assert(noexcept(ym / d_int)); + static_assert(noexcept(y / md)); + static_assert(noexcept(y_int / md)); + static_assert(noexcept(md / y)); + static_assert(noexcept(md / y_int)); + static_assert(noexcept(ym / last)); + static_assert(noexcept(y / mdl)); + static_assert(noexcept(y_int / mdl)); + static_assert(noexcept(mdl / y)); + static_assert(noexcept(mdl / y_int)); + static_assert(noexcept(ym / wdi)); + static_assert(noexcept(y / mwd)); + static_assert(noexcept(y_int / mwd)); + static_assert(noexcept(mwd / y)); + static_assert(noexcept(mwd / y_int)); + static_assert(noexcept(ym / wdl)); + static_assert(noexcept(y / mwdl)); + static_assert(noexcept(y_int / mwdl)); + static_assert(noexcept(mwdl / y)); + static_assert(noexcept(mwdl / y_int)); +} + constexpr bool test() { day_test(); month_test(); @@ -918,6 +975,7 @@ constexpr bool test() { year_month_day_last_test(); year_month_weekday_test(); year_month_weekday_last_test(); + operator_noexcept_test(); return true; } From 7153098e1599b10b6b6564f5c49a3c049441c83d Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 27 Jan 2021 20:48:39 -0800 Subject: [PATCH 130/143] Adjust comment banner. --- stl/inc/chrono | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index d23cab1e1a6..67bca06002e 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -640,7 +640,7 @@ namespace chrono { }; #if _HAS_CXX20 - // SYS_TIME aliases + // sys_time ALIASES template using sys_time = time_point; using sys_seconds = sys_time; From c3e6047b809911c9aebeed7b405b673428e53791 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 27 Jan 2021 20:48:56 -0800 Subject: [PATCH 131/143] Drop unnecessary parentheses. --- stl/inc/chrono | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 67bca06002e..eb5779c54c1 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -836,7 +836,7 @@ namespace chrono { } constexpr month operator++(int) noexcept { month _Temp{*this}; - ++(*this); + ++*this; return _Temp; } constexpr month& operator--() noexcept { @@ -845,7 +845,7 @@ namespace chrono { } constexpr month operator--(int) noexcept { month _Temp{*this}; - --(*this); + --*this; return _Temp; } @@ -991,7 +991,7 @@ namespace chrono { } constexpr weekday operator++(int) noexcept { weekday _Temp{*this}; - ++(*this); + ++*this; return _Temp; } constexpr weekday& operator--() noexcept { @@ -999,7 +999,7 @@ namespace chrono { } constexpr weekday operator--(int) noexcept { weekday _Temp{*this}; - --(*this); + --*this; return _Temp; } From b0abcef2a5f2b26e3288f5322d8661d804f1500a Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 27 Jan 2021 20:58:09 -0800 Subject: [PATCH 132/143] Reported EDG bug; add workaround/no-workaround codepaths. --- stl/inc/chrono | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index eb5779c54c1..053746d3d2d 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -916,11 +916,19 @@ namespace chrono { } constexpr year& operator+=(const years& _Years) noexcept { - _Year = static_cast(_Year + _Years.count()); // TRANSITION, EDG bug not yet reported +#ifdef __EDG__ // TRANSITION, VSO-1271098 + _Year = static_cast(_Year + _Years.count()); +#else // ^^^ workaround / no workaround vvv + _Year += static_cast(_Years.count()); +#endif // ^^^ no workaround ^^^ return *this; } constexpr year& operator-=(const years& _Years) noexcept { - _Year = static_cast(_Year - _Years.count()); // TRANSITION, EDG bug not yet reported +#ifdef __EDG__ // TRANSITION, VSO-1271098 + _Year = static_cast(_Year - _Years.count()); +#else // ^^^ workaround / no workaround vvv + _Year -= static_cast(_Years.count()); +#endif // ^^^ no workaround ^^^ return *this; } From 7aa40d9e6fe4862891ea5e1891a263cba6d9bd57 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 27 Jan 2021 21:08:16 -0800 Subject: [PATCH 133/143] Mark unary plus and unary minus as _NODISCARD. --- stl/inc/chrono | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 053746d3d2d..d25106c5ef9 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -932,10 +932,10 @@ namespace chrono { return *this; } - constexpr year operator+() const noexcept { + _NODISCARD constexpr year operator+() const noexcept { return *this; } - constexpr year operator-() const noexcept { + _NODISCARD constexpr year operator-() const noexcept { return year{-_Year}; } From 7018ac06114b177faed00deb57386de236b277a5 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 27 Jan 2021 21:12:15 -0800 Subject: [PATCH 134/143] Don't need static_cast when widening short to int. --- stl/inc/chrono | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index d25106c5ef9..4d54c5bb275 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -944,7 +944,7 @@ namespace chrono { } _NODISCARD constexpr explicit operator int() const noexcept { - return static_cast(_Year); + return _Year; } _NODISCARD constexpr bool ok() const noexcept { From 14e72c2d5d433b89920a12ab3079f9a07ef545df Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 27 Jan 2021 21:22:24 -0800 Subject: [PATCH 135/143] Use forward declarations instead of elaborated-type-specifiers. --- stl/inc/chrono | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 4d54c5bb275..691faa258b9 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -984,6 +984,9 @@ namespace chrono { return years{static_cast(_Left) - static_cast(_Right)}; } + class weekday_indexed; + class weekday_last; + class weekday { public: weekday() = default; @@ -1024,8 +1027,8 @@ namespace chrono { return _Weekday <= 6; } - _NODISCARD constexpr class weekday_indexed operator[](unsigned int _Index) const noexcept; - _NODISCARD constexpr class weekday_last operator[](last_spec) const noexcept; + _NODISCARD constexpr weekday_indexed operator[](unsigned int _Index) const noexcept; + _NODISCARD constexpr weekday_last operator[](last_spec) const noexcept; private: unsigned char _Weekday; @@ -1330,12 +1333,14 @@ namespace chrono { : _Last_day_table[static_cast(_Month) - 1]; } + class year_month_day_last; + class year_month_day { public: year_month_day() = default; constexpr year_month_day(const year& _Year_, const month& _Month_, const day& _Day_) noexcept : _Year{_Year_}, _Month{_Month_}, _Day{_Day_} {} - constexpr year_month_day(const class year_month_day_last& _Ymdl) noexcept; + constexpr year_month_day(const year_month_day_last& _Ymdl) noexcept; constexpr year_month_day(const sys_days& _Sys_days) noexcept : year_month_day{_Civil_from_days(_Sys_days.time_since_epoch().count())} {} constexpr explicit year_month_day(const local_days& _Local_days) noexcept From c2aef5950494b9b9ea38bb86319a631a04a2eda4 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Wed, 27 Jan 2021 21:44:48 -0800 Subject: [PATCH 136/143] Drop comments for out-of-line definitions. --- stl/inc/chrono | 2 -- 1 file changed, 2 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 691faa258b9..723c260d0d7 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1114,7 +1114,6 @@ namespace chrono { return _Left.weekday() == _Right.weekday(); } - // weekday _NODISCARD constexpr weekday_indexed weekday::operator[](unsigned int _Index) const noexcept { return {*this, _Index}; } @@ -1568,7 +1567,6 @@ namespace chrono { return *this; } - // year_month_day constexpr year_month_day::year_month_day(const year_month_day_last& _Ymdl) noexcept : _Year{_Ymdl.year()}, _Month{_Ymdl.month()}, _Day{_Ymdl.day()} {} From 9a7e0d46ea8638be48bec3611dffb53ec4475d10 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Thu, 28 Jan 2021 15:06:45 -0800 Subject: [PATCH 137/143] Simplify month_day::ok's February logic. --- stl/inc/chrono | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 723c260d0d7..2e7b7c07650 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1139,8 +1139,8 @@ namespace chrono { const auto _Da = static_cast(_Day); const auto _Mo = static_cast(_Month); - if (_Mo == 2 && _Da > 29) { - return false; + if (_Mo == 2) { + return _Da <= 29; } if (_Mo == 4 || _Mo == 6 || _Mo == 9 || _Mo == 11) { From ec33fb0402f0a3cdd893318ae070565ffe2c5ac6 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Thu, 28 Jan 2021 15:26:35 -0800 Subject: [PATCH 138/143] Simplify _Last_day's February logic. --- stl/inc/chrono | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index 2e7b7c07650..b381d072feb 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1328,8 +1328,11 @@ namespace chrono { day{31}, day{28}, day{31}, day{30}, day{31}, day{30}, day{31}, day{31}, day{30}, day{31}, day{30}, day{31}}; _NODISCARD constexpr day _Last_day(const year& _Year, const month& _Month) { - return _Month == month{2} && _Year.is_leap() ? _Last_day_table[static_cast(_Month) - 1] + days{1} - : _Last_day_table[static_cast(_Month) - 1]; + if (_Month == month{2} && _Year.is_leap()) { + return day{29}; + } + + return _Last_day_table[static_cast(_Month) - 1]; } class year_month_day_last; From 876fb0715f13cb3d6a0d833f9fdf19de7b1ad416 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Thu, 28 Jan 2021 15:38:24 -0800 Subject: [PATCH 139/143] Construct temporary with braces. --- stl/inc/chrono | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index b381d072feb..a5c0693df36 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1398,7 +1398,7 @@ namespace chrono { const unsigned int _Mp = (5 * _Day_of_year + 2) / 153; // [0, 11] const unsigned int _Day = _Day_of_year - (153 * _Mp + 2) / 5 + 1; // [1, 31] const unsigned int _Month = _Mp + (_Mp < 10 ? 3 : static_cast(-9)); // [1, 12] - return year_month_day(_CHRONO year{_Year + (_Month <= 2)}, _CHRONO month{_Month}, _CHRONO day{_Day}); + return year_month_day{_CHRONO year{_Year + (_Month <= 2)}, _CHRONO month{_Month}, _CHRONO day{_Day}}; } // courtesy of Howard Hinnant // https://howardhinnant.github.io/date_algorithms.html#days_from_civil From efa0c70f88f0a2ab834d2cc3c596f45d559f70e9 Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Thu, 28 Jan 2021 15:43:58 -0800 Subject: [PATCH 140/143] Drop unnecessary parentheses around unary minus. --- stl/inc/chrono | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/stl/inc/chrono b/stl/inc/chrono index a5c0693df36..2791eb6a82b 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1445,7 +1445,7 @@ namespace chrono { } _NODISCARD constexpr year_month_day operator-(const year_month_day& _Left, const months& _Right) noexcept { - return _Left + (-_Right); + return _Left + -_Right; } _NODISCARD constexpr year_month_day operator+(const year_month_day& _Left, const years& _Right) noexcept { @@ -1457,7 +1457,7 @@ namespace chrono { } _NODISCARD constexpr year_month_day operator-(const year_month_day& _Left, const years& _Right) noexcept { - return _Left + (-_Right); + return _Left + -_Right; } constexpr year_month_day& year_month_day::operator+=(const months& _Months) noexcept { @@ -1540,7 +1540,7 @@ namespace chrono { _NODISCARD constexpr year_month_day_last operator-( const year_month_day_last& _Left, const months& _Right) noexcept { - return _Left + (-_Right); + return _Left + -_Right; } _NODISCARD constexpr year_month_day_last operator+(const year_month_day_last& _Left, const years& _Right) noexcept { @@ -1550,7 +1550,7 @@ namespace chrono { return _Right + _Left; } _NODISCARD constexpr year_month_day_last operator-(const year_month_day_last& _Left, const years& _Right) noexcept { - return _Left + (-_Right); + return _Left + -_Right; } constexpr year_month_day_last& year_month_day_last::operator+=(const months& _Months) noexcept { @@ -1657,7 +1657,7 @@ namespace chrono { } _NODISCARD constexpr year_month_weekday operator-(const year_month_weekday& _Left, const months& _Right) noexcept { - return _Left + (-_Right); + return _Left + -_Right; } _NODISCARD constexpr year_month_weekday operator+(const year_month_weekday& _Left, const years& _Right) noexcept { @@ -1668,7 +1668,7 @@ namespace chrono { } _NODISCARD constexpr year_month_weekday operator-(const year_month_weekday& _Left, const years& _Right) noexcept { - return _Left + (-_Right); + return _Left + -_Right; } constexpr year_month_weekday& year_month_weekday::operator+=(const months& _Months) noexcept { @@ -1748,7 +1748,7 @@ namespace chrono { _NODISCARD constexpr year_month_weekday_last operator-( const year_month_weekday_last& _Left, const months& _Right) noexcept { - return _Left + (-_Right); + return _Left + -_Right; } _NODISCARD constexpr year_month_weekday_last operator+( @@ -1762,7 +1762,7 @@ namespace chrono { _NODISCARD constexpr year_month_weekday_last operator-( const year_month_weekday_last& _Left, const years& _Right) noexcept { - return _Left + (-_Right); + return _Left + -_Right; } constexpr year_month_weekday_last& year_month_weekday_last::operator+=(const months& _Months) noexcept { From cc5f2596b485633badf9c80341388e1190be843c Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Thu, 28 Jan 2021 20:16:25 -0800 Subject: [PATCH 141/143] LWG-3260 "year_month* arithmetic rejects durations convertible to years" --- stl/inc/chrono | 35 +++++++++++ .../test.cpp | 61 +++++++++++++++++++ 2 files changed, 96 insertions(+) diff --git a/stl/inc/chrono b/stl/inc/chrono index 2791eb6a82b..7927b883277 100644 --- a/stl/inc/chrono +++ b/stl/inc/chrono @@ -1250,7 +1250,9 @@ namespace chrono { return _Month; } + template constexpr year_month& operator+=(const months& _Months) noexcept; + template constexpr year_month& operator-=(const months& _Months) noexcept; constexpr year_month& operator+=(const years& _Years) noexcept; constexpr year_month& operator-=(const years& _Years) noexcept; @@ -1276,15 +1278,18 @@ namespace chrono { return _Left.month() <=> _Right.month(); } + template _NODISCARD constexpr year_month operator+(const year_month& _Left, const months& _Right) noexcept { const auto _Mo = static_cast(static_cast(_Left.month())) + (_Right.count() - 1); const auto _Div = (_Mo >= 0 ? _Mo : _Mo - 11) / 12; return year_month{_Left.year() + years{_Div}, month{static_cast(_Mo - _Div * 12 + 1)}}; } + template _NODISCARD constexpr year_month operator+(const months& _Left, const year_month& _Right) noexcept { return _Right + _Left; } + template _NODISCARD constexpr year_month operator-(const year_month& _Left, const months& _Right) noexcept { return _Left + -_Right; } @@ -1307,10 +1312,12 @@ namespace chrono { return _Left + -_Right; } + template constexpr year_month& year_month::operator+=(const months& _Months) noexcept { *this = *this + _Months; return *this; } + template constexpr year_month& year_month::operator-=(const months& _Months) noexcept { *this = *this - _Months; return *this; @@ -1348,7 +1355,9 @@ namespace chrono { constexpr explicit year_month_day(const local_days& _Local_days) noexcept : year_month_day{_Civil_from_days(_Local_days.time_since_epoch().count())} {} + template constexpr year_month_day& operator+=(const months& _Months) noexcept; + template constexpr year_month_day& operator-=(const months& _Months) noexcept; constexpr year_month_day& operator+=(const years& _Years) noexcept; constexpr year_month_day& operator-=(const years& _Years) noexcept; @@ -1435,15 +1444,18 @@ namespace chrono { return _Left.day() <=> _Right.day(); } + template _NODISCARD constexpr year_month_day operator+(const year_month_day& _Left, const months& _Right) noexcept { const auto _Ym = year_month{_Left.year(), _Left.month()} + _Right; return {_Ym.year(), _Ym.month(), _Left.day()}; } + template _NODISCARD constexpr year_month_day operator+(const months& _Left, const year_month_day& _Right) noexcept { return _Right + _Left; } + template _NODISCARD constexpr year_month_day operator-(const year_month_day& _Left, const months& _Right) noexcept { return _Left + -_Right; } @@ -1460,10 +1472,12 @@ namespace chrono { return _Left + -_Right; } + template constexpr year_month_day& year_month_day::operator+=(const months& _Months) noexcept { *this = *this + _Months; return *this; } + template constexpr year_month_day& year_month_day::operator-=(const months& _Months) noexcept { *this = *this - _Months; return *this; @@ -1482,7 +1496,9 @@ namespace chrono { constexpr year_month_day_last(const year& _Year_, const month_day_last& _Mdl) noexcept : _Year{_Year_}, _Month_day_last{_Mdl} {} + template constexpr year_month_day_last& operator+=(const months& _Months) noexcept; + template constexpr year_month_day_last& operator-=(const months& _Months) noexcept; constexpr year_month_day_last& operator+=(const years& _Years) noexcept; constexpr year_month_day_last& operator-=(const years& _Years) noexcept; @@ -1528,16 +1544,19 @@ namespace chrono { return _Left.month_day_last() <=> _Right.month_day_last(); } + template _NODISCARD constexpr year_month_day_last operator+( const year_month_day_last& _Left, const months& _Right) noexcept { const auto _Ym = year_month{_Left.year(), _Left.month()} + _Right; return {_Ym.year(), month_day_last{_Ym.month()}}; } + template _NODISCARD constexpr year_month_day_last operator+( const months& _Left, const year_month_day_last& _Right) noexcept { return _Right + _Left; } + template _NODISCARD constexpr year_month_day_last operator-( const year_month_day_last& _Left, const months& _Right) noexcept { return _Left + -_Right; @@ -1553,10 +1572,12 @@ namespace chrono { return _Left + -_Right; } + template constexpr year_month_day_last& year_month_day_last::operator+=(const months& _Months) noexcept { *this = *this + _Months; return *this; } + template constexpr year_month_day_last& year_month_day_last::operator-=(const months& _Months) noexcept { *this = *this - _Months; return *this; @@ -1583,7 +1604,9 @@ namespace chrono { constexpr explicit year_month_weekday(const local_days& _Local_days) noexcept : year_month_weekday{_Ymwd_from_days(_Local_days.time_since_epoch())} {} + template constexpr year_month_weekday& operator+=(const months& _Months) noexcept; + template constexpr year_month_weekday& operator-=(const months& _Months) noexcept; constexpr year_month_weekday& operator+=(const years& _Years) noexcept; constexpr year_month_weekday& operator-=(const years& _Years) noexcept; @@ -1648,14 +1671,17 @@ namespace chrono { && _Left.weekday_indexed() == _Right.weekday_indexed(); } + template _NODISCARD constexpr year_month_weekday operator+(const year_month_weekday& _Left, const months& _Right) noexcept { const auto _Ym = year_month{_Left.year(), _Left.month()} + _Right; return {_Ym.year(), _Ym.month(), _Left.weekday_indexed()}; } + template _NODISCARD constexpr year_month_weekday operator+(const months& _Left, const year_month_weekday& _Right) noexcept { return _Right + _Left; } + template _NODISCARD constexpr year_month_weekday operator-(const year_month_weekday& _Left, const months& _Right) noexcept { return _Left + -_Right; } @@ -1671,10 +1697,12 @@ namespace chrono { return _Left + -_Right; } + template constexpr year_month_weekday& year_month_weekday::operator+=(const months& _Months) noexcept { *this = *this + _Months; return *this; } + template constexpr year_month_weekday& year_month_weekday::operator-=(const months& _Months) noexcept { *this = *this - _Months; return *this; @@ -1693,7 +1721,9 @@ namespace chrono { constexpr year_month_weekday_last(const year& _Year_, const month& _Month_, const weekday_last& _Wdl) noexcept : _Year{_Year_}, _Month{_Month_}, _Weekday_last{_Wdl} {} + template constexpr year_month_weekday_last& operator+=(const months& _Months) noexcept; + template constexpr year_month_weekday_last& operator-=(const months& _Months) noexcept; constexpr year_month_weekday_last& operator+=(const years& _Years) noexcept; constexpr year_month_weekday_last& operator-=(const years& _Years) noexcept; @@ -1736,16 +1766,19 @@ namespace chrono { && _Left.weekday_last() == _Right.weekday_last(); } + template _NODISCARD constexpr year_month_weekday_last operator+( const year_month_weekday_last& _Left, const months& _Right) noexcept { const auto _Ym = year_month{_Left.year(), _Left.month()} + _Right; return {_Ym.year(), _Ym.month(), _Left.weekday_last()}; } + template _NODISCARD constexpr year_month_weekday_last operator+( const months& _Left, const year_month_weekday_last& _Right) noexcept { return _Right + _Left; } + template _NODISCARD constexpr year_month_weekday_last operator-( const year_month_weekday_last& _Left, const months& _Right) noexcept { return _Left + -_Right; @@ -1765,10 +1798,12 @@ namespace chrono { return _Left + -_Right; } + template constexpr year_month_weekday_last& year_month_weekday_last::operator+=(const months& _Months) noexcept { *this = *this + _Months; return *this; } + template constexpr year_month_weekday_last& year_month_weekday_last::operator-=(const months& _Months) noexcept { *this = *this - _Months; return *this; diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index 71e074bfc56..b3bc9d3deb3 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -11,6 +11,9 @@ using namespace std::chrono; constexpr int y_min = -32767; constexpr int y_max = 32767; +// For testing LWG-3260 "year_month* arithmetic rejects durations convertible to years" +using Decades = duration, years::period>>; + constexpr void day_test() { day d{0u}; @@ -501,6 +504,13 @@ constexpr void year_month_test() { assert(ym.year() == 2020y); assert(ym.month() == January); + ym += Decades{2}; + assert(ym.year() == 2040y); + assert(ym.month() == January); + ym -= Decades{2}; + assert(ym.year() == 2020y); + assert(ym.month() == January); + assert(2020y / April == 2020y / April); assert(2019y / April < 2020y / April); assert(2020y / March < 2020y / April); @@ -518,6 +528,11 @@ constexpr void year_month_test() { assert(ym - years{2} == 2018y / January); + assert(ym + Decades{2} == 2040y / January); + assert(Decades{2} + ym == 2040y / January); + + assert(ym - Decades{2} == 2000y / January); + if (is_constant_evaluated()) { static_assert((2020y / 1).ok()); static_assert(!(2020y / 13).ok()); @@ -611,6 +626,16 @@ constexpr void year_month_day_test() { assert(ymd1.month() == January); assert(ymd1.day() == 1d); + ymd1 += Decades{2}; + assert(ymd1.year() == 2040y); + assert(ymd1.month() == January); + assert(ymd1.day() == 1d); + + ymd1 -= Decades{2}; + assert(ymd1.year() == 2020y); + assert(ymd1.month() == January); + assert(ymd1.day() == 1d); + assert(2020y / April / 6d == sys_days{days{18'358}}); assert(sys_days{2017y / January / 0} == 2016y / December / 31); assert(sys_days{2017y / January / 31} == 2017y / January / 31); @@ -639,6 +664,11 @@ constexpr void year_month_day_test() { assert(2020y / January / 1d - years{2} == 2018y / January / 1d); + assert(2020y / January / 1d + Decades{2} == 2040y / January / 1d); + assert(Decades{2} + 2020y / January / 1d == 2040y / January / 1d); + + assert(2020y / January / 1d - Decades{2} == 2000y / January / 1d); + if (is_constant_evaluated()) { static_assert(!(-32768y / 1 / 1).ok()); static_assert(!(32768y / 1 / 1).ok()); @@ -721,6 +751,12 @@ constexpr void year_month_day_last_test() { ymdl -= years{2}; assert(ymdl == 2020y / February / 29d); + ymdl += Decades{2}; + assert(ymdl == 2040y / February / 29d); + + ymdl -= Decades{2}; + assert(ymdl == 2020y / February / 29d); + assert(2020y / April / last == sys_days{days{18'382}}); assert(static_cast(ymdl) == local_days{ymdl}); @@ -739,6 +775,11 @@ constexpr void year_month_day_last_test() { assert(ymdl - years{2} == 2018y / February / last); + assert(ymdl + Decades{2} == 2040y / February / last); + assert(Decades{2} + ymdl == 2040y / February / last); + + assert(ymdl - Decades{2} == 2000y / February / last); + if (is_constant_evaluated()) { static_assert((2020y / 1 / last).ok()); static_assert(!(2020y / 13 / last).ok()); @@ -816,6 +857,11 @@ constexpr void year_month_weekday_test() { ymwd -= years{2}; assert(ymwd == 2020y / April / Tuesday[2]); + ymwd += Decades{2}; + assert(ymwd == 2040y / April / Tuesday[2]); + ymwd -= Decades{2}; + assert(ymwd == 2020y / April / Tuesday[2]); + assert(static_cast(epoch) == sys_days{}); const auto previous = 1970y / January / Thursday[0]; assert(static_cast(previous) == (sys_days{} - days{7})); @@ -836,6 +882,11 @@ constexpr void year_month_weekday_test() { assert(years{2} + ymwd == 2022y / April / Tuesday[2]); assert(ymwd - years{2} == 2018y / April / Tuesday[2]); + + assert(ymwd + Decades{2} == 2040y / April / Tuesday[2]); + assert(Decades{2} + ymwd == 2040y / April / Tuesday[2]); + + assert(ymwd - Decades{2} == 2000y / April / Tuesday[2]); } constexpr void year_month_weekday_last_test() { @@ -883,6 +934,11 @@ constexpr void year_month_weekday_last_test() { ymwdl -= years{2}; assert(ymwdl == 2020y / January / Monday[last]); + ymwdl += Decades{2}; + assert(ymwdl == 2040y / January / Monday[last]); + ymwdl -= Decades{2}; + assert(ymwdl == 2020y / January / Monday[last]); + assert(static_cast(ymwdl) == sys_days{days{18'288}}); assert(static_cast(ymwdl) == local_days{ymwdl}); @@ -900,6 +956,11 @@ constexpr void year_month_weekday_last_test() { assert(years{2} + ymwdl == 2022y / January / Monday[last]); assert(ymwdl - years{2} == 2018y / January / Monday[last]); + + assert(ymwdl + Decades{2} == 2040y / January / Monday[last]); + assert(Decades{2} + ymwdl == 2040y / January / Monday[last]); + + assert(ymwdl - Decades{2} == 2000y / January / Monday[last]); } constexpr void operator_noexcept_test() { From dff59234e30fc7f078adf3aaffea0921ef8abc9a Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Thu, 28 Jan 2021 21:25:05 -0800 Subject: [PATCH 142/143] Work around Standard Library Header Units ICE. --- .../tests/P1502R1_standard_library_header_units/test.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tests/std/tests/P1502R1_standard_library_header_units/test.cpp b/tests/std/tests/P1502R1_standard_library_header_units/test.cpp index d660f96e77b..1fa579ad294 100644 --- a/tests/std/tests/P1502R1_standard_library_header_units/test.cpp +++ b/tests/std/tests/P1502R1_standard_library_header_units/test.cpp @@ -324,9 +324,13 @@ int main() { puts("Testing ."); promise p{}; future f{p.get_future()}; +#if 0 // TRANSITION, VSO-1271718 (Standard Library Header Units ICE with C++20 chrono) assert(f.wait_for(chrono::seconds{0}) == future_status::timeout); +#endif // ^^^ no workaround ^^^ p.set_value(1729); +#if 0 // TRANSITION, VSO-1271718 (Standard Library Header Units ICE with C++20 chrono) assert(f.wait_for(chrono::seconds{0}) == future_status::ready); +#endif // ^^^ no workaround ^^^ assert(f.get() == 1729); } @@ -756,7 +760,9 @@ int main() { } l.count_down(); // tell main() that we're done while (!token.stop_requested()) { +#if 0 // TRANSITION, VSO-1271718 (Standard Library Header Units ICE with C++20 chrono) this_thread::sleep_for(10ms); // not a timing assumption; avoids spinning furiously +#endif // ^^^ no workaround ^^^ } vec.push_back(-1000); // indicate that token.stop_requested() returned true }}; From 44985989d2365e8957687ac4bbd6dd65ff5c526a Mon Sep 17 00:00:00 2001 From: "Stephan T. Lavavej" Date: Thu, 28 Jan 2021 21:26:33 -0800 Subject: [PATCH 143/143] Revert "Verify that the "conventional syntax operators" are noexcept." This reverts commit 72b2583710bc2a77c4578cef849478a2aaf2dda9. Already tested by P0355R7_calendars_and_time_zones_dates_literals. --- .../test.cpp | 58 ------------------- 1 file changed, 58 deletions(-) diff --git a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp index b3bc9d3deb3..90d6d7ad946 100644 --- a/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp +++ b/tests/std/tests/P0355R7_calendars_and_time_zones_dates/test.cpp @@ -963,63 +963,6 @@ constexpr void year_month_weekday_last_test() { assert(ymwdl - Decades{2} == 2000y / January / Monday[last]); } -constexpr void operator_noexcept_test() { - constexpr year y{2021}; - constexpr int y_int{2021}; - constexpr month m{1}; - constexpr int m_int{1}; - constexpr day d{27}; - constexpr int d_int{27}; - constexpr weekday_indexed wdi{Wednesday[4]}; - constexpr weekday_last wdl{Wednesday[last]}; - constexpr year_month ym{y / m}; - constexpr month_day md{m / d}; - constexpr month_day_last mdl{m / last}; - constexpr month_weekday mwd{m / wdi}; - constexpr month_weekday_last mwdl{m / wdl}; - - static_assert(noexcept(y / m)); - static_assert(noexcept(y / m_int)); - static_assert(noexcept(m / d)); - static_assert(noexcept(m / d_int)); - static_assert(noexcept(m_int / d)); - static_assert(noexcept(d / m)); - static_assert(noexcept(d / m_int)); - static_assert(noexcept(m / last)); - static_assert(noexcept(m_int / last)); - static_assert(noexcept(last / m)); - static_assert(noexcept(last / m_int)); - static_assert(noexcept(m / wdi)); - static_assert(noexcept(m_int / wdi)); - static_assert(noexcept(wdi / m)); - static_assert(noexcept(wdi / m_int)); - static_assert(noexcept(m / wdl)); - static_assert(noexcept(m_int / wdl)); - static_assert(noexcept(wdl / m)); - static_assert(noexcept(wdl / m_int)); - static_assert(noexcept(ym / d)); - static_assert(noexcept(ym / d_int)); - static_assert(noexcept(y / md)); - static_assert(noexcept(y_int / md)); - static_assert(noexcept(md / y)); - static_assert(noexcept(md / y_int)); - static_assert(noexcept(ym / last)); - static_assert(noexcept(y / mdl)); - static_assert(noexcept(y_int / mdl)); - static_assert(noexcept(mdl / y)); - static_assert(noexcept(mdl / y_int)); - static_assert(noexcept(ym / wdi)); - static_assert(noexcept(y / mwd)); - static_assert(noexcept(y_int / mwd)); - static_assert(noexcept(mwd / y)); - static_assert(noexcept(mwd / y_int)); - static_assert(noexcept(ym / wdl)); - static_assert(noexcept(y / mwdl)); - static_assert(noexcept(y_int / mwdl)); - static_assert(noexcept(mwdl / y)); - static_assert(noexcept(mwdl / y_int)); -} - constexpr bool test() { day_test(); month_test(); @@ -1036,7 +979,6 @@ constexpr bool test() { year_month_day_last_test(); year_month_weekday_test(); year_month_weekday_last_test(); - operator_noexcept_test(); return true; }