[libc++] Fix template parameter naming and enforce it through readability-identifier-naming

[philnik]

Try to fix CI

[Mordante]

Thanks a lot for working on this! Since this fixes some real bugs it would be great to get in in LLVM 17. This will be branched tomorrow during the European day.

libcxx/.clang-tidy

53–60

When it's hard to get the CI running soon then maybe undo this hunk and look at it later.

[philnik]

Try to fix CI

libcxx/.clang-tidy

CheckOptions:
   - key:   readability-identifier-naming.PrivateMemberPrefix
     value: __
   - key:   readability-identifier-naming.PrivateMemberSuffix
     value: _
   - key:   readability-identifier-naming.LocalVariableCase
     value: lower_case
   - key:   readability-identifier-naming.LocalVariablePrefix
     value: __
+  - key:   readability-identifier-naming.TemplateParameterCase
+    value: CamelCase
+  - key:   readability-identifier-naming.TemplateParameterPrefix
+    value: _
+  - key:   readability-identifier-naming.TemplateParameterIgnoredRegexp
+    value: (.*\:auto|expr-type) # This is https://llvm.org/PR56464
+  - key:   readability-identifier-naming.ValueTemplateParameterIgnoredRegexp # TODO: enforce naming of variable parameters
+    value: .*
 
 # TODO: investigate these checks
 # bugprone-branch-clone,
 # bugprone-macro-parentheses,
 # cppcoreguidelines-prefer-member-initializer,
 # misc-unused-parameters,
 # modernize-use-bool-literals,
 # modernize-use-default-member-init,

libcxx/include/__bit_reference

 __bit_iterator<_Cp, false>
 move_backward(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)
 {
     return _VSTD::copy_backward(__first, __last, __result);
 }
 
 // swap_ranges
 
-template <class __C1, class __C2>
-_LIBCPP_HIDE_FROM_ABI __bit_iterator<__C2, false>
-__swap_ranges_aligned(__bit_iterator<__C1, false> __first, __bit_iterator<__C1, false> __last,
-                      __bit_iterator<__C2, false> __result)
+template <class _Cl, class _Cr>
+_LIBCPP_HIDE_FROM_ABI __bit_iterator<_Cr, false>
+__swap_ranges_aligned(__bit_iterator<_Cl, false> __first, __bit_iterator<_Cl, false> __last,
+                      __bit_iterator<_Cr, false> __result)
 {
-    typedef __bit_iterator<__C1, false> _I1;
+    typedef __bit_iterator<_Cl, false> _I1;
     typedef  typename _I1::difference_type difference_type;
     typedef typename _I1::__storage_type __storage_type;
     const int __bits_per_word = _I1::__bits_per_word;
     difference_type __n = __last - __first;
     if (__n > 0)
     {
         // do first word
         if (__first.__ctz_ != 0)
if (__n > 0)
             *__result.__seg_ |= __b1;
             *__first.__seg_  |= __b2;
             __result.__ctz_ = static_cast<unsigned>(__n);
         }
     }
     return __result;
 }
 
-template <class __C1, class __C2>
-_LIBCPP_HIDE_FROM_ABI __bit_iterator<__C2, false>
-__swap_ranges_unaligned(__bit_iterator<__C1, false> __first, __bit_iterator<__C1, false> __last,
-                        __bit_iterator<__C2, false> __result)
+template <class _Cl, class _Cr>
+_LIBCPP_HIDE_FROM_ABI __bit_iterator<_Cr, false>
+__swap_ranges_unaligned(__bit_iterator<_Cl, false> __first, __bit_iterator<_Cl, false> __last,
+                        __bit_iterator<_Cr, false> __result)
 {
-    typedef __bit_iterator<__C1, false> _I1;
+    typedef __bit_iterator<_Cl, false> _I1;
     typedef  typename _I1::difference_type difference_type;
     typedef typename _I1::__storage_type __storage_type;
     const int __bits_per_word = _I1::__bits_per_word;
     difference_type __n = __last - __first;
     if (__n > 0)
     {
         // do first word
         if (__first.__ctz_ != 0)
if (__n > 0)
                 *__first.__seg_  |= __b2 << __dn;
                 __result.__ctz_ = static_cast<unsigned>(__n);
             }
         }
     }
     return __result;
 }
 
-template <class __C1, class __C2>
+template <class _Cl, class _Cr>
 inline _LIBCPP_INLINE_VISIBILITY
