Cite N4950 in headers and source files (#3686)

Towards #182.

- This PR drops all section numbers except for D.x in `<yvals_core.h>`. I decided to cite WG21-N4868 for C++20 deprecation.
- Some citations in `<format>` are intentionally not updated because WG21-P2675R1 and LWG-3631 are not implemented yet.
- Citations in test files are not updated, but I think I'll do it soon.
- Drive-by change: a comment for `move_only_function`'s move assignment operator explaining why it's `noexcept(false)` (see #3565 (comment) and #2278 (comment)).

---------

Co-authored-by: Stephan T. Lavavej <[email protected]>
Co-authored-by: Nicole Mazzuca <[email protected]>
Co-authored-by: Casey Carter <[email protected]>

Author: 4 people

stl/inc/__msvc_chrono.hpp

@@ -196,7 +196,7 @@ namespace chrono {
         using period   = typename _Duration::period;
 
         static_assert(_Is_duration_v<_Duration>,
-            "N4885 [time.point.general]/1 mandates Duration to be a specialization of chrono::duration.");
+            "N4950 [time.point.general]/1 mandates Duration to be a specialization of chrono::duration.");
 
         constexpr time_point() = default;
 

stl/inc/algorithm

@@ -5454,7 +5454,7 @@ _EXPORT_STD template <class _FwdIt>
 constexpr _FwdIt shift_left(_FwdIt _First, const _FwdIt _Last, _Iter_diff_t<_FwdIt> _Pos_to_shift) {
     // shift [_First, _Last) left by _Pos_to_shift
     // positions; returns the end of the resulting range
-    _STL_ASSERT(_Pos_to_shift >= 0, "shift count must be non-negative (N4910 [alg.shift]/1)");
+    _STL_ASSERT(_Pos_to_shift >= 0, "shift count must be non-negative (N4950 [alg.shift]/1)");
 
     _Adl_verify_range(_First, _Last);
 
@@ -5495,7 +5495,7 @@ _EXPORT_STD template <class _FwdIt>
 constexpr _FwdIt shift_right(_FwdIt _First, const _FwdIt _Last, _Iter_diff_t<_FwdIt> _Pos_to_shift) {
     // shift [_First, _Last) right by _Pos_to_shift
     // positions; returns the beginning of the resulting range
-    _STL_ASSERT(_Pos_to_shift >= 0, "shift count must be non-negative (N4910 [alg.shift]/5)");
+    _STL_ASSERT(_Pos_to_shift >= 0, "shift count must be non-negative (N4950 [alg.shift]/5)");
 
     _Adl_verify_range(_First, _Last);
 
@@ -5581,7 +5581,7 @@ namespace ranges {
 
         template <permutable _It, sentinel_for<_It> _Se>
         constexpr subrange<_It> operator()(_It _First, const _Se _Last, iter_difference_t<_It> _Pos_to_shift) const {
-            _STL_ASSERT(_Pos_to_shift >= 0, "shift count must be non-negative (N4910 [alg.shift]/1)");
+            _STL_ASSERT(_Pos_to_shift >= 0, "shift count must be non-negative (N4950 [alg.shift]/1)");
 
             _Adl_verify_range(_First, _Last);
             auto _Result = _First;
@@ -5599,7 +5599,7 @@ namespace ranges {
         template <forward_range _Rng>
             requires permutable<iterator_t<_Rng>>
         constexpr borrowed_subrange_t<_Rng> operator()(_Rng&& _Range, range_difference_t<_Rng> _Pos_to_shift) const {
-            _STL_ASSERT(_Pos_to_shift >= 0, "shift count must be non-negative (N4910 [alg.shift]/1)");
+            _STL_ASSERT(_Pos_to_shift >= 0, "shift count must be non-negative (N4950 [alg.shift]/1)");
 
             if (_Pos_to_shift == 0) {
                 auto _Last = _Rewrap_iterator(_Range, _Get_final_iterator_unwrapped(_Range));
@@ -5703,7 +5703,7 @@ namespace ranges {
             _It _First, _Se _Last, iter_difference_t<_It> _Pos_to_shift, const _SizeTy _Size) {
             _STL_INTERNAL_STATIC_ASSERT(permutable<_It>);
             _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
-            _STL_ASSERT(_Pos_to_shift >= 0, "shift count must be non-negative (N4910 [alg.shift]/5)");
+            _STL_ASSERT(_Pos_to_shift >= 0, "shift count must be non-negative (N4950 [alg.shift]/5)");
 
             if (_Pos_to_shift == 0) {
                 return {_First, _RANGES next(_First, _Last)};
@@ -10061,7 +10061,7 @@ namespace ranges {
             const auto _First = _Range.begin();
             const auto _Last  = _Range.end();
             _STL_ASSERT(_First != _Last,
-                "An initializer_list passed to std::ranges::minmax must not be empty. (N4928 [alg.min.max]/21)");
+                "An initializer_list passed to std::ranges::minmax must not be empty. (N4950 [alg.min.max]/21)");
             return _Minmax_fwd_unchecked(_First, _Last, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
         }
 
@@ -10073,13 +10073,13 @@ namespace ranges {
             auto _UFirst = _RANGES _Ubegin(_Range);
             auto _ULast  = _RANGES _Uend(_Range);
             _STL_ASSERT(
-                _UFirst != _ULast, "A range passed to std::ranges::minmax must not be empty. (N4928 [alg.min.max]/21)");
+                _UFirst != _ULast, "A range passed to std::ranges::minmax must not be empty. (N4950 [alg.min.max]/21)");
             if constexpr (forward_range<_Rng> && _Prefer_iterator_copies<iterator_t<_Rng>>) {
                 return _Minmax_fwd_unchecked(
                     _STD move(_UFirst), _STD move(_ULast), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
             } else {
                 using _Vty = range_value_t<_Rng>;
-                // This initialization is correct, similar to the N4928 [dcl.init.aggr]/6 example
+                // This initialization is correct, similar to the N4950 [dcl.init.aggr]/6 example
                 minmax_result<_Vty> _Found = {static_cast<_Vty>(*_UFirst), _Found.min};
                 if (_UFirst == _ULast) {
                     return _Found;
@@ -10147,7 +10147,7 @@ namespace ranges {
 
             auto _Found_min = _First;
             if (++_First == _Last) {
-                // This initialization is correct, similar to the N4928 [dcl.init.aggr]/6 example
+                // This initialization is correct, similar to the N4950 [dcl.init.aggr]/6 example
                 minmax_result<_Vty> _Result = {static_cast<_Vty>(*_Found_min), _Result.min};
                 return _Result;
             }
@@ -10568,7 +10568,7 @@ namespace ranges {
             const _Ty& _Val, const _Ty& _Lo, const _Ty& _Hi, _Pr _Pred = {}, _Pj _Proj = {}) const {
             _STL_ASSERT(!_STD invoke(_Pred, _STD invoke(_Proj, _Hi), _STD invoke(_Proj, _Lo)),
                 "The lower bound cannot be greater than the upper bound in a call to std::ranges::clamp "
-                "(N4861 [alg.clamp]/2).");
+                "(N4950 [alg.clamp]/2).");
 
             auto&& _Temp = _STD invoke(_Proj, _Val);
             if (_STD invoke(_Pred, _STD forward<decltype(_Temp)>(_Temp), _STD invoke(_Proj, _Lo))) {

stl/inc/array

@@ -580,9 +580,8 @@ public:
 #if _HAS_CXX17
 template <class _First, class... _Rest>
 struct _Enforce_same {
-    static_assert(conjunction_v<is_same<_First, _Rest>...>,
-        "N4687 26.3.7.2 [array.cons]/2: "
-        "Requires: (is_same_v<T, U> && ...) is true. Otherwise the program is ill-formed.");
+    static_assert(
+        conjunction_v<is_same<_First, _Rest>...>, "N4950 [array.cons]/2: Mandates: (is_same_v<T, U> && ...) is true.");
     using type = _First;
 };
 
@@ -830,18 +829,18 @@ _NODISCARD constexpr array<remove_cv_t<_Ty>, _Size> _To_array_rvalue_impl(
 
 _EXPORT_STD template <class _Ty, size_t _Size>
 _NODISCARD constexpr array<remove_cv_t<_Ty>, _Size> to_array(_Ty (&_Array)[_Size]) {
-    static_assert(!is_array_v<_Ty>, "N4830 [array.creation]/1: "
+    static_assert(!is_array_v<_Ty>, "N4950 [array.creation]/1: "
                                     "to_array does not accept multidimensional arrays.");
-    static_assert(is_constructible_v<_Ty, _Ty&>, "N4830 [array.creation]/1: "
+    static_assert(is_constructible_v<_Ty, _Ty&>, "N4950 [array.creation]/1: "
                                                  "to_array requires copy constructible elements.");
     return _To_array_lvalue_impl(_Array, make_index_sequence<_Size>{});
 }
 
 _EXPORT_STD template <class _Ty, size_t _Size>
 _NODISCARD constexpr array<remove_cv_t<_Ty>, _Size> to_array(_Ty (&&_Array)[_Size]) {
-    static_assert(!is_array_v<_Ty>, "N4830 [array.creation]/4: "
+    static_assert(!is_array_v<_Ty>, "N4950 [array.creation]/4: "
                                     "to_array does not accept multidimensional arrays.");
-    static_assert(is_move_constructible_v<_Ty>, "N4830 [array.creation]/4: "
+    static_assert(is_move_constructible_v<_Ty>, "N4950 [array.creation]/4: "
                                                 "to_array requires move constructible elements.");
     return _To_array_rvalue_impl(_STD move(_Array), make_index_sequence<_Size>{});
 }

stl/inc/barrier

@@ -74,15 +74,15 @@ public:
         is_function_v<remove_pointer_t<_Completion_function>> ||
 #endif // __cpp_noexcept_function_type
             is_nothrow_invocable_v<_Completion_function&>,
-        "N4861 [thread.barrier.class]/5: is_nothrow_invocable_v<CompletionFunction&> shall be true");
+        "N4950 [thread.barrier.class]/5: is_nothrow_invocable_v<CompletionFunction&> shall be true");
 
     using arrival_token = _Arrival_token<_Completion_function>;
 
     constexpr explicit barrier(
         const ptrdiff_t _Expected, _Completion_function _Fn = _Completion_function()) noexcept /* strengthened */
         : _Val(_One_then_variadic_args_t{}, _STD move(_Fn), _Expected << _Barrier_value_shift) {
         _STL_VERIFY(_Val._Myval2._Current.load(memory_order_relaxed) >= 0,
-            "Precondition: expected >= 0 and expected <= max() (N4861 [thread.barrier.class]/9)");
+            "Precondition: expected >= 0 and expected <= max() (N4950 [thread.barrier.class]/9)");
     }
 
     barrier(const barrier&)            = delete;
@@ -95,11 +95,11 @@ public:
     _NODISCARD_BARRIER_TOKEN arrival_token arrive(ptrdiff_t _Update = 1) noexcept /* strengthened */ {
         // Shifting before precondition check, so that exceeding max() will trigger precondition check too
         _Update <<= _Barrier_value_shift;
-        _STL_VERIFY(_Update > 0, "Precondition: update > 0 (N4861 [thread.barrier.class]/12)");
+        _STL_VERIFY(_Update > 0, "Precondition: update > 0 (N4950 [thread.barrier.class]/12)");
         // TRANSITION, GH-1133: should be memory_order_release
         ptrdiff_t _Current = _Val._Myval2._Current.fetch_sub(_Update) - _Update;
         _STL_VERIFY(_Current >= 0, "Precondition: update is less than or equal to the expected count "
-                                   "for the current barrier phase (N4861 [thread.barrier.class]/12)");
+                                   "for the current barrier phase (N4950 [thread.barrier.class]/12)");
         if ((_Current & _Barrier_value_mask) == 0) {
             // TRANSITION, GH-1133: should have this fence:
             // atomic_thread_fence(memory_order_acquire);
@@ -114,14 +114,14 @@ public:
     void wait(arrival_token&& _Arrival) const noexcept /* strengthened */ {
         _STL_VERIFY((_Arrival._Value & _Barrier_value_mask) == reinterpret_cast<intptr_t>(this),
             "Preconditions: arrival is associated with the phase synchronization point for the current phase "
-            "or the immediately preceding phase of the same barrier object (N4861 [thread.barrier.class]/19)");
+            "or the immediately preceding phase of the same barrier object (N4950 [thread.barrier.class]/19)");
         const ptrdiff_t _Arrival_value = _Arrival._Value & _Barrier_arrival_token_mask;
         _Arrival._Value                = _Barrier_invalid_token;
         for (;;) {
             // TRANSITION, GH-1133: should be memory_order_acquire
             const ptrdiff_t _Current = _Val._Myval2._Current.load();
             _STL_VERIFY(_Current >= 0, "Invariant counter >= 0, possibly caused by preconditions violation "
-                                       "(N4861 [thread.barrier.class]/12)");
+                                       "(N4950 [thread.barrier.class]/12)");
             if ((_Current & _Barrier_arrival_token_mask) != _Arrival_value) {
                 break;
             }
@@ -134,7 +134,7 @@ public:
         ptrdiff_t _Current       = _Val._Myval2._Current.fetch_sub(_Barrier_value_step) - _Barrier_value_step;
         const ptrdiff_t _Arrival = _Current & _Barrier_arrival_token_mask;
         _STL_VERIFY(_Current >= 0, "Precondition: update is less than or equal to the expected count "
-                                   "for the current barrier phase (N4861 [thread.barrier.class]/12)");
+                                   "for the current barrier phase (N4950 [thread.barrier.class]/12)");
         if ((_Current & _Barrier_value_mask) == 0) {
             _Completion(_Current);
             return;
@@ -145,7 +145,7 @@ public:
             // TRANSITION, GH-1133: should be memory_order_acquire
             _Current = _Val._Myval2._Current.load();
             _STL_VERIFY(_Current >= 0, "Invariant counter >= 0, possibly caused by preconditions violation "
-                                       "(N4861 [thread.barrier.class]/12)");
+                                       "(N4950 [thread.barrier.class]/12)");
             if ((_Current & _Barrier_arrival_token_mask) != _Arrival) {
                 break;
             }
@@ -156,7 +156,7 @@ public:
         const ptrdiff_t _Rem_count =
             _Val._Myval2._Total.fetch_sub(_Barrier_value_step, memory_order_relaxed) - _Barrier_value_step;
         _STL_VERIFY(_Rem_count >= 0, "Precondition: The expected count for the current barrier phase "
-                                     "is greater than zero (N4861 [thread.barrier.class]/24) "
+                                     "is greater than zero (N4950 [thread.barrier.class]/24) "
                                      "(checked initial expected count, which is not less than the current)");
         (void) arrive(1);
     }
@@ -166,7 +166,7 @@ private:
         const ptrdiff_t _Rem_count = _Val._Myval2._Total.load(memory_order_relaxed);
         _STL_VERIFY(_Rem_count >= 0, "Invariant: initial expected count less than zero, "
                                      "possibly caused by preconditions violation "
-                                     "(N4861 [thread.barrier.class]/24)");
+                                     "(N4950 [thread.barrier.class]/24)");
         _Val._Get_first()();
         const ptrdiff_t _New_phase_count = _Rem_count | ((_Current + 1) & _Barrier_arrival_token_mask);
         // TRANSITION, GH-1133: should be memory_order_release

stl/inc/bit

@@ -99,12 +99,12 @@ _NODISCARD constexpr _Ty bit_ceil(const _Ty _Val) noexcept /* strengthened */ {
 
     if constexpr (sizeof(_Ty) < sizeof(unsigned int)) { // for types subject to integral promotion
         if (_STD is_constant_evaluated()) {
-            // Because N4892 [expr.shift]/1 "integral promotions are performed"
+            // Because N4950 [expr.shift]/1 "integral promotions are performed"
             // the compiler will not generate a compile time error for
             // uint8_t{1} << 8
             // or
             // uint16_t{1} << 16
-            // so we must manually enforce N4892 [bit.pow.two]/5, 8:
+            // so we must manually enforce N4950 [bit.pow.two]/5, 8:
             // "Preconditions: N is representable as a value of type T."
             // "Remarks: A function call expression that violates the precondition in the Preconditions: element
             // is not a core constant expression (7.7)."

stl/inc/charconv

@@ -304,7 +304,7 @@ _NODISCARD _CONSTEXPR23 from_chars_result _Integer_from_chars(
         }
     }
 
-    _Raw_value = static_cast<_RawTy>(_Value); // implementation-defined for negative, N4713 7.8 [conv.integral]/3
+    _Raw_value = static_cast<_RawTy>(_Value); // congruent to _Value modulo 2^N for negative, N4950 [conv.integral]/3
 
     return {_Next, errc{}};
 }
@@ -369,24 +369,27 @@ _EXPORT_STD _CONSTEXPR23 from_chars_result from_chars(const char* const _First,
 // array is not necessary: all operations on the _Big_integer_flt type are carefully written to only access elements at
 // indices [0, _Myused), and all operations correctly update _Myused as the utilized size increases.
 
-// _Big_integer_flt _Xval{}; is direct-list-initialization (N4750 11.6.4 [dcl.init.list]/1).
-// N4750 11.6.4 [dcl.init.list]/3.5:
+// _Big_integer_flt _Xval{}; is direct-list-initialization (N4950 [dcl.init.list]/1).
+// N4950 [dcl.init.list]/3.5:
 // "Otherwise, if the initializer list has no elements and T is a class type with a default constructor,
 // the object is value-initialized."
-// N4750 11.6 [dcl.init]/8, /8.1:
+// N4950 [dcl.init.general]/9, /9.1, /9.1.1:
 // "To value-initialize an object of type T means:
-// - if T is a (possibly cv-qualified) class type (Clause 12) with either no default constructor (15.1)
-// or a default constructor that is user-provided or deleted, then the object is default-initialized;"
-// N4750 11.6 [dcl.init]/7, /7.1:
+// - if T is a (possibly cv-qualified) class type ([class]), then
+//   - if T has either no default constructor ([class.default.ctor]) or a default constructor
+//   that is user-provided or deleted, then the object is default-initialized;"
+// N4950 [dcl.init.general]/7, /7.1:
 // "To default-initialize an object of type T means:
-// - If T is a (possibly cv-qualified) class type (Clause 12), constructors are considered. The applicable constructors
-// are enumerated (16.3.1.3), and the best one for the initializer () is chosen through overload resolution (16.3).
+// - If T is a (possibly cv-qualified) class type ([class]), constructors are considered. The applicable constructors
+// are enumerated ([over.match.ctor]), and the best one for the initializer () is chosen through overload resolution
+// ([over.match]).
 // The constructor thus selected is called, with an empty argument list, to initialize the object."
-// N4750 15.6.2 [class.base.init]/9, /9.3:
-// "In a non-delegating constructor, if a given potentially constructed subobject is not designated by a
-// mem-initializer-id (including the case where there is no mem-initializer-list because the constructor has no
-// ctor-initializer), then [...] - otherwise, the entity is default-initialized (11.6)."
-// N4750 11.6 [dcl.init]/7, /7.2, /7.3:
+// N4950 [class.base.init]/9, /9.3:
+// "In a non-delegating constructor other than an implicitly-defined copy/move constructor ([class.copy.ctor]),
+// if a given potentially constructed subobject is not designated by a mem-initializer-id (including the case
+// where there is no mem-initializer-list because the constructor has no ctor-initializer), then [...]
+// - otherwise, the entity is default-initialized ([dcl.init])."
+// N4950 [dcl.init.general]/7, /7.2, /7.3:
 // "To default-initialize an object of type T means: [...]
 // - If T is an array type, each element is default-initialized.
 // - Otherwise, no initialization is performed."
@@ -1651,7 +1654,7 @@ _NODISCARD from_chars_result _Ordinary_floating_from_chars(const char* const _Fi
     constexpr int _Maximum_temporary_decimal_exponent = 5200;
     constexpr int _Minimum_temporary_decimal_exponent = -5200;
 
-    if (_Fmt != chars_format::fixed // N4713 23.20.3 [charconv.from.chars]/7.3
+    if (_Fmt != chars_format::fixed // N4950 [charconv.from.chars]/6.3
                                     // "if fmt has chars_format::fixed set but not chars_format::scientific,
                                     // the optional exponent part shall not appear"
         && _Next != _Last && (static_cast<unsigned char>(*_Next) | 0x20) == _Exponent_prefix) { // found exponent prefix
@@ -1690,7 +1693,7 @@ _NODISCARD from_chars_result _Ordinary_floating_from_chars(const char* const _Fi
     const char* const _Exponent_end = _Next;
 
     if (_Fmt == chars_format::scientific
-        && _Frac_end == _Exponent_end) { // N4713 23.20.3 [charconv.from.chars]/7.2
+        && _Frac_end == _Exponent_end) { // N4950 [charconv.from.chars]/6.2
                                          // "if fmt has chars_format::scientific set but not chars_format::fixed,
                                          // the otherwise optional exponent part shall appear"
         return {_First, errc::invalid_argument};