Various cleanups

.vscode/settings.json

@@ -30,5 +30,9 @@
         "./llvm-project/libcxx/utils",
         "./llvm-project/llvm/utils/lit",
         "./tests/utils"
-    ]
+    ],
+    "search.exclude": {
+        "stl/src/xcharconv_ryu_tables.cpp": true,
+        "tests/std/tests/P0067R5_charconv/*test_cases*.hpp": true
+    }
 }

CMakeLists.txt

@@ -54,7 +54,7 @@ option(STL_ASAN_BUILD "Build the STL with ASan enabled" OFF)
 
 set(VCLIBS_EXPLICIT_MACHINE "")
 
-if("${VCLIBS_TARGET_ARCHITECTURE}" STREQUAL "x86")
+if(VCLIBS_TARGET_ARCHITECTURE STREQUAL "x86")
     set(VCLIBS_TARGET_ARCHITECTURE "x86")
     set(VCLIBS_I386_OR_AMD64 "i386")
     set(VCLIBS_X86_OR_X64 "x86")

benchmarks/CMakeLists.txt

@@ -19,7 +19,7 @@ if(DEFINED STL_BINARY_DIR)
 
     string(TOLOWER "${VCLIBS_TARGET_ARCHITECTURE}" VCLIBS_TARGET_ARCHITECTURE)
 
-    if("${VCLIBS_TARGET_ARCHITECTURE}" STREQUAL "x86")
+    if(VCLIBS_TARGET_ARCHITECTURE STREQUAL "x86")
         set(VCLIBS_I386_OR_AMD64 "i386")
     elseif(VCLIBS_TARGET_ARCHITECTURE STREQUAL "x64")
         set(VCLIBS_I386_OR_AMD64 "amd64")

stl/inc/__msvc_bit_utils.hpp