-__bit_iterator<__C2, false>
-swap_ranges(__bit_iterator<__C1, false> __first1, __bit_iterator<__C1, false> __last1,
-            __bit_iterator<__C2, false> __first2)
+__bit_iterator<_Cr, false>
+swap_ranges(__bit_iterator<_Cl, false> __first1, __bit_iterator<_Cl, false> __last1,
+            __bit_iterator<_Cr, false> __first2)
 {
     if (__first1.__ctz_ == __first2.__ctz_)
         return _VSTD::__swap_ranges_aligned(__first1, __last1, __first2);
     return _VSTD::__swap_ranges_unaligned(__first1, __last1, __first2);
 }
 
 // rotate
 
private:
     friend __bit_iterator<_Dp, false> __copy_backward_unaligned(__bit_iterator<_Dp, _IC> __first,
                                                                 __bit_iterator<_Dp, _IC> __last,
                                                                 __bit_iterator<_Dp, false> __result);
     template <class _Dp, bool _IC>
     _LIBCPP_CONSTEXPR_SINCE_CXX20
     friend __bit_iterator<_Dp, false> copy_backward(__bit_iterator<_Dp, _IC> __first,
                                                     __bit_iterator<_Dp, _IC> __last,
                                                     __bit_iterator<_Dp, false> __result);
-    template <class __C1, class __C2>friend __bit_iterator<__C2, false> __swap_ranges_aligned(__bit_iterator<__C1, false>,
-                                                                                           __bit_iterator<__C1, false>,
-                                                                                           __bit_iterator<__C2, false>);
-    template <class __C1, class __C2>friend __bit_iterator<__C2, false> __swap_ranges_unaligned(__bit_iterator<__C1, false>,
-                                                                                             __bit_iterator<__C1, false>,
-                                                                                             __bit_iterator<__C2, false>);
-    template <class __C1, class __C2>friend __bit_iterator<__C2, false> swap_ranges(__bit_iterator<__C1, false>,
-                                                                                 __bit_iterator<__C1, false>,
-                                                                                 __bit_iterator<__C2, false>);
+    template <class _Cl, class _Cr>friend __bit_iterator<_Cr, false> __swap_ranges_aligned(__bit_iterator<_Cl, false>,
+                                                                                           __bit_iterator<_Cl, false>,
+                                                                                           __bit_iterator<_Cr, false>);
+    template <class _Cl, class _Cr>friend __bit_iterator<_Cr, false> __swap_ranges_unaligned(__bit_iterator<_Cl, false>,
+                                                                                             __bit_iterator<_Cl, false>,
+                                                                                             __bit_iterator<_Cr, false>);
+    template <class _Cl, class _Cr>friend __bit_iterator<_Cr, false> swap_ranges(__bit_iterator<_Cl, false>,
+                                                                                 __bit_iterator<_Cl, false>,
+                                                                                 __bit_iterator<_Cr, false>);
     template <class _Dp>
     _LIBCPP_CONSTEXPR_SINCE_CXX20
     friend __bit_iterator<_Dp, false> rotate(__bit_iterator<_Dp, false>,
                                              __bit_iterator<_Dp, false>,
                                              __bit_iterator<_Dp, false>);
     template <class _Dp, bool _IC1, bool _IC2>
     _LIBCPP_CONSTEXPR_SINCE_CXX20
     friend bool __equal_aligned(__bit_iterator<_Dp, _IC1>,

libcxx/include/__chrono/calendar.h

 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace chrono
 {
 
 struct local_t {};
-template<class Duration>
-using local_time  = time_point<local_t, Duration>;
+template<class _Duration>
+using local_time  = time_point<local_t, _Duration>;
 using local_seconds = local_time<seconds>;
 using local_days    = local_time<days>;
 
 struct last_spec { explicit last_spec() = default; };
 inline constexpr last_spec last{};
 
 
 } // namespace chrono
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
 #endif // _LIBCPP___CHRONO_CALENDAR_H

libcxx/include/__format/format_context.h

#ifndef _LIBCPP_HAS_NO_LOCALIZATION
   //   Returns: The locale passed to the formatting function if the latter
   //   takes one, and std::locale() otherwise.
   // This is done by storing the locale of the constructor in this optional. If
   // locale() is called and the optional has no value the value will be created.
   // This allows the implementation to lazily create the locale.
   // TODO FMT Validate whether lazy creation is the best solution.
   optional<_VSTD::locale> __loc_;
 
-  template <class __OutIt, class __CharT>
-  friend _LIBCPP_HIDE_FROM_ABI basic_format_context<__OutIt, __CharT>
-  __format_context_create(__OutIt, basic_format_args<basic_format_context<__OutIt, __CharT>>,
+  template <class _OtherOutIt, class _OtherCharT>
+  friend _LIBCPP_HIDE_FROM_ABI basic_format_context<_OtherOutIt, _OtherCharT>
+  __format_context_create(_OtherOutIt, basic_format_args<basic_format_context<_OtherOutIt, _OtherCharT>>,
                           optional<_VSTD::locale>&&);
 
   // Note: the Standard doesn't specify the required constructors.
   _LIBCPP_HIDE_FROM_ABI
   explicit basic_format_context(_OutIt __out_it,
                                 basic_format_args<basic_format_context> __args,
                                 optional<_VSTD::locale>&& __loc)
       : __out_it_(_VSTD::move(__out_it)), __args_(__args),
         __loc_(_VSTD::move(__loc)) {}
 #else
-  template <class __OutIt, class __CharT>
-  friend _LIBCPP_HIDE_FROM_ABI basic_format_context<__OutIt, __CharT>
-      __format_context_create(__OutIt, basic_format_args<basic_format_context<__OutIt, __CharT>>);
+  template <class _OtherOutIt, class _OtherCharT>
+  friend _LIBCPP_HIDE_FROM_ABI basic_format_context<_OtherOutIt, _OtherCharT>
+      __format_context_create(_OtherOutIt, basic_format_args<basic_format_context<_OtherOutIt, _OtherCharT>>);
 
   _LIBCPP_HIDE_FROM_ABI
   explicit basic_format_context(_OutIt __out_it,
                                 basic_format_args<basic_format_context> __args)
       : __out_it_(_VSTD::move(__out_it)), __args_(__args) {}
 #endif
 };
 

libcxx/include/__format/range_default_formatter.h

set_brackets(basic_string_view<_CharT> __opening_bracket, basic_string_view<_CharT> __closing_bracket) noexcept {
     __underlying_.set_brackets(__opening_bracket, __closing_bracket);
   }
 
   template <class _ParseContext>
   _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
     return __underlying_.parse(__ctx);
   }
 
