Changelog

• xlocale, xlocinfo.h
  • Remove _XB and _XS. They were zero, so they served no useful purpose.
  • Move the remaining "ctype code bits" macros from xlocinfo.h to their only usage in xlocale, then immediately #undef them. These macros are extremely short, making them unusually polluting.
• xstddef
  • Remove _CLASS_DEFINE_CONST, which was unused after constexpr INVOKE and related utilities #703.
• ymath.h, src/xmath.hpp
  • Move the "_Feraise argument" macros from ymath.h (where they're visible to users via complex) to src/xmath.hpp (as they're used in separately compiled files only).
• src/xferaise.cpp
  • Include xmath.hpp to get those macros. (This was the only file not already including xmath.hpp, and it drags in the previously included headers.)
• functional
  • Remove the workaround for VSO-1132105 which was resolved as fixed.
  • MS-internal testing passed for x86/x64 stl vcr compiler, so it appears that we don't need to retain this workaround for CUDA.
• deque
  • Call emplace_front (which orphans) and _Emplace_back_internal (which doesn't orphan) in a centralized manner. Note that push_back already behaved like this.
  • Now that they're used exactly once, expand the _PUSH_FRONT_BEGIN etc. macros (deleting unnecessary semicolons). No logic changes.
  • Add missing braces.
  • Replace the macro _DEQUEMAPSIZ with static constexpr int _Minimum_map_size, private within deque.
  • Change the extremely verbose macro _DEQUESIZ to be a static constexpr int in _Deque_val, and rename it to _Block_size now that it's not a macro.
• complex
  • Comment why the _C_COMPLEX_T guard is necessary.
• filesystem
  • Change example paths in comments to use cat, dog, elk elements, consistent with tests/std/tests/P0218R1_filesystem/test.cpp. (This isn't strictly required by our policies, but it avoids potential headaches. I also believe that the animals are more readable - they're in alphabetical order and differ in their first letter, unlike the extremely similar bar / baz.)
  • _File_time_clock uses the same 100 nanosecond period as system_clock; simply use that type. (It's not going to change unexpectedly, due to ABI.)
• chrono, xtimec.h
  • Directly express system_clock::period, removing the last use of _XTIME_NSECS_PER_TICK. Comment that this is 100 nanoseconds.
  • ratio denominators default to 1; taking advantage of this slightly improves clarity.
  • Logic change that should preserve semantics: previously, we were dividing (with truncation) and multiplying by _XTIME_TICKS_PER_TIME_T which was 10000000LL. That value, 10,000,000, is how many 100ns ticks occur in 1s (which is the period for time_t). We can and should use the chrono / ratio type system for this.
    • to_time_t takes a 100ns time_point _Time. _Time.time_since_epoch() gives us a 100ns duration. Previously, we extracted a raw integer with .count(), truncate-divided by _XTIME_TICKS_PER_TIME_T to get a raw integer of whole seconds, and then redundantly cast to __time64_t. (That's the same as our rep, long long.) Now, we can use duration_cast<seconds> to perform the truncating conversion. Then we can extract and return .count(). (seconds is also represented by long long.)
    • from_time_t takes __time64_t _Tm, a raw integer of whole seconds. We previously multiplied by _XTIME_TICKS_PER_TIME_T to get a raw integer of 100ns ticks, then invoked the explicit constructors for our duration and time_point. Now, it's simpler to explicitly construct seconds{_Tm} (again, same long long representation), which encodes in the type system what we know about _Tm's meaning. Then, we can implicitly convert to our duration while explicitly constructing our time_point. (The duration conversion is implicit and safe because converting from whole seconds to fine-grained 100ns ticks is information-preserving. Yay chrono design!)
    • Note that this eliminates redundancy - all of the math is centralized in ratio_multiply<ratio<100>, nano> and we don't need to write down the inverse value _XTIME_TICKS_PER_TIME_T.

Test Coverage

This tests to_time_t's truncating behavior, which is the "hard" part:

This tests from_time_t's behavior:

Therefore, I believe that existing test coverage is sufficient. Just in case, I tested this manually:

Manual Testing

C:\Temp>type meow.cpp

#include <chrono>
#include <iostream>
using namespace std;
using namespace std::chrono;

int main() {
    cout << "_MSVC_STL_UPDATE: " << _MSVC_STL_UPDATE << endl;
    constexpr system_clock::time_point now{system_clock::duration{16004804410890516ll}};
    const auto value = system_clock::to_time_t(now);
    cout << "time_t: " << value << endl;
    const auto round_trip = system_clock::from_time_t(value);
    cout << nanoseconds{now - round_trip}.count() << " ns difference" << endl;
}

VS 2019 16.8 Preview 3:

C:\Temp>cl /EHsc /nologo /W4 /MTd meow.cpp && meow
meow.cpp
_MSVC_STL_UPDATE: 202008
time_t: 1600480441
89051600 ns difference

This PR:

C:\Temp>cl /EHsc /nologo /W4 /MTd meow.cpp && meow
meow.cpp
_MSVC_STL_UPDATE: 202009
time_t: 1600480441
89051600 ns difference