Add some noexcept optimizations removing the need for _Backout

Author: miscco

stl/inc/memory

@@ -272,6 +272,11 @@ namespace ranges {
                     _CSTD memset(_OFirst, static_cast<unsigned char>(_Val), static_cast<size_t>(_OFinal - _OFirst));
                     return _OFinal;
                 }
+            } else if constexpr (is_nothrow_constructible_v<iter_value_t<_It>, const _Ty&>) {
+                for (; _OFirst != _OLast; ++_OFirst) {
+                    _Construct_in_place(*_OFirst, _Val);
+                }
+                return _OFirst;
             } else {
                 _Uninitialized_backout _Backout{_STD move(_OFirst)};
 
@@ -362,11 +367,17 @@ namespace ranges {
             // clang-format on
             _Algorithm_int_t<iter_difference_t<_It>> _Count = _Count_raw;
             if (_Count > 0) {
+                auto _UFirst = _Get_unwrapped_n(_STD move(_First), _Count);
                 if constexpr (_Fill_memset_is_safe<_It, _Ty>) {
-                    _CSTD memset(_Get_unwrapped_n(_STD move(_First), _Count), static_cast<unsigned char>(_Val), _Count);
+                    _CSTD memset(_STD move(_UFirst), static_cast<unsigned char>(_Val), _Count);
                     _RANGES advance(_First, _Count);
+                } else if constexpr (is_nothrow_constructible_v<iter_value_t<_It>, const _Ty&>) {
+                    for (; 0 < _Count; ++_UFirst, (void) --_Count) {
+                        _Construct_in_place(*_UFirst, _Val);
+                    }
+                    _Seek_wrapped(_First, _STD move(_UFirst));
                 } else {
-                    _Uninitialized_backout _Backout{_Get_unwrapped_n(_STD move(_First), _Count)};
+                    _Uninitialized_backout _Backout{_STD move(_UFirst)};
 
                     for (; 0 < _Count; --_Count) {
                         _Backout._Emplace_back(_Val);
@@ -497,6 +508,12 @@ namespace ranges {
                 } else {
                     return _RANGES next(_OFirst, _STD move(_OLast));
                 }
+            } else if constexpr (is_nothrow_default_constructible_v<_Ty>) {
+                for (; _OFirst != _OLast; ++_OFirst) {
+                    ::new (static_cast<void*>(_Unfancy(_OFirst))) _Ty;
+                }
+
+                return _OFirst;
             } else {
                 _Uninitialized_backout _Backout{_STD move(_OFirst)};
 
@@ -553,6 +570,13 @@ namespace ranges {
             if (_Count > 0) {
                 if constexpr (is_trivially_default_constructible_v<_Ty>) {
                     _RANGES advance(_First, _Count);
+                } else if constexpr (is_nothrow_default_constructible_v<_Ty>) {
+                    auto _UFirst = _Get_unwrapped_n(_STD move(_First));
+                    for (; 0 < _Count; ++_UFirst, (void) --_Count) {
+                        ::new (static_cast<void*>(_Unfancy(_UFirst))) _Ty;
+                    }
+
+                    _Seek_wrapped(_First, _STD move(_UFirst));
                 } else {
                     _Uninitialized_backout _Backout{_Get_unwrapped_n(_STD move(_First), _Count)};
 
@@ -654,8 +678,15 @@ namespace ranges {
             _STL_INTERNAL_STATIC_ASSERT(_No_throw_sentinel_for<_Se, _It>);
             _STL_INTERNAL_STATIC_ASSERT(default_initializable<iter_value_t<_It>>);
 
+            using _Ty = iter_value_t<_It>;
             if constexpr (_Use_memset_value_construct_v<_It>) {
                 return _RANGES _Zero_range(_OFirst, _OLast);
+            } else if constexpr (is_nothrow_default_constructible_v<_Ty>) {
+                for (; _OFirst != _OLast; ++_OFirst) {
+                    ::new (static_cast<void*>(_Unfancy(_OFirst))) _Ty{};
+                }
+
+                return _OFirst;
             } else {
                 _Uninitialized_backout _Backout{_STD move(_OFirst)};
 
@@ -697,12 +728,20 @@ namespace ranges {
             requires default_initializable<iter_value_t<_It>>
         _It operator()(_It _First, const iter_difference_t<_It> _Count_raw) const {
             // clang-format on
+            using _Ty                                       = iter_value_t<_It>;
             _Algorithm_int_t<iter_difference_t<_It>> _Count = _Count_raw;
             if (_Count > 0) {
+                auto _UFirst = _Get_unwrapped_n(_STD move(_First));
                 if constexpr (_Use_memset_value_construct_v<_It>) {
-                    return _RANGES _Zero_range(_OFirst, _OFirst + _Count);
+                    _Seek_wrapped(_First, _RANGES _Zero_range(_UFirst, _UFirst + _Count));
+                } else if constexpr (is_nothrow_default_constructible_v<_Ty>) {
+                    for (; 0 < _Count; ++_UFirst, (void) --_Count) {
+                        ::new (static_cast<void*>(_Unfancy(_UFirst))) _Ty{};
+                    }
+
+                    _Seek_wrapped(_First, _STD move(_UFirst));
                 } else {
-                    _Uninitialized_backout _Backout{_Get_unwrapped_n(_STD move(_First), _Count)};
+                    _Uninitialized_backout _Backout{_STD move(_UFirst)};
 
                     for (; 0 < _Count; --_Count) {
                         _Backout._Emplace_back();