-  template <class FormatContext>
-  _LIBCPP_HIDE_FROM_ABI typename FormatContext::iterator format(__maybe_const_r& __range, FormatContext& __ctx) const {
+  template <class _FormatContext>
+  _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator
+  format(__maybe_const_r& __range, _FormatContext& __ctx) const {
     return __underlying_.format(__range, __ctx);
   }
 };
 
 template <ranges::input_range _Rp, class _CharT>
 struct _LIBCPP_TEMPLATE_VIS __range_default_formatter<range_format::map, _Rp, _CharT> {
 private:
   using __maybe_const_map = __fmt_maybe_const<_Rp, _CharT>;

libcxx/include/__functional/binder1st.h

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
 
-template <class __Operation>
+template <class _Operation>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 binder1st
-    : public __unary_function<typename __Operation::second_argument_type, typename __Operation::result_type>
+    : public __unary_function<typename _Operation::second_argument_type, typename _Operation::result_type>
 {
 protected:
-    __Operation                               op;
-    typename __Operation::first_argument_type value;
+    _Operation                               op;
+    typename _Operation::first_argument_type value;
 public:
-    _LIBCPP_INLINE_VISIBILITY binder1st(const __Operation& __x,
-                               const typename __Operation::first_argument_type __y)
+    _LIBCPP_INLINE_VISIBILITY binder1st(const _Operation& __x,
+                               const typename _Operation::first_argument_type __y)
         : op(__x), value(__y) {}
-    _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
-        (typename __Operation::second_argument_type& __x) const
+    _LIBCPP_INLINE_VISIBILITY typename _Operation::result_type operator()
+        (typename _Operation::second_argument_type& __x) const
             {return op(value, __x);}
-    _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
-        (const typename __Operation::second_argument_type& __x) const
+    _LIBCPP_INLINE_VISIBILITY typename _Operation::result_type operator()
+        (const typename _Operation::second_argument_type& __x) const
             {return op(value, __x);}
 };
 
-template <class __Operation, class _Tp>
+template <class _Operation, class _Tp>
 _LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
-binder1st<__Operation>
-bind1st(const __Operation& __op, const _Tp& __x)
-    {return binder1st<__Operation>(__op, __x);}
+binder1st<_Operation>
+bind1st(const _Operation& __op, const _Tp& __x)
+    {return binder1st<_Operation>(__op, __x);}
 
 #endif // _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FUNCTIONAL_BINDER1ST_H

libcxx/include/__functional/binder2nd.h

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
 
-template <class __Operation>
+template <class _Operation>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 binder2nd
-    : public __unary_function<typename __Operation::first_argument_type, typename __Operation::result_type>
+    : public __unary_function<typename _Operation::first_argument_type, typename _Operation::result_type>
 {
 protected:
-    __Operation                                op;
-    typename __Operation::second_argument_type value;
+    _Operation                                op;
+    typename _Operation::second_argument_type value;
 public:
     _LIBCPP_INLINE_VISIBILITY
-    binder2nd(const __Operation& __x, const typename __Operation::second_argument_type __y)
+    binder2nd(const _Operation& __x, const typename _Operation::second_argument_type __y)
         : op(__x), value(__y) {}
-    _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
-        (      typename __Operation::first_argument_type& __x) const
+    _LIBCPP_INLINE_VISIBILITY typename _Operation::result_type operator()
+        (      typename _Operation::first_argument_type& __x) const
             {return op(__x, value);}
-    _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
-        (const typename __Operation::first_argument_type& __x) const
+    _LIBCPP_INLINE_VISIBILITY typename _Operation::result_type operator()
+        (const typename _Operation::first_argument_type& __x) const
             {return op(__x, value);}
 };
 
-template <class __Operation, class _Tp>
+template <class _Operation, class _Tp>
 _LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
-binder2nd<__Operation>
-bind2nd(const __Operation& __op, const _Tp& __x)
-    {return binder2nd<__Operation>(__op, __x);}
+binder2nd<_Operation>
+bind2nd(const _Operation& __op, const _Tp& __x)
+    {return binder2nd<_Operation>(__op, __x);}
 
 #endif // _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FUNCTIONAL_BINDER2ND_H

libcxx/include/__fwd/mdspan.h

 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 23
 
 // Layout policy with a mapping which corresponds to FORTRAN-style array layouts
 struct layout_left {
-  template <class Extents>
+  template <class _Extents>
   class mapping;
 };
 
 // Layout policy with a mapping which corresponds to C-style array layouts
 struct layout_right {
-  template <class Extents>
+  template <class _Extents>
   class mapping;
 };
 
 /*
 // Will be implemented with follow on revision
 // Layout policy with a unique mapping where strides are arbitrary
 struct layout_stride {
   template<class Extents>

libcxx/include/__stop_token/stop_callback.h

_LIBCPP_HIDE_FROM_ABI explicit stop_callback(__private_tag, _StatePtr&& __state, _Cb&& __cb) noexcept(
         __state_() {
     if (__state && __state->__add_callback(this)) {
       // st.stop_requested() was false and this is successfully added to the linked list
       __state_ = std::forward<_StatePtr>(__state);
     }
   }
 };
 
-template <class Callback>
-_LIBCPP_AVAILABILITY_SYNC stop_callback(stop_token, Callback) -> stop_callback<Callback>;
+template <class _Callback>
+_LIBCPP_AVAILABILITY_SYNC stop_callback(stop_token, _Callback) -> stop_callback<_Callback>;
 
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)

libcxx/include/experimental/propagate_const

_LIBCPP_HIDE_FROM_ABI explicit _LIBCPP_CONSTEXPR operator bool() const
     return get() != nullptr;
   }
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const element_type* operator->() const
   {
     return get();
   }
 
-  template <class _Tp_ = _Tp, class _Up = enable_if_t<is_convertible<
-                                  const _Tp_, const element_type *>::value>>
+  template <class _Dummy = _Tp, class _Up = enable_if_t<is_convertible<
+                                  const _Dummy, const element_type *>::value>>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR operator const element_type *() const {
     return get();
   }
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const element_type& operator*() const
   {
     return *get();
   }
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR element_type* operator->()
   {
     return get();
   }
 
-  template <class _Tp_ = _Tp, class _Up = enable_if_t<
-                                  is_convertible<_Tp_, element_type *>::value>>
+  template <class _Dummy = _Tp, class _Up = enable_if_t<
+                                  is_convertible<_Dummy, element_type *>::value>>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR operator element_type *() {
     return get();
   }
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR element_type& operator*()
   {
     return *get();
   }

libcxx/include/experimental/type_traits

 
 template <template<class...> class _Op, class... _Args>
   using is_detected = typename _DETECTOR<nonesuch, void, _Op, _Args...>::value_t;
 template <template<class...> class _Op, class... _Args>
   using detected_t = typename _DETECTOR<nonesuch, void, _Op, _Args...>::type;
 template <template<class...> class _Op, class... _Args>
   _LIBCPP_CONSTEXPR bool is_detected_v = is_detected<_Op, _Args...>::value;
 
-template <class Default, template<class...> class _Op, class... _Args>
-  using detected_or = _DETECTOR<Default, void, _Op, _Args...>;
-template <class Default, template<class...> class _Op, class... _Args>
-  using detected_or_t = typename detected_or<Default, _Op, _Args...>::type;
-
-template <class Expected, template<class...> class _Op, class... _Args>
-  using is_detected_exact = is_same<Expected, detected_t<_Op, _Args...>>;
-template <class Expected, template<class...> class _Op, class... _Args>
-  _LIBCPP_CONSTEXPR bool is_detected_exact_v = is_detected_exact<Expected, _Op, _Args...>::value;
-
-template <class To, template<class...> class _Op, class... _Args>
-  using is_detected_convertible = is_convertible<detected_t<_Op, _Args...>, To>;
-template <class To, template<class...> class _Op, class... _Args>
-  _LIBCPP_CONSTEXPR bool is_detected_convertible_v = is_detected_convertible<To, _Op, _Args...>::value;
+template <class _Default, template<class...> class _Op, class... _Args>
+  using detected_or = _DETECTOR<_Default, void, _Op, _Args...>;
+template <class _Default, template<class...> class _Op, class... _Args>
+  using detected_or_t = typename detected_or<_Default, _Op, _Args...>::type;
+
+template <class _Expected, template<class...> class _Op, class... _Args>
+  using is_detected_exact = is_same<_Expected, detected_t<_Op, _Args...>>;
+template <class _Expected, template<class...> class _Op, class... _Args>
+  _LIBCPP_CONSTEXPR bool is_detected_exact_v = is_detected_exact<_Expected, _Op, _Args...>::value;
+
+template <class _To, template<class...> class _Op, class... _Args>
+  using is_detected_convertible = is_convertible<detected_t<_Op, _Args...>, _To>;
+template <class _To, template<class...> class _Op, class... _Args>
+  _LIBCPP_CONSTEXPR bool is_detected_convertible_v = is_detected_convertible<_To, _Op, _Args...>::value;
 
 
 _LIBCPP_END_NAMESPACE_LFTS
 
 #endif /* _LIBCPP_STD_VER >= 14 */
 
 #endif /* _LIBCPP_EXPERIMENTAL_TYPE_TRAITS */

libcxx/include/locale

 };
 
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages_byname<char>;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages_byname<wchar_t>;
 #endif
 
 template<class _Codecvt, class _Elem = wchar_t,
