Various cleanups

stl/inc/chrono

@@ -3648,24 +3648,31 @@ namespace chrono {
             if (_Second || _Subsecond) {
                 _Ret |= _F_sec;
             }
+
             if (_Minute) {
                 _Ret |= _F_min;
             }
+
             if (_Hour_24) {
                 _Ret |= _F_hr;
             }
+
             if (_Day) {
                 _Ret |= _F_day;
             }
+
             if (_Weekday) {
                 _Ret |= _F_wkday;
             }
+
             if (_Month) {
                 _Ret |= _F_mon;
             }
+
             if (_Day_of_year) {
                 _Ret |= _F_doy;
             }
+
             if (_Two_dig_year && _Century) {
                 _Ret |= _F_year;
             }

stl/inc/complex

@@ -203,7 +203,7 @@ namespace _Float_multi_prec {
 #undef _FMP_USING_X86_X64_INTRINSICS
 #undef _FMP_USING_ARM64_INTRINSICS
 
-#define _FMP ::std::_Float_multi_prec::
+#define _FMP _STD _Float_multi_prec::
 
 // implements numerical algorithms for <complex>
 namespace _Math_algorithms {
@@ -1932,7 +1932,7 @@ _NODISCARD inline float _Log_abs(const complex<float>& _Left) noexcept {
 
 template <class _Ty>
 _NODISCARD complex<_Ty> log(const complex<_Ty>& _Left) {
-    const _Ty _Log_abs_v = _STD _Log_abs(_Left); // get logarithm of magnitude
+    const _Ty _Log_abs_v = _Log_abs(_Left); // get logarithm of magnitude
     const _Ty _Theta     = _Ctraits<_Ty>::atan2(_STD imag(_Left), _STD real(_Left)); // get phase
     return complex<_Ty>(_Log_abs_v, _Theta);
 }

stl/inc/experimental/filesystem

@@ -1914,6 +1914,7 @@ inline void copy(const path& _Oldpval, const path& _Newpval, copy_options _Opts,
         _Oldstat = status(_Oldpval);
         _Newstat = status(_Newpval);
     }
+
     if (!exists(_Oldstat) || equivalent(_Oldpval, _Newpval, _Code2) || is_other(_Oldstat) || is_other(_Newstat)
         || (is_directory(_Oldstat) && is_regular_file(_Newstat))) {
         _Code = make_error_code(errc::operation_not_permitted);

stl/inc/format

@@ -1487,11 +1487,9 @@ struct _Format_arg_traits {
 
     static auto _Phony_basic_format_arg_constructor(nullptr_t) -> const void*; // not defined
 
-    // clang-format off
     template <class _Ty>
         requires is_void_v<_Ty>
     static auto _Phony_basic_format_arg_constructor(_Ty*) -> const void*; // not defined
-    // clang-format on
 
     template <class _Ty>
     using _Storage_type = decltype(_Phony_basic_format_arg_constructor(_STD declval<_Ty>()));
@@ -1716,11 +1714,9 @@ public:
     }
 };
 
-// clang-format off
 template <class _Out, class _CharT>
     requires output_iterator<_Out, const _CharT&>
 class basic_format_context {
-    // clang-format on
 private:
     _Out _OutputIt;
     basic_format_args<basic_format_context> _Args;

stl/inc/istream

@@ -807,7 +807,7 @@ basic_istream<_Elem, _Traits>& _Istream_extract_into_buffer(
         }
         _CATCH_IO_(ios_base, _Istr)
     }
-    __analysis_assume(static_cast<size_t>(_Current) < _Size); // TRANSITION, VSO-860375
+    _Analysis_assume_(static_cast<size_t>(_Current) < _Size); // TRANSITION, VSO-860375
     _Str[_Current] = _Elem(); // add terminating null character
     _Istr.width(0);
     if (_Current == 0) {

stl/inc/limits

@@ -1023,7 +1023,7 @@ _NODISCARD constexpr int _Countl_zero_fallback(_Ty _Val) noexcept {
 // see "Hacker's Delight" section 5-4
 template <class _Ty>
 _NODISCARD constexpr int _Countr_zero_fallback(const _Ty _Val) noexcept {
-    constexpr int _Digits = std::numeric_limits<_Ty>::digits;
+    constexpr int _Digits = numeric_limits<_Ty>::digits;
     return _Digits - _Countl_zero_fallback(static_cast<_Ty>(static_cast<_Ty>(~_Val) & static_cast<_Ty>(_Val - 1)));
 }
 

stl/inc/locale

@@ -165,72 +165,72 @@ _NODISCARD bool has_facet(const locale& _Loc) noexcept {
 }
 
 template <class _Elem>
-_NODISCARD bool(isalnum)(_Elem _Ch, const locale& _Loc) {
+_NODISCARD bool isalnum(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::alnum, _Ch);
 }
 
 template <class _Elem>
-_NODISCARD bool(isalpha)(_Elem _Ch, const locale& _Loc) {
+_NODISCARD bool isalpha(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::alpha, _Ch);
 }
 
 template <class _Elem>
-_NODISCARD bool(isblank)(_Elem _Ch, const locale& _Loc) {
+_NODISCARD bool isblank(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::blank, _Ch);
 }
 
 template <class _Elem>
-_NODISCARD bool(iscntrl)(_Elem _Ch, const locale& _Loc) {
+_NODISCARD bool iscntrl(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::cntrl, _Ch);
 }
 
 template <class _Elem>
-_NODISCARD bool(isdigit)(_Elem _Ch, const locale& _Loc) {
+_NODISCARD bool isdigit(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::digit, _Ch);
 }
 
 template <class _Elem>
-_NODISCARD bool(isgraph)(_Elem _Ch, const locale& _Loc) {
+_NODISCARD bool isgraph(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::graph, _Ch);
 }
 
 template <class _Elem>
-_NODISCARD bool(islower)(_Elem _Ch, const locale& _Loc) {
+_NODISCARD bool islower(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::lower, _Ch);
 }
 
 template <class _Elem>
-_NODISCARD bool(isprint)(_Elem _Ch, const locale& _Loc) {
+_NODISCARD bool isprint(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::print, _Ch);
 }
 
 template <class _Elem>
-_NODISCARD bool(ispunct)(_Elem _Ch, const locale& _Loc) {
+_NODISCARD bool ispunct(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::punct, _Ch);
 }
 
 template <class _Elem>
-_NODISCARD bool(isspace)(_Elem _Ch, const locale& _Loc) {
+_NODISCARD bool isspace(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::space, _Ch);
 }
 
 template <class _Elem>
-_NODISCARD bool(isupper)(_Elem _Ch, const locale& _Loc) {
+_NODISCARD bool isupper(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::upper, _Ch);
 }
 
 template <class _Elem>
-_NODISCARD bool(isxdigit)(_Elem _Ch, const locale& _Loc) {
+_NODISCARD bool isxdigit(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::xdigit, _Ch);
 }
 
 template <class _Elem>
-_NODISCARD _Elem(tolower)(_Elem _Ch, const locale& _Loc) {
+_NODISCARD _Elem tolower(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).tolower(_Ch);
 }
 
 template <class _Elem>
-_NODISCARD _Elem(toupper)(_Elem _Ch, const locale& _Loc) {
+_NODISCARD _Elem toupper(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).toupper(_Ch);
 }
 _STD_END

stl/inc/random

@@ -989,8 +989,8 @@ public:
         result_type _Buffer[_Nx];
         typename _Mybase::_Traits::_Cy_t _Carry_buf;
         const auto _Save_flags = _Istr.flags(ios_base::dec | ios_base::skipws);
-        for (size_t _Ix = 0; _Ix < _Nx; ++_Ix) {
-            _Istr >> _Buffer[_Ix];
+        for (auto& _Val : _Buffer) {
+            _Istr >> _Val;
         }
 
         _Istr >> _Carry_buf;
@@ -1217,9 +1217,8 @@ public:
     }
 
 protected:
-    _Post_satisfies_(this->_Idx == 0)
-
-        void _Refill_lower() { // compute values for the lower half of the history array
+    _Post_satisfies_(this->_Idx == 0) void _Refill_lower() {
+        // compute values for the lower half of the history array
         constexpr size_t _Wrap_bound_one = _Nx - _One_mod_n;
         constexpr size_t _Wrap_bound_m   = _Nx - _M_mod_n;
 
@@ -1722,8 +1721,9 @@ public:
     friend basic_istream<_Elem, _Traits>& operator>>(
         basic_istream<_Elem, _Traits>& _Istr, shuffle_order_engine& _Eng) { // read state from _Istr
         _Istr >> _Eng._Eng;
-        for (size_t _Idx = 0; _Idx < shuffle_order_engine::table_size; ++_Idx) {
-            _Istr >> _Eng._Arr[_Idx];
+
+        for (auto& _Val : _Eng._Arr) {
+            _Istr >> _Val;
         }
 
         return _Istr >> _Eng._Yx;
@@ -1733,17 +1733,18 @@ public:
     friend basic_ostream<_Elem, _Traits>& operator<<(
         basic_ostream<_Elem, _Traits>& _Ostr, const shuffle_order_engine& _Eng) { // write state to _Ostr
         _Ostr << _Eng._Eng;
-        for (size_t _Idx = 0; _Idx < shuffle_order_engine::table_size; ++_Idx) {
-            _Ostr << ' ' << _Eng._Arr[_Idx];
+
+        for (const auto& _Val : _Eng._Arr) {
+            _Ostr << ' ' << _Val;
         }
 
         return _Ostr << ' ' << _Eng._Yx;
     }
 
 private:
     void _Init() { // compute values for operator()
-        for (size_t _Idx = 0; _Idx < _Kx; ++_Idx) {
-            _Arr[_Idx] = _Eng();
+        for (auto& _Val : _Arr) {
+            _Val = _Eng();
         }
 
         _Yx = _Eng();
@@ -2220,15 +2221,13 @@ public:
 
     template <class _Engine>
     _NODISCARD _Ty operator()(_Engine& _Eng) const {
-        _Ty _Res;
-        _Ty1 _Val;
-        for (_Res = 0, _Val = 1.0;; ++_Res) { // count repetitions
+        _Ty1 _Val = 1.0;
+        for (_Ty _Res = 0;; ++_Res) { // count repetitions
             _Val *= _NRAND(_Eng, _Ty1);
             if (_Val <= _Gx0) {
-                break;
+                return _Res;
             }
         }
-        return _Res;
     }
 
     void _Init(const _Ty1& _Mean0) { // set internal state
@@ -4424,11 +4423,10 @@ public:
 
         template <class _Elem, class _Traits>
         basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr
-            const size_t _Nvals = _Pvec.size();
-            _Ostr << ' ' << _Nvals;
+            _Ostr << ' ' << _Pvec.size();
 
-            for (size_t _Idx = 0; _Idx < _Nvals; ++_Idx) {
-                _Out(_Ostr, _Pvec[_Idx]);
+            for (const auto& _Val : _Pvec) {
+                _Out(_Ostr, _Val);
             }
 
             return _Ostr;
@@ -4686,8 +4684,8 @@ public:
         const piecewise_constant_distribution& _Dist) { // write state to _Ostr
         static_cast<const piecewise_constant_distribution::_Mypbase&>(_Dist._Par)._Write(_Ostr);
 
-        for (size_t _Idx = 0; _Idx < _Dist._Par._Bvec.size(); ++_Idx) {
-            _Out(_Ostr, _Dist._Par._Bvec[_Idx]);
+        for (const auto& _Val : _Dist._Par._Bvec) {
+            _Out(_Ostr, _Val);
         }
 
         return _Ostr;
@@ -4912,8 +4910,8 @@ public:
         const piecewise_linear_distribution& _Dist) { // write state to _Ostr
         static_cast<const piecewise_linear_distribution::_Mypbase&>(_Dist._Par)._Write(_Ostr);
 
-        for (size_t _Idx = 0; _Idx < _Dist._Par._Bvec.size(); ++_Idx) {
-            _Out(_Ostr, _Dist._Par._Bvec[_Idx]);
+        for (const auto& _Val : _Dist._Par._Bvec) {
+            _Out(_Ostr, _Val);
         }
 
         return _Ostr;