@@ -113,16 +113,13 @@ _NODISCARD int _Countl_zero_bsr(const _Ty _Val) noexcept {
 
 template <class _Ty>
 _NODISCARD int _Checked_x86_x64_countl_zero(const _Ty _Val) noexcept {
-#ifdef __AVX2__
-    return _Countl_zero_lzcnt(_Val);
-#else // ^^^ defined(__AVX2__) / !defined(__AVX2__) vvv
+#ifndef __AVX2__
     const bool _Definitely_have_lzcnt = __isa_available >= _Stl_isa_available_avx2;
-    if (_Definitely_have_lzcnt) {
-        return _Countl_zero_lzcnt(_Val);
-    } else {
+    if (!_Definitely_have_lzcnt) {
         return _Countl_zero_bsr(_Val);
     }
 #endif // ^^^ !defined(__AVX2__) ^^^
+    return _Countl_zero_lzcnt(_Val);
 }
 #endif // (defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)) || (defined(_M_X64) && !defined(_M_ARM64EC))
 
@@ -259,16 +256,13 @@ _NODISCARD int _Countr_zero_bsf(const _Ty _Val) noexcept {
 
 template <class _Ty>
 _NODISCARD int _Checked_x86_x64_countr_zero(const _Ty _Val) noexcept {
-#ifdef __AVX2__
-    return _Countr_zero_tzcnt(_Val);
-#else // ^^^ defined(__AVX2__) / !defined(__AVX2__) vvv
+#ifndef __AVX2__
     const bool _Definitely_have_tzcnt = __isa_available >= _Stl_isa_available_avx2;
-    if (_Definitely_have_tzcnt) {
-        return _Countr_zero_tzcnt(_Val);
-    } else {
+    if (!_Definitely_have_tzcnt) {
         return _Countr_zero_bsf(_Val);
     }
 #endif // ^^^ !defined(__AVX2__) ^^^
+    return _Countr_zero_tzcnt(_Val);
 }
 
 #endif // _HAS_TZCNT_BSF_INTRINSICS
@@ -336,20 +330,17 @@ constexpr decltype(auto) _Select_countr_zero_impl(_Fn _Callback) {
     // TRANSITION, DevCom-1527995: Lambdas in this function ensure inlining
 #if _HAS_TZCNT_BSF_INTRINSICS && _HAS_CXX20
     if (!_STD is_constant_evaluated()) {
-#ifdef __AVX2__
-        return _Callback([](_Ty _Val) _STATIC_LAMBDA { return _Countr_zero_tzcnt(_Val); });
-#else // ^^^ AVX2 / not AVX2 vvv
+#ifndef __AVX2__
         const bool _Definitely_have_tzcnt = __isa_available >= _Stl_isa_available_avx2;
-        if (_Definitely_have_tzcnt) {
-            return _Callback([](_Ty _Val) _STATIC_LAMBDA { return _Countr_zero_tzcnt(_Val); });
-        } else {
-            return _Callback([](_Ty _Val) _STATIC_LAMBDA { return _Countr_zero_bsf(_Val); });
+        if (!_Definitely_have_tzcnt) {
+            return _Callback([](_Ty _Val) _STATIC_CALL_OPERATOR { return _Countr_zero_bsf(_Val); });
         }
-#endif // ^^^ not AVX2 ^^^
+#endif // ^^^ !defined(__AVX2__) ^^^
+        return _Callback([](_Ty _Val) _STATIC_CALL_OPERATOR { return _Countr_zero_tzcnt(_Val); });
     }
 #endif // ^^^ _HAS_TZCNT_BSF_INTRINSICS && _HAS_CXX20 ^^^
     // C++17 constexpr gcd() calls this function, so it should be constexpr unless we detect runtime evaluation.
-    return _Callback([](_Ty _Val) _STATIC_LAMBDA { return _Countr_zero_fallback(_Val); });
+    return _Callback([](_Ty _Val) _STATIC_CALL_OPERATOR { return _Countr_zero_fallback(_Val); });
 }
 
 template <class _Ty>
@@ -394,13 +385,13 @@ _CONSTEXPR20 decltype(auto) _Select_popcount_impl(_Fn _Callback) {
 #if !_POPCNT_INTRINSICS_ALWAYS_AVAILABLE
         const bool _Definitely_have_popcnt = __isa_available >= _Stl_isa_available_sse42;
         if (!_Definitely_have_popcnt) {
-            return _Callback([](_Ty _Val) _STATIC_LAMBDA { return _Popcount_fallback(_Val); });
+            return _Callback([](_Ty _Val) _STATIC_CALL_OPERATOR { return _Popcount_fallback(_Val); });
         }
 #endif // ^^^ !_POPCNT_INTRINSICS_ALWAYS_AVAILABLE ^^^
-        return _Callback([](_Ty _Val) _STATIC_LAMBDA { return _Unchecked_popcount(_Val); });
+        return _Callback([](_Ty _Val) _STATIC_CALL_OPERATOR { return _Unchecked_popcount(_Val); });
     }
 #endif // ^^^ _HAS_POPCNT_INTRINSICS ^^^
-    return _Callback([](_Ty _Val) _STATIC_LAMBDA { return _Popcount_fallback(_Val); });
+    return _Callback([](_Ty _Val) _STATIC_CALL_OPERATOR { return _Popcount_fallback(_Val); });
 }
 
 #undef _HAS_TZCNT_BSF_INTRINSICS

stl/inc/__msvc_chrono.hpp

@@ -677,7 +677,7 @@ namespace chrono {
         _NODISCARD static time_point now() noexcept { // get current time
             const long long _Freq = _Query_perf_frequency(); // doesn't change after system boot
             const long long _Ctr  = _Query_perf_counter();
-            static_assert(period::num == 1, "This assumes period::num == 1.");
+            _STL_INTERNAL_STATIC_ASSERT(period::num == 1);
             // The compiler recognizes the constants for frequency and time period and uses shifts and
             // multiplies instead of divides to calculate the nanosecond value.
             constexpr long long _TenMHz        = 10'000'000;
@@ -686,7 +686,7 @@ namespace chrono {
                 // 10 MHz is a very common QPC frequency on modern x86/x64 PCs. Optimizing for
                 // this specific frequency can double the performance of this function by
                 // avoiding the expensive frequency conversion path.
-                static_assert(period::den % _TenMHz == 0, "It should never fail.");
+                _STL_INTERNAL_STATIC_ASSERT(period::den % _TenMHz == 0);
                 constexpr long long _Multiplier = period::den / _TenMHz;
                 return time_point(duration(_Ctr * _Multiplier));
             } else if (_Freq == _TwentyFourMHz) {
@@ -695,8 +695,8 @@ namespace chrono {
                 using _Multiplier_part                = ratio<period::den % _TwentyFourMHz, _TwentyFourMHz>;
                 constexpr long long _Multiplier_num   = _Multiplier_part::num;
                 constexpr long long _Multiplier_den   = _Multiplier_part::den;
-                static_assert(
-                    _Multiplier_num <= _Multiplier_whole, "This assumes that _Ctr * _Multiplier_num doesn't overflow.");
+                // This assumes that _Ctr * _Multiplier_num doesn't overflow.
+                _STL_INTERNAL_STATIC_ASSERT(_Multiplier_num <= _Multiplier_whole);
                 const long long _Whole = _Ctr * _Multiplier_whole;
                 const long long _Part  = _Ctr * _Multiplier_num / _Multiplier_den;
                 return time_point(duration(_Whole + _Part));

stl/inc/__msvc_formatter.hpp

@@ -47,6 +47,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <type_traits>
+
 #if _HAS_CXX23
 #include <xutility>
 #endif // _HAS_CXX23

stl/inc/__msvc_ranges_to.hpp

@@ -632,7 +632,7 @@ namespace ranges {
                 } else if constexpr (_Strat == _St::_Own) {
                     return owning_view{_STD forward<_Rng>(_Range)};
                 } else {
-                    _STL_INTERNAL_STATIC_ASSERT(false); // unexpected strategy
+                    static_assert(false); // unexpected strategy
                 }
             }
         };
@@ -1146,7 +1146,7 @@ namespace ranges {
                                      "the default-constructed object. (N5014 [range.utility.conv.to]/2.1.5)");
             }
         } else if constexpr (input_range<range_reference_t<_Rng>>) {
-            const auto _Xform = [](auto&& _Elem) _STATIC_LAMBDA {
+            const auto _Xform = [](auto&& _Elem) _STATIC_CALL_OPERATOR {
                 return _RANGES to<range_value_t<_Container>>(_STD forward<decltype(_Elem)>(_Elem));
             };
             return _RANGES to<_Container>(views::transform(ref_view{_Range}, _Xform), _STD forward<_Types>(_Args)...);

stl/inc/__msvc_ranges_tuple_formatter.hpp

@@ -426,7 +426,7 @@ auto _Format_arg_traits<_Context>::_Type_eraser() {
         return basic_string_view<_Char_type>{};
     } else if constexpr (_Is_any_of_v<decay_t<_Td>, _Char_type*, const _Char_type*>) {
         return static_cast<const _Char_type*>(nullptr);
-    } else if constexpr (is_void_v<remove_pointer_t<_Td>> || is_same_v<_Td, nullptr_t>) {
+    } else if constexpr (is_void_v<remove_pointer_t<_Td>> || is_null_pointer_v<_Td>) {
         return static_cast<const void*>(nullptr);
     } else {
         int _Dummy{};

stl/inc/__msvc_string_view.hpp

@@ -96,7 +96,7 @@ size_t _Find_first_of_pos_vectorized(const _Ty1* const _Haystack, const size_t _
     } else if constexpr (sizeof(_Ty1) == 8) {
         return ::__std_find_first_of_trivial_pos_8(_Haystack, _Haystack_length, _Needle, _Needle_length);
     } else {
-        _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size
+        static_assert(false, "unexpected size");
     }
 }
 #endif // ^^^ _VECTORIZED_FIND_FIRST_OF ^^^
@@ -111,7 +111,7 @@ size_t _Find_last_of_pos_vectorized(const _Ty1* const _Haystack, const size_t _H
     } else if constexpr (sizeof(_Ty1) == 2) {
         return ::__std_find_last_of_trivial_pos_2(_Haystack, _Haystack_length, _Needle, _Needle_length);
     } else {
-        _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size
+        static_assert(false, "unexpected size");
     }
 }
 #endif // ^^^ _VECTORIZED_FIND_LAST_OF ^^^
@@ -128,7 +128,7 @@ const _Ty* _Find_not_ch_vectorized(const _Ty* const _First, const _Ty* const _La
     } else if constexpr (sizeof(_Ty) == 8) {
         return static_cast<const _Ty*>(::__std_find_not_ch_8(_First, _Last, static_cast<uint64_t>(_Ch)));
     } else {
-        _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size
+        static_assert(false, "unexpected size");
     }
 }
 #endif // ^^^ _VECTORIZED_FIND ^^^
@@ -145,7 +145,7 @@ size_t _Find_last_not_ch_pos_vectorized(const _Ty* const _First, const _Ty* cons
     } else if constexpr (sizeof(_Ty) == 8) {
         return ::__std_find_last_not_ch_pos_8(_First, _Last, static_cast<uint64_t>(_Ch));
     } else {
-        _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size
+        static_assert(false, "unexpected size");
     }
 }
 #endif // ^^^ _VECTORIZED_FIND_LAST ^^^
@@ -160,7 +160,7 @@ size_t _Find_first_not_of_pos_vectorized(const _Ty1* const _Haystack, const size
     } else if constexpr (sizeof(_Ty1) == 2) {
         return ::__std_find_first_not_of_trivial_pos_2(_Haystack, _Haystack_length, _Needle, _Needle_length);
     } else {
-        _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size
+        static_assert(false, "unexpected size");
     }
 }
 #endif // ^^^ _VECTORIZED_FIND_FIRST_OF ^^^
@@ -175,7 +175,7 @@ size_t _Find_last_not_of_pos_vectorized(const _Ty1* const _Haystack, const size_
     } else if constexpr (sizeof(_Ty1) == 2) {
         return ::__std_find_last_not_of_trivial_pos_2(_Haystack, _Haystack_length, _Needle, _Needle_length);
     } else {
-        _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size
+        static_assert(false, "unexpected size");
     }
 }
 #endif // ^^^ _VECTORIZED_FIND_LAST_OF ^^^
@@ -1961,9 +1961,7 @@ namespace ranges {
     template <class _Elem, class _Traits>
     constexpr bool enable_borrowed_range<basic_string_view<_Elem, _Traits>> = true;
 } // namespace ranges
-#endif // _HAS_CXX20
 
-#if _HAS_CXX20
 _EXPORT_STD template <class _Elem, class _Traits>
 _NODISCARD constexpr bool operator==(const basic_string_view<_Elem, _Traits> _Lhs,
     const type_identity_t<basic_string_view<_Elem, _Traits>> _Rhs) noexcept {