-         class _Wide_alloc = allocator<_Elem>,
-         class _Byte_alloc = allocator<char> >
+         class _WideAlloc = allocator<_Elem>,
+         class _ByteAlloc = allocator<char> >
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 wstring_convert
 {
 public:
-    typedef basic_string<char, char_traits<char>, _Byte_alloc>   byte_string;
-    typedef basic_string<_Elem, char_traits<_Elem>, _Wide_alloc> wide_string;
-    typedef typename _Codecvt::state_type                        state_type;
-    typedef typename wide_string::traits_type::int_type          int_type;
+    typedef basic_string<char, char_traits<char>, _ByteAlloc>   byte_string;
+    typedef basic_string<_Elem, char_traits<_Elem>, _WideAlloc> wide_string;
+    typedef typename _Codecvt::state_type                       state_type;
+    typedef typename wide_string::traits_type::int_type         int_type;
 
 private:
     byte_string __byte_err_string_;
     wide_string __wide_err_string_;
     _Codecvt* __cvtptr_;
     state_type __cvtstate_;
     size_t __cvtcount_;
 
#endif
 
     _LIBCPP_INLINE_VISIBILITY
     size_t converted() const _NOEXCEPT {return __cvtcount_;}
     _LIBCPP_INLINE_VISIBILITY
     state_type state() const {return __cvtstate_;}
 };
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
-template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
+template<class _Codecvt, class _Elem, class _WideAlloc, class _ByteAlloc>
 inline
-wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
+wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::
     wstring_convert(_Codecvt* __pcvt)
         : __cvtptr_(__pcvt), __cvtstate_(), __cvtcount_(0)
 {
 }
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
-template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
+template<class _Codecvt, class _Elem, class _WideAlloc, class _ByteAlloc>
 inline
-wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
+wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::
     wstring_convert(_Codecvt* __pcvt, state_type __state)
         : __cvtptr_(__pcvt), __cvtstate_(__state), __cvtcount_(0)
 {
 }
 
-template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
-wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
+template<class _Codecvt, class _Elem, class _WideAlloc, class _ByteAlloc>
+wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::
     wstring_convert(const byte_string& __byte_err, const wide_string& __wide_err)
         : __byte_err_string_(__byte_err), __wide_err_string_(__wide_err),
           __cvtstate_(), __cvtcount_(0)
 {
     __cvtptr_ = new _Codecvt;
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
-template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
+template<class _Codecvt, class _Elem, class _WideAlloc, class _ByteAlloc>
 inline
-wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
+wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::
     wstring_convert(wstring_convert&& __wc)
         : __byte_err_string_(_VSTD::move(__wc.__byte_err_string_)),
           __wide_err_string_(_VSTD::move(__wc.__wide_err_string_)),
           __cvtptr_(__wc.__cvtptr_),
           __cvtstate_(__wc.__cvtstate_), __cvtcount_(__wc.__cvtcount_)
 {
     __wc.__cvtptr_ = nullptr;
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
-template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
-wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::~wstring_convert()
+template<class _Codecvt, class _Elem, class _WideAlloc, class _ByteAlloc>
+wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::~wstring_convert()
 {
     delete __cvtptr_;
 }
 
-template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
-typename wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::wide_string
-wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
+template<class _Codecvt, class _Elem, class _WideAlloc, class _ByteAlloc>
+typename wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::wide_string
+wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::
     from_bytes(const char* __frm, const char* __frm_end)
 {
 _LIBCPP_SUPPRESS_DEPRECATED_POP
     __cvtcount_ = 0;
     if (__cvtptr_ != nullptr)
     {
         wide_string __ws(2*(__frm_end - __frm), _Elem());
         if (__frm != __frm_end)
_LIBCPP_SUPPRESS_DEPRECATED_POP
     }
 
     if (__wide_err_string_.empty())
         __throw_range_error("wstring_convert: from_bytes error");
 
     return __wide_err_string_;
 }
 
-template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
-typename wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::byte_string
-wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
+template<class _Codecvt, class _Elem, class _WideAlloc, class _ByteAlloc>
+typename wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::byte_string
+wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::
     to_bytes(const _Elem* __frm, const _Elem* __frm_end)
 {
     __cvtcount_ = 0;
     if (__cvtptr_ != nullptr)
     {
         byte_string __bs(2*(__frm_end - __frm), char());
         if (__frm != __frm_end)
             __bs.resize(__bs.capacity());

libcxx/include/optional

 >;
 
 template<class _Tp>
 class optional;
 
 #if _LIBCPP_STD_VER >= 20
 
 template <class _Tp>
-concept __is_derived_from_optional = requires(const _Tp& __t) { []<class __Up>(const optional<__Up>&) {}(__t); };
+concept __is_derived_from_optional = requires(const _Tp& __t) { []<class _Up>(const optional<_Up>&) {}(__t); };
 
 #  endif // _LIBCPP_STD_VER >= 20
 
 template <class _Tp>
 struct __is_std_optional : false_type {};
 template <class _Tp> struct __is_std_optional<optional<_Tp>> : true_type {};
 
 template <class _Tp>

libcxx/include/queue

void swap(queue& __q)
         _NOEXCEPT_(__is_nothrow_swappable<container_type>::value)
     {
         using _VSTD::swap;
         swap(c, __q.c);
     }
 
     _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI const _Container& __get_container() const { return c; }
 
-    template <class _T1, class _C1>
+    template <class _T1, class _OtherContainer>
     friend
     _LIBCPP_INLINE_VISIBILITY
     bool
-    operator==(const queue<_T1, _C1>& __x,const queue<_T1, _C1>& __y);
+    operator==(const queue<_T1, _OtherContainer>& __x,const queue<_T1, _OtherContainer>& __y);
 
-    template <class _T1, class _C1>
+    template <class _T1, class _OtherContainer>
     friend
     _LIBCPP_INLINE_VISIBILITY
     bool
-    operator< (const queue<_T1, _C1>& __x,const queue<_T1, _C1>& __y);
+    operator< (const queue<_T1, _OtherContainer>& __x,const queue<_T1, _OtherContainer>& __y);
 };
 
 #if _LIBCPP_STD_VER >= 17
 template<class _Container,
          class = enable_if_t<!__is_allocator<_Container>::value>
 >
 queue(_Container)
     -> queue<typename _Container::value_type, _Container>;

libcxx/include/semaphore

public:
     void acquire()
     {
         auto const __test_fn = [this]() -> bool {
             auto __old = __a_.load(memory_order_relaxed);
             return (__old != 0) && __a_.compare_exchange_strong(__old, __old - 1, memory_order_acquire, memory_order_relaxed);
         };
         __cxx_atomic_wait(&__a_.__a_, __test_fn);
     }
-    template <class Rep, class Period>
+    template <class _Rep, class _Period>
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    bool try_acquire_for(chrono::duration<Rep, Period> const& __rel_time)
+    bool try_acquire_for(chrono::duration<_Rep, _Period> const& __rel_time)
     {
-        if (__rel_time == chrono::duration<Rep, Period>::zero())
+        if (__rel_time == chrono::duration<_Rep, _Period>::zero())
             return try_acquire();
         auto const __test_fn = [this]() { return try_acquire(); };
         return std::__libcpp_thread_poll_with_backoff(__test_fn, __libcpp_timed_backoff_policy(), __rel_time);
     }
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     bool try_acquire()
     {
         auto __old = __a_.load(memory_order_acquire);
void release(ptrdiff_t __update = 1)
         _LIBCPP_ASSERT_UNCATEGORIZED(__update >= 0, "counting_semaphore:release called with a negative value");
         __semaphore_.release(__update);
     }
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     void acquire()
     {
         __semaphore_.acquire();
     }
-    template<class Rep, class Period>
+    template<class _Rep, class _Period>
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    bool try_acquire_for(chrono::duration<Rep, Period> const& __rel_time)
+    bool try_acquire_for(chrono::duration<_Rep, _Period> const& __rel_time)
     {
         return __semaphore_.try_acquire_for(chrono::duration_cast<chrono::nanoseconds>(__rel_time));
     }
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     bool try_acquire()
     {
         return __semaphore_.try_acquire();
     }
-    template <class Clock, class Duration>
+    template <class _Clock, class _Duration>
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    bool try_acquire_until(chrono::time_point<Clock, Duration> const& __abs_time)
+    bool try_acquire_until(chrono::time_point<_Clock, _Duration> const& __abs_time)
     {
-        auto const __current = Clock::now();
+        auto const __current = _Clock::now();
         if (__current >= __abs_time)
             return try_acquire();
         else
             return try_acquire_for(__abs_time - __current);
     }
 };
 
 using binary_semaphore = counting_semaphore<1>;

libcxx/include/shared_mutex

_LIBCPP_HIDE_FROM_ABI shared_lock& operator=(shared_lock&& __u) _NOEXCEPT {
     __owns_     = __u.__owns_;
     __u.__m_    = nullptr;
     __u.__owns_ = false;
     return *this;
   }
 
   _LIBCPP_HIDE_FROM_ABI void lock();
   _LIBCPP_HIDE_FROM_ABI bool try_lock();
-  template <class Rep, class Period>
-  _LIBCPP_HIDE_FROM_ABI bool try_lock_for(const chrono::duration<Rep, Period>& __rel_time);
-  template <class Clock, class Duration>
-  _LIBCPP_HIDE_FROM_ABI bool try_lock_until(const chrono::time_point<Clock, Duration>& __abs_time);
+  template <class _Rep, class _Period>
+  _LIBCPP_HIDE_FROM_ABI bool try_lock_for(const chrono::duration<_Rep, _Period>& __rel_time);
+  template <class _Clock, class _Duration>
+  _LIBCPP_HIDE_FROM_ABI bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __abs_time);
   _LIBCPP_HIDE_FROM_ABI void unlock();
 
   // Setters
   _LIBCPP_HIDE_FROM_ABI void swap(shared_lock& __u) _NOEXCEPT {
     _VSTD::swap(__m_, __u.__m_);
     _VSTD::swap(__owns_, __u.__owns_);
   }
 

libcxx/include/stack

void swap(stack& __s)
         _NOEXCEPT_(__is_nothrow_swappable<container_type>::value)
     {
         using _VSTD::swap;
         swap(c, __s.c);
     }
 
     _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI const _Container& __get_container() const { return c; }
 
-    template <class T1, class _C1>
+    template <class _T1, class _OtherContainer>
     friend
     bool
-    operator==(const stack<T1, _C1>& __x, const stack<T1, _C1>& __y);
+    operator==(const stack<_T1, _OtherContainer>& __x, const stack<_T1, _OtherContainer>& __y);
 
-    template <class T1, class _C1>
+    template <class _T1, class _OtherContainer>
     friend
     bool
-    operator< (const stack<T1, _C1>& __x, const stack<T1, _C1>& __y);
+    operator< (const stack<_T1, _OtherContainer>& __x, const stack<_T1, _OtherContainer>& __y);
 };
 
 #if _LIBCPP_STD_VER >= 17
 template<class _Container,
          class = enable_if_t<!__is_allocator<_Container>::value>
 >
 stack(_Container)
     -> stack<typename _Container::value_type, _Container>;

libcxx/include/tuple

#if _LIBCPP_STD_VER >= 23
     _LIBCPP_HIDE_FROM_ABI constexpr
         explicit(!(is_convertible_v<const _Up&&, _Tp> && ...))
     tuple(allocator_arg_t, const _Alloc& __alloc, const tuple<_Up...>&& __t)
         : __base_(allocator_arg_t(), __alloc, std::move(__t)) {}
 #endif // _LIBCPP_STD_VER >= 23
 
     // tuple(const pair<U1, U2>&) constructors (including allocator_arg_t variants)
 
-    template <template <class...> class Pred, class _Pair, class _DecayedPair = __remove_cvref_t<_Pair>, class _Tuple = tuple>
+    template <template <class...> class _Pred, class _Pair, class _DecayedPair = __remove_cvref_t<_Pair>, class _Tuple = tuple>
     struct _CtorPredicateFromPair : false_type{};
 
-    template <template <class...> class Pred, class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2>
-    struct _CtorPredicateFromPair<Pred, _Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> > : _And<
-        Pred<_Tp1, __copy_cvref_t<_Pair, _Up1> >,
-        Pred<_Tp2, __copy_cvref_t<_Pair, _Up2> >
+    template <template <class...> class _Pred, class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2>
+    struct _CtorPredicateFromPair<_Pred, _Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> > : _And<
+        _Pred<_Tp1, __copy_cvref_t<_Pair, _Up1> >,
+        _Pred<_Tp2, __copy_cvref_t<_Pair, _Up2> >
     > {};
 
     template <class _Pair>
     struct _EnableCtorFromPair : _CtorPredicateFromPair<is_constructible, _Pair>{};
 
     template <class _Pair>
     struct _NothrowConstructibleFromPair : _CtorPredicateFromPair<is_nothrow_constructible, _Pair>{};
 
const tuple& operator=(tuple<_UTypes...>&& __u) const {
         std::__memberwise_forward_assign(*this,
                                          __u,
                                          __tuple_types<_UTypes...>(),
                                          typename __make_tuple_indices<sizeof...(_Tp)>::type());
         return *this;
     }
 #endif // _LIBCPP_STD_VER >= 23
 
-    template <template<class...> class Pred, bool _Const,
+    template <template<class...> class _Pred, bool _Const,
               class _Pair, class _DecayedPair = __remove_cvref_t<_Pair>, class _Tuple = tuple>
     struct _AssignPredicateFromPair : false_type {};
 
-    template <template<class...> class Pred, bool _Const,
+    template <template<class...> class _Pred, bool _Const,
               class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2>
-    struct _AssignPredicateFromPair<Pred, _Const, _Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> > :
-        _And<Pred<__maybe_const<_Const, _Tp1>&, __copy_cvref_t<_Pair, _Up1> >,
-             Pred<__maybe_const<_Const, _Tp2>&, __copy_cvref_t<_Pair, _Up2> >
+    struct _AssignPredicateFromPair<_Pred, _Const, _Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> > :
+        _And<_Pred<__maybe_const<_Const, _Tp1>&, __copy_cvref_t<_Pair, _Up1> >,
+             _Pred<__maybe_const<_Const, _Tp2>&, __copy_cvref_t<_Pair, _Up2> >
             > {};
 
     template <bool _Const, class _Pair>
     struct _EnableAssignFromPair : _AssignPredicateFromPair<is_assignable, _Const, _Pair> {};
 
     template <bool _Const, class _Pair>
     struct _NothrowAssignFromPair : _AssignPredicateFromPair<is_nothrow_assignable, _Const, _Pair> {};
 

libcxx/include/variant

 struct __overload<bool const volatile, _Idx> : __overload_bool<bool const volatile, _Idx> {};
 
 template <class ..._Bases>
 struct __all_overloads : _Bases... {
   void operator()() const;
   using _Bases::operator()...;
 };
 
-template <class IdxSeq>
+template <class _IdxSeq>
 struct __make_overloads_imp;
 
 template <size_t ..._Idx>
 struct __make_overloads_imp<__tuple_indices<_Idx...> > {
   template <class ..._Types>
   using _Apply _LIBCPP_NODEBUG = __all_overloads<__overload<_Types, _Idx>...>;
 };
 

libcxx/include/vector

 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <>
 inline constexpr bool __format::__enable_insertable<vector<wchar_t>> = true;
 #endif
 
 #endif // _LIBCPP_STD_VER >= 20
 
 #if _LIBCPP_STD_VER >= 23
-template <class _Tp, class CharT>
+template <class _Tp, class _CharT>
 // Since is-vector-bool-reference is only used once it's inlined here.
   requires same_as<typename _Tp::__container, vector<bool, typename _Tp::__container::allocator_type>>
-struct _LIBCPP_TEMPLATE_VIS formatter<_Tp, CharT> {
+struct _LIBCPP_TEMPLATE_VIS formatter<_Tp, _CharT> {
 private:
-  formatter<bool, CharT> __underlying_;
+  formatter<bool, _CharT> __underlying_;
 
 public:
   template <class _ParseContext>
   _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
         return __underlying_.parse(__ctx);
   }
 
   template <class _FormatContext>