[libc++] Make parameter names consistent and enforce the naming style using readability-identifier-naming

[philnik]

Summary

Ensure that parameter names have the style __lower_case

[philnik]

• Try to fix CI

[Mordante]

Thanks for the cleanup! Some small comments.
Did you use clang-tidy to find these? If so maybe add an attribution in the commit message.

Since the CI fails I would like to have a look at the next version.

libcxx/include/__format/formatter.h

76

Nice catch! Can you undo this change? It will be removed in D128846.

libcxx/include/__format/formatter_output.h

36–37

This is the duplicate and this version will be the only one after D128846.

libcxx/include/charconv

619

I don't feel this aids the readability, so I would prefer to keep it as-is.
Instead rename _Last to __l.
In general it's good to use longer names for the larger scope.

654

Likewise please keep this __base.

libcxx/include/regex

2971

I have a preference to use __c, without a named argument it almost sounds like the argument is unused.

[philnik]

• Address comments

libcxx/include/__format/formatter.h

76

I'd rather keep this change in, since clang-tidy would fail otherwise or we couldn't enforce the proper naming.

libcxx/include/regex

2971

My general approach is that if the name isn't useful to the reader in the declaration just don't add one. Saying "this char is really a character" isn't exactly useful IMO. I've also removed some path p in filesystem somewhere. In general I'm assuming that arguments are used, especially in implementation-detail functions. Our code-base isn't so large that it would be impractical to remove an argument everywhere in a single patch.

[Mordante]

libcxx/include/__format/formatter.h

76

I already landed the patch so this code no longer exists.

I really like these cleanup patches, but I really would like to urge you to be careful about creating merge conflicts in actively in flight patches. I don't ask you to actively search for them, but please ping people when the patch touches code in areas other's are working on. We can land this patch without enforcing the clang-tidy test and enable the test at a later time.

libcxx/include/regex

2971

I disagree. I really dislike the idea just to remove variables names because we can. Names have meaning for the reader even simple names. When there's no name you don't know whether it just was a simple name or a special name just removed.

[philnik]

• Rebased
• Try to fix CI

libcxx/include/__format/formatter.h

76

I don't want to create more work for people, but I think there is a balance here. If you would have said that this causes problems in multiple places I would have been happy to wait for the other patches to land first. OTOH enforcing proper naming in the CI outweighs having to resolve a single merge conflict IMO.
I can try to ping people in future patches, but there would probably be a high false-positive rate. Most of the clang-tidy cleanups touch a lot of files, but only a few lines per file (other than really bad offenders like locale_win32.h). This makes it very hard to determine if anybody is actually touching that code and I would probably have to ping everyone who is working on libc++ currently in this patch.
Hui and Konstantin because of the changes in the algorithms; you because of the changes in format and I don't really know what Louis is working on, but there is probably something in here.

libcxx/include/regex

2971

Having a simple name could just as well mean that someone didn't think of a good name or didn't update it in the declaration. I don't think having __c there helps me in any way to know that. I'm not saying that we should just remove all argument names. I'm saying that single-letter names or names that are essentially just the type (like basic_string __str) are useless to the reader and should be omitted.

As an example, this is from <string>:

friend _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string operator+<>(const basic_string&, const basic_string&);
friend _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string operator+<>(const value_type*, const basic_string&);
friend _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string operator+<>(value_type, const basic_string&);
friend _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string operator+<>(const basic_string&, const value_type*);
friend _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string operator+<>(const basic_string&, value_type);

vs.

friend _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string operator+<>(const basic_string& __x, const basic_string& __y);
friend _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string operator+<>(const value_type* __x, const basic_string& __y);
friend _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string operator+<>(value_type __x, const basic_string& __y);
friend _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string operator+<>(const basic_string& __x, const value_type* __y);
friend _LIBCPP_CONSTEXPR_AFTER_CXX17 basic_string operator+<>(const basic_string& __x, value_type __y);

IMO the extra names are just noise which make the declarations harder to read.
@ldionne What's your take on this?

[ldionne]

libcxx/include/__filesystem/operations.h

42

In the other functions we use __ec = nullptr, let's keep that for consistency. This applies to several functions you modified here.

libcxx/include/charconv

662

This shuffling around of variables names is tricky, but I checked and I think it's correct.

libcxx/include/regex

2971

I'd tend to agree with @philnik on this one. We shouldn't go around eagerly removing parameter names just because we can, however I see little benefit to keeping names that really don't bring any additional semantical information, like it's the case for __c here. We already know what the parameter is, it's a char because the type is CharType.

All in all, this is a small issue and I'm OK with either approach, but if this were my patch, I would probably have removed the parameter name because it's what makes most sense to me.

libcxx/.clang-tidy

Checks: >
   misc-misplaced-const,
   misc-non-copyable-objects,
   misc-uniqueptr-reset-release,
 
   modernize-loop-convert,
   modernize-redundant-void-arg,
 
   readability-duplicate-include,
+  readability-identifier-naming,
   readability-function-cognitive-complexity,
   readability-function-size,
   readability-misplaced-array-index,
   readability-redundant-control-flow,
   readability-redundant-function-ptr-dereference,
   readability-redundant-preprocessor,
   readability-simplify-subscript-expr,
   readability-uniqueptr-delete-release,
 
 CheckOptions:
   - key:   readability-function-cognitive-complexity.Threshold
     value: 143 # TODO: bring that number down
   - key:   readability-function-size.LineThreshold
     value: 194 # TODO: bring that number down
+  - key:   readability-identifier-naming.GetConfigPerFile
+    value: false
+  - key:   readability-identifier-naming.ParameterCase
+    value: lower_case
+  - key:   readability-identifier-naming.ParameterPrefix
+    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/__algorithm/binary_search.h

 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ForwardIterator, class _Tp, class _Compare>
 _LIBCPP_NODISCARD_EXT inline
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
-binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
+binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp)
 {
     using _Comp_ref = typename __comp_ref_type<_Compare>::type;
-    __first = std::lower_bound<_ForwardIterator, _Tp, _Comp_ref>(__first, __last, __value_, __comp);
-    return __first != __last && !__comp(__value_, *__first);
+    __first = std::lower_bound<_ForwardIterator, _Tp, _Comp_ref>(__first, __last, __value, __comp);
+    return __first != __last && !__comp(__value, *__first);
 }
 
 template <class _ForwardIterator, class _Tp>
 _LIBCPP_NODISCARD_EXT inline
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
-binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
+binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
 {
-    return std::binary_search(__first, __last, __value_,
+    return std::binary_search(__first, __last, __value,
                               __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_BINARY_SEARCH_H

libcxx/include/__algorithm/count.h

 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _Tp>
 _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     typename iterator_traits<_InputIterator>::difference_type
-    count(_InputIterator __first, _InputIterator __last, const _Tp& __value_) {
+    count(_InputIterator __first, _InputIterator __last, const _Tp& __value) {
   typename iterator_traits<_InputIterator>::difference_type __r(0);
   for (; __first != __last; ++__first)
-    if (*__first == __value_)
+    if (*__first == __value)
       ++__r;
   return __r;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_COUNT_H

libcxx/include/__algorithm/equal_range.h

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Compare, class _ForwardIterator, class _Tp>
 _LIBCPP_CONSTEXPR_AFTER_CXX17 pair<_ForwardIterator, _ForwardIterator>
-__equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
+__equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp)
 {
     typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
     difference_type __len = _VSTD::distance(__first, __last);
     while (__len != 0)
     {
         difference_type __l2 = _VSTD::__half_positive(__len);
         _ForwardIterator __m = __first;
         _VSTD::advance(__m, __l2);
-        if (__comp(*__m, __value_))
+        if (__comp(*__m, __value))
         {
             __first = ++__m;
             __len -= __l2 + 1;
         }
-        else if (__comp(__value_, *__m))
+        else if (__comp(__value, *__m))
         {
             __last = __m;
             __len = __l2;
         }
         else
         {
             auto __proj = std::__identity();
             _ForwardIterator __mp1 = __m;
             return pair<_ForwardIterator, _ForwardIterator>
                    (
-                      _VSTD::__lower_bound_impl<_StdIterOps>(__first, __m, __value_, __comp, __proj),
-                      _VSTD::__upper_bound<_Compare>(++__mp1, __last, __value_, __comp)
+                      _VSTD::__lower_bound_impl<_StdIterOps>(__first, __m, __value, __comp, __proj),
+                      _VSTD::__upper_bound<_Compare>(++__mp1, __last, __value, __comp)
                    );
         }
     }
     return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
 }
 
 template <class _ForwardIterator, class _Tp, class _Compare>
 _LIBCPP_NODISCARD_EXT inline
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 pair<_ForwardIterator, _ForwardIterator>
-equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
+equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp)
 {
     typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
-    return _VSTD::__equal_range<_Comp_ref>(__first, __last, __value_, __comp);
+    return _VSTD::__equal_range<_Comp_ref>(__first, __last, __value, __comp);
 }
 
 template <class _ForwardIterator, class _Tp>
 _LIBCPP_NODISCARD_EXT inline
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 pair<_ForwardIterator, _ForwardIterator>
-equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
+equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
 {
-    return _VSTD::equal_range(__first, __last, __value_,
+    return _VSTD::equal_range(__first, __last, __value,
                              __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_EQUAL_RANGE_H

libcxx/include/__algorithm/fill.h

 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ForwardIterator, class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
-__fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, forward_iterator_tag)
+__fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, forward_iterator_tag)
 {
     for (; __first != __last; ++__first)
-        *__first = __value_;
+        *__first = __value;
 }
 
 template <class _RandomAccessIterator, class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
-__fill(_RandomAccessIterator __first, _RandomAccessIterator __last, const _Tp& __value_, random_access_iterator_tag)
+__fill(_RandomAccessIterator __first, _RandomAccessIterator __last, const _Tp& __value, random_access_iterator_tag)
 {
-    _VSTD::fill_n(__first, __last - __first, __value_);
+    _VSTD::fill_n(__first, __last - __first, __value);
 }
 
 template <class _ForwardIterator, class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
-fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
+fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
 {
-    _VSTD::__fill(__first, __last, __value_, typename iterator_traits<_ForwardIterator>::iterator_category());
+    _VSTD::__fill(__first, __last, __value, typename iterator_traits<_ForwardIterator>::iterator_category());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_FILL_H

libcxx/include/__algorithm/fill_n.h

 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _OutputIterator, class _Size, class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _OutputIterator
-__fill_n(_OutputIterator __first, _Size __n, const _Tp& __value_)
+__fill_n(_OutputIterator __first, _Size __n, const _Tp& __value)
 {
     for (; __n > 0; ++__first, (void) --__n)
-        *__first = __value_;
+        *__first = __value;
     return __first;
 }
 
 template <class _OutputIterator, class _Size, class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _OutputIterator
-fill_n(_OutputIterator __first, _Size __n, const _Tp& __value_)
+fill_n(_OutputIterator __first, _Size __n, const _Tp& __value)
 {
-   return _VSTD::__fill_n(__first, _VSTD::__convert_to_integral(__n), __value_);
+   return _VSTD::__fill_n(__first, _VSTD::__convert_to_integral(__n), __value);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_FILL_N_H

libcxx/include/__algorithm/find.h

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _Tp>
 _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _InputIterator
-find(_InputIterator __first, _InputIterator __last, const _Tp& __value_) {
+find(_InputIterator __first, _InputIterator __last, const _Tp& __value) {
   for (; __first != __last; ++__first)
-    if (*__first == __value_)
+    if (*__first == __value)
       break;
   return __first;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_FIND_H

libcxx/include/__algorithm/lower_bound.h

if (std::__invoke(__comp, std::__invoke(__proj, *__m), __value)) {
       __len = __l2;
     }
   }
   return __first;
 }
 
 template <class _ForwardIterator, class _Tp, class _Compare>
 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
-_ForwardIterator lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) {
+_ForwardIterator lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp) {
   static_assert(__is_callable<_Compare, decltype(*__first), const _Tp&>::value,
                 "The comparator has to be callable");
   auto __proj = std::__identity();
-  return std::__lower_bound_impl<_StdIterOps>(__first, __last, __value_, __comp, __proj);
+  return std::__lower_bound_impl<_StdIterOps>(__first, __last, __value, __comp, __proj);
 }
 
 template <class _ForwardIterator, class _Tp>
 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
-_ForwardIterator lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) {
-  return std::lower_bound(__first, __last, __value_,
+_ForwardIterator lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
+  return std::lower_bound(__first, __last, __value,
                           __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_LOWER_BOUND_H

libcxx/include/__algorithm/minmax_element.h

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Comp, class _Proj>
 class _MinmaxElementLessFunc {
-  _Comp& __comp;
-  _Proj& __proj;
+  _Comp& __comp_;
+  _Proj& __proj_;
 
 public:
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-  _MinmaxElementLessFunc(_Comp& __comp_, _Proj& __proj_) : __comp(__comp_), __proj(__proj_) {}
+  _MinmaxElementLessFunc(_Comp& __comp, _Proj& __proj) : __comp_(__comp), __proj_(__proj) {}
 
   template <class _Iter>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11
   bool operator()(_Iter& __it1, _Iter& __it2) {
-    return std::__invoke(__comp, std::__invoke(__proj, *__it1), std::__invoke(__proj, *__it2));
+    return std::__invoke(__comp_, std::__invoke(__proj_, *__it1), std::__invoke(__proj_, *__it2));
   }
 };
 
 template <class _Iter, class _Sent, class _Proj, class _Comp>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11
 pair<_Iter, _Iter> __minmax_element_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
   auto __less = _MinmaxElementLessFunc<_Comp, _Proj>(__comp, __proj);
 

libcxx/include/__algorithm/remove.h

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ForwardIterator, class _Tp>
 _LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
-remove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
+remove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
 {
-    __first = _VSTD::find(__first, __last, __value_);
+    __first = _VSTD::find(__first, __last, __value);
     if (__first != __last)
     {
         _ForwardIterator __i = __first;
         while (++__i != __last)
         {
-            if (!(*__i == __value_))
+            if (!(*__i == __value))
             {
                 *__first = _VSTD::move(*__i);
                 ++__first;
             }
         }
     }
     return __first;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_REMOVE_H

libcxx/include/__algorithm/remove_copy.h

 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _OutputIterator, class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _OutputIterator
-remove_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, const _Tp& __value_)
+remove_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, const _Tp& __value)
 {
     for (; __first != __last; ++__first)
     {
-        if (!(*__first == __value_))
+        if (!(*__first == __value))
         {
             *__result = *__first;
             ++__result;
         }
     }
     return __result;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_REMOVE_COPY_H

libcxx/include/__algorithm/search_n.h

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _BinaryPredicate, class _ForwardIterator, class _Size, class _Tp>
 _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator __search_n(_ForwardIterator __first, _ForwardIterator __last,
-                                                          _Size __count, const _Tp& __value_, _BinaryPredicate __pred,
+                                                          _Size __count, const _Tp& __value, _BinaryPredicate __pred,
                                                           forward_iterator_tag) {
   if (__count <= 0)
     return __first;
   while (true) {
     // Find first element in sequence that matchs __value_, with a mininum of loop checks
     while (true) {
       if (__first == __last) // return __last if no element matches __value_
         return __last;
-      if (__pred(*__first, __value_))
+      if (__pred(*__first, __value))
         break;
       ++__first;
     }
     // *__first matches __value_, now match elements after here
     _ForwardIterator __m = __first;
     _Size __c(0);
     while (true) {
       if (++__c == __count) // If pattern exhausted, __first is the answer (works for 1 element pattern)
         return __first;
       if (++__m == __last) // Otherwise if source exhaused, pattern not found
         return __last;
-      if (!__pred(*__m, __value_)) // if there is a mismatch, restart with a new __first
+      if (!__pred(*__m, __value)) // if there is a mismatch, restart with a new __first
       {
         __first = __m;
         ++__first;
         break;
       } // else there is a match, check next elements
     }
   }
 }
 
 template <class _BinaryPredicate, class _RandomAccessIterator, class _Size, class _Tp>
 _LIBCPP_CONSTEXPR_AFTER_CXX17 _RandomAccessIterator __search_n(_RandomAccessIterator __first,
                                                                _RandomAccessIterator __last, _Size __count,
-                                                               const _Tp& __value_, _BinaryPredicate __pred,
+                                                               const _Tp& __value, _BinaryPredicate __pred,
                                                                random_access_iterator_tag) {
   typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
   if (__count <= 0)
     return __first;
   _Size __len = static_cast<_Size>(__last - __first);
   if (__len < __count)
     return __last;
   const _RandomAccessIterator __s = __last - difference_type(__count - 1); // Start of pattern match can't go beyond here
   while (true) {
     // Find first element in sequence that matchs __value_, with a mininum of loop checks
     while (true) {
       if (__first >= __s) // return __last if no element matches __value_
         return __last;
-      if (__pred(*__first, __value_))
+      if (__pred(*__first, __value))
         break;
       ++__first;
     }
     // *__first matches __value_, now match elements after here
     _RandomAccessIterator __m = __first;
     _Size __c(0);
     while (true) {
       if (++__c == __count) // If pattern exhausted, __first is the answer (works for 1 element pattern)
         return __first;
       ++__m;                       // no need to check range on __m because __s guarantees we have enough source
-      if (!__pred(*__m, __value_)) // if there is a mismatch, restart with a new __first
+      if (!__pred(*__m, __value)) // if there is a mismatch, restart with a new __first
       {
         __first = __m;
         ++__first;
         break;
       } // else there is a match, check next elements
     }
   }
 }
 
 template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
 _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator search_n(
-    _ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value_, _BinaryPredicate __pred) {
+    _ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value, _BinaryPredicate __pred) {
   return _VSTD::__search_n<_BinaryPredicate&>(
-      __first, __last, _VSTD::__convert_to_integral(__count), __value_, __pred,
+      __first, __last, _VSTD::__convert_to_integral(__count), __value, __pred,
       typename iterator_traits<_ForwardIterator>::iterator_category());
 }
 
 template <class _ForwardIterator, class _Size, class _Tp>
 _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
-search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value_) {
+search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value) {
   typedef typename iterator_traits<_ForwardIterator>::value_type __v;
-  return _VSTD::search_n(__first, __last, _VSTD::__convert_to_integral(__count), __value_, __equal_to<__v, _Tp>());
+  return _VSTD::search_n(__first, __last, _VSTD::__convert_to_integral(__count), __value, __equal_to<__v, _Tp>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_SEARCH_N_H

libcxx/include/__algorithm/upper_bound.h

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Compare, class _ForwardIterator, class _Tp>
 _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
-__upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
+__upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp)
 {
     typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
     difference_type __len = _VSTD::distance(__first, __last);
     while (__len != 0)
     {
         difference_type __l2 = _VSTD::__half_positive(__len);
         _ForwardIterator __m = __first;
         _VSTD::advance(__m, __l2);
-        if (__comp(__value_, *__m))
+        if (__comp(__value, *__m))
             __len = __l2;
         else
         {
             __first = ++__m;
             __len -= __l2 + 1;
         }
     }
     return __first;
 }
 
 template <class _ForwardIterator, class _Tp, class _Compare>
 _LIBCPP_NODISCARD_EXT inline
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _ForwardIterator
-upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
+upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp)
 {
-    return _VSTD::__upper_bound<_Compare&>(__first, __last, __value_, __comp);
+    return _VSTD::__upper_bound<_Compare&>(__first, __last, __value, __comp);
 }
 
 template <class _ForwardIterator, class _Tp>
 _LIBCPP_NODISCARD_EXT inline
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _ForwardIterator
-upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
+upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
 {
-    return _VSTD::upper_bound(__first, __last, __value_,
+    return _VSTD::upper_bound(__first, __last, __value,
                              __less<_Tp, typename iterator_traits<_ForwardIterator>::value_type>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_UPPER_BOUND_H

libcxx/include/__bit_reference

if (__n > 0)
             return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__libcpp_ctz(__b)));
     }
     return _It(__first.__seg_, static_cast<unsigned>(__n));
 }
 
 template <class _Cp, bool _IsConst, class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 __bit_iterator<_Cp, _IsConst>
-find(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value_)
+find(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value)
 {
-    if (static_cast<bool>(__value_))
+    if (static_cast<bool>(__value))
         return _VSTD::__find_bool_true(__first, static_cast<typename _Cp::size_type>(__last - __first));
     return _VSTD::__find_bool_false(__first, static_cast<typename _Cp::size_type>(__last - __first));
 }
 
 // count
 
 template <class _Cp, bool _IsConst>
 typename __bit_iterator<_Cp, _IsConst>::difference_type
if (__n > 0)
         __r += _VSTD::__libcpp_popcount(~*__first.__seg_ & __m);
     }
     return __r;
 }
 
 template <class _Cp, bool _IsConst, class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename __bit_iterator<_Cp, _IsConst>::difference_type
-count(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value_)
+count(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value)
 {
-    if (static_cast<bool>(__value_))
+    if (static_cast<bool>(__value))
         return _VSTD::__count_bool_true(__first, static_cast<typename _Cp::size_type>(__last - __first));
     return _VSTD::__count_bool_false(__first, static_cast<typename _Cp::size_type>(__last - __first));
 }
 
 // fill_n
 
 template <class _Cp>
 void
if (__n > 0)
         __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
         *__first.__seg_ |= __m;
     }
 }
 
 template <class _Cp>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-fill_n(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n, bool __value_)
+fill_n(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n, bool __value)
 {
     if (__n > 0)
     {
-        if (__value_)
+        if (__value)
             _VSTD::__fill_n_true(__first, __n);
         else
             _VSTD::__fill_n_false(__first, __n);
     }
 }
 
 // fill
 
 template <class _Cp>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-fill(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __last, bool __value_)
+fill(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __last, bool __value)
 {
-    _VSTD::fill_n(__first, static_cast<typename _Cp::size_type>(__last - __first), __value_);
+    _VSTD::fill_n(__first, static_cast<typename _Cp::size_type>(__last - __first), __value);
 }
 
 // copy
 
 template <class _Cp, bool _IsConst>
 __bit_iterator<_Cp, false>
 __copy_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
                                                      __bit_iterator<_Cp, false> __result)

libcxx/include/__chrono/duration.h

#endif
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator++()      {++__rep_; return *this;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration  operator++(int)   {return duration(__rep_++);}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator--()      {--__rep_; return *this;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration  operator--(int)   {return duration(__rep_--);}
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator+=(const duration& __d) {__rep_ += __d.count(); return *this;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator-=(const duration& __d) {__rep_ -= __d.count(); return *this;}
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator*=(const rep& rhs) {__rep_ *= rhs; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator/=(const rep& rhs) {__rep_ /= rhs; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const rep& rhs) {__rep_ %= rhs; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const duration& rhs) {__rep_ %= rhs.count(); return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator*=(const rep& __rhs) {__rep_ *= __rhs; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator/=(const rep& __rhs) {__rep_ /= __rhs; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const rep& __rhs) {__rep_ %= __rhs; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const duration& __rhs) {__rep_ %= __rhs.count(); return *this;}
 
     // special values
 
     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration zero() _NOEXCEPT {return duration(duration_values<rep>::zero());}
     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration min()  _NOEXCEPT {return duration(duration_values<rep>::min());}
     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration max()  _NOEXCEPT {return duration(duration_values<rep>::max());}
 };
 

libcxx/include/__chrono/time_point.h

 
 public:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 time_point() : __d_(duration::zero()) {}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 explicit time_point(const duration& __d) : __d_(__d) {}
 
     // conversions
     template <class _Duration2>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
-    time_point(const time_point<clock, _Duration2>& t,
+    time_point(const time_point<clock, _Duration2>& __t,
         typename enable_if
         <
             is_convertible<_Duration2, duration>::value
         >::type* = nullptr)
-            : __d_(t.time_since_epoch()) {}
+            : __d_(__t.time_since_epoch()) {}
 
     // observer
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 duration time_since_epoch() const {return __d_;}
 
     // arithmetic
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 time_point& operator+=(const duration& __d) {__d_ += __d; return *this;}

libcxx/include/__chrono/year_month_weekday.h

public:
     _LIBCPP_HIDE_FROM_ABI year_month_weekday() = default;
     _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday(const chrono::year& __yval, const chrono::month& __mval,
                                const chrono::weekday_indexed& __wdival) noexcept
         : __y{__yval}, __m{__mval}, __wdi{__wdival} {}
     _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday(const sys_days& __sysd) noexcept
             : year_month_weekday(__from_days(__sysd.time_since_epoch())) {}
     _LIBCPP_HIDE_FROM_ABI inline explicit constexpr year_month_weekday(const local_days& __locd) noexcept
             : year_month_weekday(__from_days(__locd.time_since_epoch())) {}
-    _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday& operator+=(const months& m) noexcept;
-    _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday& operator-=(const months& m) noexcept;
-    _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday& operator+=(const years& y)  noexcept;
-    _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday& operator-=(const years& y)  noexcept;
+    _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday& operator+=(const months&) noexcept;
+    _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday& operator-=(const months&) noexcept;
+    _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday& operator+=(const years&)  noexcept;
+    _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday& operator-=(const years&)  noexcept;
 
     _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::year                       year() const noexcept { return __y; }
     _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::month                     month() const noexcept { return __m; }
     _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::weekday                 weekday() const noexcept { return __wdi.weekday(); }
     _LIBCPP_HIDE_FROM_ABI inline constexpr unsigned                          index() const noexcept { return __wdi.index(); }
     _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::weekday_indexed weekday_indexed() const noexcept { return __wdi; }
 
     _LIBCPP_HIDE_FROM_ABI inline constexpr                       operator sys_days() const noexcept { return   sys_days{__to_days()}; }

libcxx/include/__filesystem/copy_options.h

enum class _LIBCPP_ENUM_VIS copy_options : unsigned short {
   skip_symlinks = 32,
   directories_only = 64,
   create_symlinks = 128,
   create_hard_links = 256,
   __in_recursive_copy = 512,
 };
 
 _LIBCPP_INLINE_VISIBILITY
-inline constexpr copy_options operator&(copy_options _LHS, copy_options _RHS) {
-  return static_cast<copy_options>(static_cast<unsigned short>(_LHS) &
-                                   static_cast<unsigned short>(_RHS));
+inline constexpr copy_options operator&(copy_options __lhs, copy_options __rhs) {
+  return static_cast<copy_options>(static_cast<unsigned short>(__lhs) &
+                                   static_cast<unsigned short>(__rhs));
 }
 
 _LIBCPP_INLINE_VISIBILITY
-inline constexpr copy_options operator|(copy_options _LHS, copy_options _RHS) {
-  return static_cast<copy_options>(static_cast<unsigned short>(_LHS) |
-                                   static_cast<unsigned short>(_RHS));
+inline constexpr copy_options operator|(copy_options __lhs, copy_options __rhs) {
+  return static_cast<copy_options>(static_cast<unsigned short>(__lhs) |
+                                   static_cast<unsigned short>(__rhs));
 }
 
 _LIBCPP_INLINE_VISIBILITY
-inline constexpr copy_options operator^(copy_options _LHS, copy_options _RHS) {
-  return static_cast<copy_options>(static_cast<unsigned short>(_LHS) ^
-                                   static_cast<unsigned short>(_RHS));
+inline constexpr copy_options operator^(copy_options __lhs, copy_options __rhs) {
+  return static_cast<copy_options>(static_cast<unsigned short>(__lhs) ^
+                                   static_cast<unsigned short>(__rhs));
 }
 
 _LIBCPP_INLINE_VISIBILITY
-inline constexpr copy_options operator~(copy_options _LHS) {
-  return static_cast<copy_options>(~static_cast<unsigned short>(_LHS));
+inline constexpr copy_options operator~(copy_options __lhs) {
+  return static_cast<copy_options>(~static_cast<unsigned short>(__lhs));
 }
 
 _LIBCPP_INLINE_VISIBILITY
-inline copy_options& operator&=(copy_options& _LHS, copy_options _RHS) {
-  return _LHS = _LHS & _RHS;
+inline copy_options& operator&=(copy_options& __lhs, copy_options __rhs) {
+  return __lhs = __lhs & __rhs;
 }
 
 _LIBCPP_INLINE_VISIBILITY
-inline copy_options& operator|=(copy_options& _LHS, copy_options _RHS) {
-  return _LHS = _LHS | _RHS;
+inline copy_options& operator|=(copy_options& __lhs, copy_options __rhs) {
+  return __lhs = __lhs | __rhs;
 }
 
 _LIBCPP_INLINE_VISIBILITY
-inline copy_options& operator^=(copy_options& _LHS, copy_options _RHS) {
-  return _LHS = _LHS ^ _RHS;
+inline copy_options& operator^=(copy_options& __lhs, copy_options __rhs) {
+  return __lhs = __lhs ^ __rhs;
 }
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_POP
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
 #endif // _LIBCPP_CXX03_LANG
 
 #endif // _LIBCPP___FILESYSTEM_COPY_OPTIONS_H

libcxx/include/__filesystem/directory_options.h

 
 enum class _LIBCPP_ENUM_VIS directory_options : unsigned char {
   none = 0,
   follow_directory_symlink = 1,
   skip_permission_denied = 2
 };
 
 _LIBCPP_INLINE_VISIBILITY
-inline constexpr directory_options operator&(directory_options _LHS,
-                                             directory_options _RHS) {
-  return static_cast<directory_options>(static_cast<unsigned char>(_LHS) &
-                                        static_cast<unsigned char>(_RHS));
+inline constexpr directory_options operator&(directory_options __lhs,
+                                             directory_options __rhs) {
+  return static_cast<directory_options>(static_cast<unsigned char>(__lhs) &
+                                        static_cast<unsigned char>(__rhs));
 }
 
 _LIBCPP_INLINE_VISIBILITY
-inline constexpr directory_options operator|(directory_options _LHS,
-                                             directory_options _RHS) {
-  return static_cast<directory_options>(static_cast<unsigned char>(_LHS) |
-                                        static_cast<unsigned char>(_RHS));
+inline constexpr directory_options operator|(directory_options __lhs,
+                                             directory_options __rhs) {
+  return static_cast<directory_options>(static_cast<unsigned char>(__lhs) |
+                                        static_cast<unsigned char>(__rhs));
 }
 
 _LIBCPP_INLINE_VISIBILITY
-inline constexpr directory_options operator^(directory_options _LHS,
-                                             directory_options _RHS) {
-  return static_cast<directory_options>(static_cast<unsigned char>(_LHS) ^
-                                        static_cast<unsigned char>(_RHS));
+inline constexpr directory_options operator^(directory_options __lhs,
+                                             directory_options __rhs) {
+  return static_cast<directory_options>(static_cast<unsigned char>(__lhs) ^
+                                        static_cast<unsigned char>(__rhs));
 }
 
 _LIBCPP_INLINE_VISIBILITY
-inline constexpr directory_options operator~(directory_options _LHS) {
-  return static_cast<directory_options>(~static_cast<unsigned char>(_LHS));
+inline constexpr directory_options operator~(directory_options __lhs) {
+  return static_cast<directory_options>(~static_cast<unsigned char>(__lhs));
 }
 
 _LIBCPP_INLINE_VISIBILITY
-inline directory_options& operator&=(directory_options& _LHS,
-                                     directory_options _RHS) {
-  return _LHS = _LHS & _RHS;
+inline directory_options& operator&=(directory_options& __lhs,
+                                     directory_options __rhs) {
+  return __lhs = __lhs & __rhs;
 }
 
 _LIBCPP_INLINE_VISIBILITY
-inline directory_options& operator|=(directory_options& _LHS,
-                                     directory_options _RHS) {
-  return _LHS = _LHS | _RHS;
+inline directory_options& operator|=(directory_options& __lhs,
+                                     directory_options __rhs) {
+  return __lhs = __lhs | __rhs;
 }
 
 _LIBCPP_INLINE_VISIBILITY
-inline directory_options& operator^=(directory_options& _LHS,
-                                     directory_options _RHS) {
-  return _LHS = _LHS ^ _RHS;
+inline directory_options& operator^=(directory_options& __lhs,
+                                     directory_options __rhs) {
+  return __lhs = __lhs ^ __rhs;
 }
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_POP
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
 #endif // _LIBCPP_CXX03_LANG
 
 #endif // _LIBCPP___FILESYSTEM_DIRECTORY_OPTIONS_H

libcxx/include/__filesystem/operations.h

 
 _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
 
 _LIBCPP_FUNC_VIS path __absolute(const path&, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS path __canonical(const path&, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS bool __copy_file(const path& __from, const path& __to, copy_options __opt, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS void __copy_symlink(const path& __existing_symlink, const path& __new_symlink, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS void __copy(const path& __from, const path& __to, copy_options __opt, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS bool __create_directories(const path& p, error_code* ec = nullptr);
+_LIBCPP_FUNC_VIS bool __create_directories(const path&, error_code* = nullptr);
 _LIBCPP_FUNC_VIS void __create_directory_symlink(const path& __to, const path& __new_symlink, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS bool __create_directory(const path& p, error_code* ec = nullptr);
-_LIBCPP_FUNC_VIS bool __create_directory(const path& p, const path& attributes, error_code* ec = nullptr);
+_LIBCPP_FUNC_VIS bool __create_directory(const path&, error_code* = nullptr);
+_LIBCPP_FUNC_VIS bool __create_directory(const path&, const path& __attributes, error_code* = nullptr);
 _LIBCPP_FUNC_VIS void __create_hard_link(const path& __to, const path& __new_hard_link, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS void __create_symlink(const path& __to, const path& __new_symlink, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS path __current_path(error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS void __current_path(const path&, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS bool __equivalent(const path&, const path&, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS file_status __status(const path&, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS uintmax_t __file_size(const path&, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS uintmax_t __hard_link_count(const path&, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS file_status __symlink_status(const path&, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS file_time_type __last_write_time(const path& p, error_code* ec = nullptr);
-_LIBCPP_FUNC_VIS void __last_write_time(const path& p, file_time_type new_time, error_code* ec = nullptr);
+_LIBCPP_FUNC_VIS file_time_type __last_write_time(const path&, error_code* = nullptr);
+_LIBCPP_FUNC_VIS void __last_write_time(const path&, file_time_type __new_time, error_code* = nullptr);
 _LIBCPP_FUNC_VIS path __weakly_canonical(path const& __p, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS path __read_symlink(const path& p, error_code* ec = nullptr);
-_LIBCPP_FUNC_VIS uintmax_t __remove_all(const path& p, error_code* ec = nullptr);
-_LIBCPP_FUNC_VIS bool __remove(const path& p, error_code* ec = nullptr);
-_LIBCPP_FUNC_VIS void __rename(const path& from, const path& to, error_code* ec = nullptr);
-_LIBCPP_FUNC_VIS void __resize_file(const path& p, uintmax_t size, error_code* ec = nullptr);
+_LIBCPP_FUNC_VIS path __read_symlink(const path&, error_code* = nullptr);
+_LIBCPP_FUNC_VIS uintmax_t __remove_all(const path&, error_code* = nullptr);
+_LIBCPP_FUNC_VIS bool __remove(const path&, error_code* = nullptr);
+_LIBCPP_FUNC_VIS void __rename(const path& __from, const path& __to, error_code* = nullptr);
+_LIBCPP_FUNC_VIS void __resize_file(const path&, uintmax_t __size, error_code* = nullptr);
 _LIBCPP_FUNC_VIS path __temp_directory_path(error_code* __ec = nullptr);
 
 inline _LIBCPP_HIDE_FROM_ABI path absolute(const path& __p) { return __absolute(__p); }
 inline _LIBCPP_HIDE_FROM_ABI path absolute(const path& __p, error_code& __ec) { return __absolute(__p, &__ec); }
 inline _LIBCPP_HIDE_FROM_ABI path canonical(const path& __p)                   { return __canonical(__p); }
 inline _LIBCPP_HIDE_FROM_ABI path canonical(const path& __p, error_code& __ec) { return __canonical(__p, &__ec); }
 inline _LIBCPP_HIDE_FROM_ABI bool copy_file(const path& __from, const path& __to) { return __copy_file(__from, __to, copy_options::none); }
 inline _LIBCPP_HIDE_FROM_ABI bool copy_file(const path& __from, const path& __to, error_code& __ec) { return __copy_file(__from, __to, copy_options::none, &__ec); }

 inline _LIBCPP_HIDE_FROM_ABI bool is_block_file(const path& __p) { return is_block_file(__status(__p)); }
 inline _LIBCPP_HIDE_FROM_ABI bool is_block_file(const path& __p, error_code& __ec) noexcept { return is_block_file(__status(__p, &__ec)); }
 inline _LIBCPP_HIDE_FROM_ABI bool is_character_file(file_status __s) noexcept { return __s.type() == file_type::character; }
 inline _LIBCPP_HIDE_FROM_ABI bool is_character_file(const path& __p) { return is_character_file(__status(__p)); }
 inline _LIBCPP_HIDE_FROM_ABI bool is_character_file(const path& __p, error_code& __ec) noexcept { return is_character_file(__status(__p, &__ec)); }
 inline _LIBCPP_HIDE_FROM_ABI bool is_directory(file_status __s) noexcept { return __s.type() == file_type::directory; }
 inline _LIBCPP_HIDE_FROM_ABI bool is_directory(const path& __p) { return is_directory(__status(__p)); }
 inline _LIBCPP_HIDE_FROM_ABI bool is_directory(const path& __p, error_code& __ec) noexcept { return is_directory(__status(__p, &__ec)); }
-_LIBCPP_FUNC_VIS bool __fs_is_empty(const path& p, error_code* ec = nullptr);
+_LIBCPP_FUNC_VIS bool __fs_is_empty(const path&, error_code* = nullptr);
 inline _LIBCPP_HIDE_FROM_ABI bool is_empty(const path& __p) { return __fs_is_empty(__p); }
 inline _LIBCPP_HIDE_FROM_ABI bool is_empty(const path& __p, error_code& __ec) { return __fs_is_empty(__p, &__ec); }
 inline _LIBCPP_HIDE_FROM_ABI bool is_fifo(file_status __s) noexcept { return __s.type() == file_type::fifo; }
 inline _LIBCPP_HIDE_FROM_ABI bool is_fifo(const path& __p) { return is_fifo(__status(__p)); }
 inline _LIBCPP_HIDE_FROM_ABI bool is_fifo(const path& __p, error_code& __ec) noexcept { return is_fifo(__status(__p, &__ec)); }
 inline _LIBCPP_HIDE_FROM_ABI bool is_regular_file(file_status __s) noexcept { return __s.type() == file_type::regular; }
 inline _LIBCPP_HIDE_FROM_ABI bool is_regular_file(const path& __p) { return is_regular_file(__status(__p)); }
 inline _LIBCPP_HIDE_FROM_ABI bool is_regular_file(const path& __p, error_code& __ec) noexcept { return is_regular_file(__status(__p, &__ec)); }

libcxx/include/__filesystem/perm_options.h

 enum class _LIBCPP_ENUM_VIS perm_options : unsigned char {
   replace = 1,
   add = 2,
   remove = 4,
   nofollow = 8
 };
 
 _LIBCPP_INLINE_VISIBILITY
-inline constexpr perm_options operator&(perm_options _LHS, perm_options _RHS) {
-  return static_cast<perm_options>(static_cast<unsigned>(_LHS) &
-                                   static_cast<unsigned>(_RHS));
+inline constexpr perm_options operator&(perm_options __lhs, perm_options __rhs) {
+  return static_cast<perm_options>(static_cast<unsigned>(__lhs) &
+                                   static_cast<unsigned>(__rhs));
 }
 
 _LIBCPP_INLINE_VISIBILITY
-inline constexpr perm_options operator|(perm_options _LHS, perm_options _RHS) {
-  return static_cast<perm_options>(static_cast<unsigned>(_LHS) |
-                                   static_cast<unsigned>(_RHS));
+inline constexpr perm_options operator|(perm_options __lhs, perm_options __rhs) {
+  return static_cast<perm_options>(static_cast<unsigned>(__lhs) |
+                                   static_cast<unsigned>(__rhs));
 }
 
 _LIBCPP_INLINE_VISIBILITY
-inline constexpr perm_options operator^(perm_options _LHS, perm_options _RHS) {
-  return static_cast<perm_options>(static_cast<unsigned>(_LHS) ^
-                                   static_cast<unsigned>(_RHS));
+inline constexpr perm_options operator^(perm_options __lhs, perm_options __rhs) {
+  return static_cast<perm_options>(static_cast<unsigned>(__lhs) ^
+                                   static_cast<unsigned>(__rhs));
 }
 
 _LIBCPP_INLINE_VISIBILITY
-inline constexpr perm_options operator~(perm_options _LHS) {
-  return static_cast<perm_options>(~static_cast<unsigned>(_LHS));
+inline constexpr perm_options operator~(perm_options __lhs) {
+  return static_cast<perm_options>(~static_cast<unsigned>(__lhs));
 }
 
 _LIBCPP_INLINE_VISIBILITY
-inline perm_options& operator&=(perm_options& _LHS, perm_options _RHS) {
-  return _LHS = _LHS & _RHS;
+inline perm_options& operator&=(perm_options& __lhs, perm_options __rhs) {
+  return __lhs = __lhs & __rhs;
 }
 
 _LIBCPP_INLINE_VISIBILITY
-inline perm_options& operator|=(perm_options& _LHS, perm_options _RHS) {
-  return _LHS = _LHS | _RHS;
+inline perm_options& operator|=(perm_options& __lhs, perm_options __rhs) {
+  return __lhs = __lhs | __rhs;
 }
 
 _LIBCPP_INLINE_VISIBILITY
-inline perm_options& operator^=(perm_options& _LHS, perm_options _RHS) {
-  return _LHS = _LHS ^ _RHS;
+inline perm_options& operator^=(perm_options& __lhs, perm_options __rhs) {
+  return __lhs = __lhs ^ __rhs;
 }
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_POP
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
 #endif // _LIBCPP_CXX03_LANG
 
 #endif // _LIBCPP___FILESYSTEM_PERM_OPTIONS_H

libcxx/include/__filesystem/perms.h

enum class _LIBCPP_ENUM_VIS perms : unsigned {
   set_uid = 04000,
   set_gid = 02000,
   sticky_bit = 01000,
   mask = 07777,
   unknown = 0xFFFF,
 };
 
 _LIBCPP_INLINE_VISIBILITY
-inline constexpr perms operator&(perms _LHS, perms _RHS) {
-  return static_cast<perms>(static_cast<unsigned>(_LHS) &
-                            static_cast<unsigned>(_RHS));
+inline constexpr perms operator&(perms __lhs, perms __rhs) {
+  return static_cast<perms>(static_cast<unsigned>(__lhs) &
+                            static_cast<unsigned>(__rhs));
 }
 
 _LIBCPP_INLINE_VISIBILITY
-inline constexpr perms operator|(perms _LHS, perms _RHS) {
-  return static_cast<perms>(static_cast<unsigned>(_LHS) |
-                            static_cast<unsigned>(_RHS));
+inline constexpr perms operator|(perms __lhs, perms __rhs) {
+  return static_cast<perms>(static_cast<unsigned>(__lhs) |
+                            static_cast<unsigned>(__rhs));
 }
 
 _LIBCPP_INLINE_VISIBILITY
-inline constexpr perms operator^(perms _LHS, perms _RHS) {
-  return static_cast<perms>(static_cast<unsigned>(_LHS) ^
-                            static_cast<unsigned>(_RHS));
+inline constexpr perms operator^(perms __lhs, perms __rhs) {
+  return static_cast<perms>(static_cast<unsigned>(__lhs) ^
+                            static_cast<unsigned>(__rhs));
 }
 
 _LIBCPP_INLINE_VISIBILITY
-inline constexpr perms operator~(perms _LHS) {
-  return static_cast<perms>(~static_cast<unsigned>(_LHS));
+inline constexpr perms operator~(perms __lhs) {
+  return static_cast<perms>(~static_cast<unsigned>(__lhs));
 }
 
 _LIBCPP_INLINE_VISIBILITY
-inline perms& operator&=(perms& _LHS, perms _RHS) { return _LHS = _LHS & _RHS; }
+inline perms& operator&=(perms& __lhs, perms __rhs) { return __lhs = __lhs & __rhs; }
 
 _LIBCPP_INLINE_VISIBILITY
-inline perms& operator|=(perms& _LHS, perms _RHS) { return _LHS = _LHS | _RHS; }
+inline perms& operator|=(perms& __lhs, perms __rhs) { return __lhs = __lhs | __rhs; }
 
 _LIBCPP_INLINE_VISIBILITY
-inline perms& operator^=(perms& _LHS, perms _RHS) { return _LHS = _LHS ^ _RHS; }
+inline perms& operator^=(perms& __lhs, perms __rhs) { return __lhs = __lhs ^ __rhs; }
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_POP
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
 #endif // _LIBCPP_CXX03_LANG
 
 #endif // _LIBCPP___FILESYSTEM_PERMS_H

libcxx/include/__format/formatter.h

else
     case _Flags::_Sign::__space:
       *__buf++ = ' ';
       break;
     }
 
   return __buf;
 }
 
-_LIBCPP_HIDE_FROM_ABI constexpr char __hex_to_upper(char c) {
-  switch (c) {
+_LIBCPP_HIDE_FROM_ABI constexpr char __hex_to_upper(char __c) {
+  switch (__c) {
   case 'a':
     return 'A';
   case 'b':
     return 'B';
   case 'c':
     return 'C';
   case 'd':
     return 'D';
   case 'e':
     return 'E';
   case 'f':
     return 'F';
   }
-  return c;
+  return __c;
 }
 
 } // namespace __format_spec
 
 namespace __formatter {
 
 /** The character types that formatters are specialized for. */
 template <class _CharT>

libcxx/include/__format/formatter_output.h

 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
 namespace __formatter {
 
-_LIBCPP_HIDE_FROM_ABI constexpr char __hex_to_upper(char c) {
-  switch (c) {
+_LIBCPP_HIDE_FROM_ABI constexpr char __hex_to_upper(char __c) {
+  switch (__c) {
   case 'a':
     return 'A';
   case 'b':
     return 'B';
   case 'c':
     return 'C';
   case 'd':
     return 'D';
   case 'e':
     return 'E';
   case 'f':
     return 'F';
   }
-  return c;
+  return __c;
 }
 
 // TODO FMT remove _v2 suffix.
 struct _LIBCPP_TYPE_VIS __padding_size_result_v2 {
   size_t __before_;
   size_t __after_;
 };
 

libcxx/include/__format/parser_std_format_spec.h

if (__r.__ptr == __end || *__r.__ptr != _CharT('}'))
     __throw_format_error("Invalid arg-id");
 
   ++__r.__ptr;
   return __r;
 }
 
 template <class _Context>
 _LIBCPP_HIDE_FROM_ABI constexpr uint32_t
-__substitute_arg_id(basic_format_arg<_Context> _Arg) {
+__substitute_arg_id(basic_format_arg<_Context> __format_arg) {
   return visit_format_arg(
       [](auto __arg) -> uint32_t {
         using _Type = decltype(__arg);
         if constexpr (integral<_Type>) {
           if constexpr (signed_integral<_Type>) {
             if (__arg < 0)
               __throw_format_error("A format-spec arg-id replacement shouldn't "
                                    "have a negative value");
           }
 
           using _CT = common_type_t<_Type, decltype(__format::__number_max)>;
           if (static_cast<_CT>(__arg) >
               static_cast<_CT>(__format::__number_max))
             __throw_format_error("A format-spec arg-id replacement exceeds "
                                  "the maximum supported value");
 
           return __arg;
         } else if constexpr (same_as<_Type, monostate>)
           __throw_format_error("Argument index out of bounds");
         else
           __throw_format_error("A format-spec arg-id replacement argument "
                                "isn't an integral type");
       },
-      _Arg);
+      __format_arg);
 }
 
 class _LIBCPP_TYPE_VIS __parser_width {
 public:
   /** Contains a width or an arg-id. */
   uint32_t __width : 31 {0};
   /** Determines whether the value stored is a width or an arg-id. */
   uint32_t __width_as_arg : 1 {0};

libcxx/include/__functional/function.h

 
 template <class _Rp, class... _ArgTypes> class __value_func<_Rp(_ArgTypes...)>
 {
     typename aligned_storage<3 * sizeof(void*)>::type __buf_;
 
     typedef __base<_Rp(_ArgTypes...)> __func;
     __func* __f_;
 
-    _LIBCPP_NO_CFI static __func* __as_base(void* p)
+    _LIBCPP_NO_CFI static __func* __as_base(void* __p)
     {
-        return reinterpret_cast<__func*>(p);
+        return reinterpret_cast<__func*>(__p);
     }
 
   public:
     _LIBCPP_INLINE_VISIBILITY
     __value_func() _NOEXCEPT : __f_(nullptr) {}
 
     template <class _Fp, class _Alloc>
     _LIBCPP_INLINE_VISIBILITY __value_func(_Fp&& __f, const _Alloc& __a)

libcxx/include/__iterator/back_insert_iterator.h

 #else
     typedef void difference_type;
 #endif
     typedef void pointer;
     typedef void reference;
     typedef _Container container_type;
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit back_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator=(const typename _Container::value_type& __value_)
-        {container->push_back(__value_); return *this;}
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator=(const typename _Container::value_type& __value)
+        {container->push_back(__value); return *this;}
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator=(typename _Container::value_type&& __value_)
-        {container->push_back(_VSTD::move(__value_)); return *this;}
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator=(typename _Container::value_type&& __value)
+        {container->push_back(_VSTD::move(__value)); return *this;}
 #endif // _LIBCPP_CXX03_LANG
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator*()     {return *this;}
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator++()    {return *this;}
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator  operator++(int) {return *this;}
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _Container* __get_container() const { return container; }
 };
 

libcxx/include/__iterator/front_insert_iterator.h

 #else
     typedef void difference_type;
 #endif
     typedef void pointer;
     typedef void reference;
     typedef _Container container_type;
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit front_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator=(const typename _Container::value_type& __value_)
-        {container->push_front(__value_); return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator=(const typename _Container::value_type& __value)
+        {container->push_front(__value); return *this;}
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator=(typename _Container::value_type&& __value_)
-        {container->push_front(_VSTD::move(__value_)); return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator=(typename _Container::value_type&& __value)
+        {container->push_front(_VSTD::move(__value)); return *this;}
 #endif // _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator*()     {return *this;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator++()    {return *this;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator  operator++(int) {return *this;}
 };
 
 template <class _Container>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17

libcxx/include/__iterator/insert_iterator.h

#else
     typedef void difference_type;
 #endif
     typedef void pointer;
     typedef void reference;
     typedef _Container container_type;
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator(_Container& __x, __insert_iterator_iter_t<_Container> __i)
         : container(_VSTD::addressof(__x)), iter(__i) {}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator=(const typename _Container::value_type& __value_)
-        {iter = container->insert(iter, __value_); ++iter; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator=(const typename _Container::value_type& __value)
+        {iter = container->insert(iter, __value); ++iter; return *this;}
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator=(typename _Container::value_type&& __value_)
-        {iter = container->insert(iter, _VSTD::move(__value_)); ++iter; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator=(typename _Container::value_type&& __value)
+        {iter = container->insert(iter, _VSTD::move(__value)); ++iter; return *this;}
 #endif // _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator*()        {return *this;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator++()       {return *this;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator++(int)    {return *this;}
 };
 
 template <class _Container>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17

libcxx/include/__iterator/ostream_iterator.h

 private:
     ostream_type* __out_stream_;
     const char_type* __delim_;
 public:
     _LIBCPP_INLINE_VISIBILITY ostream_iterator(ostream_type& __s) _NOEXCEPT
         : __out_stream_(_VSTD::addressof(__s)), __delim_(nullptr) {}
     _LIBCPP_INLINE_VISIBILITY ostream_iterator(ostream_type& __s, const _CharT* __delimiter) _NOEXCEPT
         : __out_stream_(_VSTD::addressof(__s)), __delim_(__delimiter) {}
-    _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator=(const _Tp& __value_)
+    _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator=(const _Tp& __value)
         {
-            *__out_stream_ << __value_;
+            *__out_stream_ << __value;
             if (__delim_)
                 *__out_stream_ << __delim_;
             return *this;
         }
 
     _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator*()     {return *this;}
     _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator++()    {return *this;}
     _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator++(int) {return *this;}
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_OSTREAM_ITERATOR_H

libcxx/include/__iterator/reverse_iterator.h

#endif
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     _Iter base() const {return current;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     reference operator*() const {_Iter __tmp = current; return *--__tmp;}
 
 #if _LIBCPP_STD_VER > 17
     _LIBCPP_INLINE_VISIBILITY
     constexpr pointer operator->() const
-      requires is_pointer_v<_Iter> || requires(const _Iter i) { i.operator->(); }
+      requires is_pointer_v<_Iter> || requires(const _Iter __i) { __i.operator->(); }
     {
       if constexpr (is_pointer_v<_Iter>) {
         return std::prev(current);
       } else {
         return std::prev(current).operator->();
       }
     }
 #else

libcxx/include/__numeric/iota.h

 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ForwardIterator, class _Tp>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
-iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value_)
+iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value)
 {
-    for (; __first != __last; ++__first, (void) ++__value_)
-        *__first = __value_;
+    for (; __first != __last; ++__first, (void) ++__value)
+        *__first = __value;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___NUMERIC_IOTA_H

libcxx/include/__random/piecewise_constant_distribution.h

class _LIBCPP_TEMPLATE_VIS param_type
         vector<result_type> __b_;
         vector<result_type> __densities_;
         vector<result_type> __areas_;
     public:
         typedef piecewise_constant_distribution distribution_type;
 
         param_type();
         template<class _InputIteratorB, class _InputIteratorW>
-            param_type(_InputIteratorB __fB, _InputIteratorB __lB,
-                       _InputIteratorW __fW);
+            param_type(_InputIteratorB __f_b, _InputIteratorB __l_b,
+                       _InputIteratorW __f_w);
 #ifndef _LIBCPP_CXX03_LANG
         template<class _UnaryOperation>
             param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
 #endif // _LIBCPP_CXX03_LANG
         template<class _UnaryOperation>
             param_type(size_t __nw, result_type __xmin, result_type __xmax,
                        _UnaryOperation __fw);
         param_type(param_type const&) = default;
private:
     param_type __p_;
 
 public:
     // constructor and reset functions
     _LIBCPP_INLINE_VISIBILITY
     piecewise_constant_distribution() {}
     template<class _InputIteratorB, class _InputIteratorW>
         _LIBCPP_INLINE_VISIBILITY
-        piecewise_constant_distribution(_InputIteratorB __fB,
-                                        _InputIteratorB __lB,
-                                        _InputIteratorW __fW)
-        : __p_(__fB, __lB, __fW) {}
+        piecewise_constant_distribution(_InputIteratorB __f_b,
+                                        _InputIteratorB __l_b,
+                                        _InputIteratorW __f_w)
+        : __p_(__f_b, __l_b, __f_w) {}
 
 #ifndef _LIBCPP_CXX03_LANG
     template<class _UnaryOperation>
         _LIBCPP_INLINE_VISIBILITY
         piecewise_constant_distribution(initializer_list<result_type> __bl,
                                         _UnaryOperation __fw)
         : __p_(__bl, __fw) {}
 #endif // _LIBCPP_CXX03_LANG
: __b_(2),
       __areas_(1, 0.0)
 {
     __b_[1] = 1;
 }
 
 template<class _RealType>
 template<class _InputIteratorB, class _InputIteratorW>
 piecewise_constant_distribution<_RealType>::param_type::param_type(
-        _InputIteratorB __fB, _InputIteratorB __lB, _InputIteratorW __fW)
-    : __b_(__fB, __lB)
+        _InputIteratorB __f_b, _InputIteratorB __l_b, _InputIteratorW __f_w)
+    : __b_(__f_b, __l_b)
 {
     if (__b_.size() < 2)
     {
         __b_.resize(2);
         __b_[0] = 0;
         __b_[1] = 1;
         __densities_.assign(1, 1.0);
         __areas_.assign(1, 0.0);
     }
     else
     {
         __densities_.reserve(__b_.size() - 1);
-        for (size_t __i = 0; __i < __b_.size() - 1; ++__i, ++__fW)
-            __densities_.push_back(*__fW);
+        for (size_t __i = 0; __i < __b_.size() - 1; ++__i, ++__f_w)
+            __densities_.push_back(*__f_w);
         __init();
     }
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template<class _RealType>
 template<class _UnaryOperation>

libcxx/include/__random/piecewise_linear_distribution.h

class _LIBCPP_TEMPLATE_VIS param_type
         vector<result_type> __b_;
         vector<result_type> __densities_;
         vector<result_type> __areas_;
     public:
         typedef piecewise_linear_distribution distribution_type;
 
         param_type();
         template<class _InputIteratorB, class _InputIteratorW>
-            param_type(_InputIteratorB __fB, _InputIteratorB __lB,
-                       _InputIteratorW __fW);
+            param_type(_InputIteratorB __f_b, _InputIteratorB __l_b,
+                       _InputIteratorW __f_w);
 #ifndef _LIBCPP_CXX03_LANG
         template<class _UnaryOperation>
             param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
 #endif // _LIBCPP_CXX03_LANG
         template<class _UnaryOperation>
             param_type(size_t __nw, result_type __xmin, result_type __xmax,
                        _UnaryOperation __fw);
         param_type(param_type const&) = default;
private:
     param_type __p_;
 
 public:
     // constructor and reset functions
     _LIBCPP_INLINE_VISIBILITY
     piecewise_linear_distribution() {}
     template<class _InputIteratorB, class _InputIteratorW>
         _LIBCPP_INLINE_VISIBILITY
-        piecewise_linear_distribution(_InputIteratorB __fB,
-                                      _InputIteratorB __lB,
-                                      _InputIteratorW __fW)
-        : __p_(__fB, __lB, __fW) {}
+        piecewise_linear_distribution(_InputIteratorB __f_b,
+                                      _InputIteratorB __l_b,
+                                      _InputIteratorW __f_w)
+        : __p_(__f_b, __l_b, __f_w) {}
 
 #ifndef _LIBCPP_CXX03_LANG
     template<class _UnaryOperation>
         _LIBCPP_INLINE_VISIBILITY
         piecewise_linear_distribution(initializer_list<result_type> __bl,
                                       _UnaryOperation __fw)
         : __p_(__bl, __fw) {}
 #endif // _LIBCPP_CXX03_LANG
: __b_(2),
       __areas_(1, 0.0)
 {
     __b_[1] = 1;
 }
 
 template<class _RealType>
 template<class _InputIteratorB, class _InputIteratorW>
 piecewise_linear_distribution<_RealType>::param_type::param_type(
-        _InputIteratorB __fB, _InputIteratorB __lB, _InputIteratorW __fW)
-    : __b_(__fB, __lB)
+        _InputIteratorB __f_b, _InputIteratorB __l_b, _InputIteratorW __f_w)
+    : __b_(__f_b, __l_b)
 {
     if (__b_.size() < 2)
     {
         __b_.resize(2);
         __b_[0] = 0;
         __b_[1] = 1;
         __densities_.assign(2, 1.0);
         __areas_.assign(1, 0.0);
     }
     else
     {
         __densities_.reserve(__b_.size());
-        for (size_t __i = 0; __i < __b_.size(); ++__i, ++__fW)
-            __densities_.push_back(*__fW);
+        for (size_t __i = 0; __i < __b_.size(); ++__i, ++__f_w)
+            __densities_.push_back(*__f_w);
         __init();
     }
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template<class _RealType>
 template<class _UnaryOperation>

libcxx/include/__ranges/zip_view.h

 
 namespace views {
 namespace __zip {
 
 struct __fn {
   _LIBCPP_HIDE_FROM_ABI constexpr auto operator()() const noexcept { return empty_view<tuple<>>{}; }
 
   template <class... _Ranges>
-  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Ranges&&... rs) const
-      noexcept(noexcept(zip_view<all_t<_Ranges&&>...>(std::forward<_Ranges>(rs)...)))
-          -> decltype(zip_view<all_t<_Ranges&&>...>(std::forward<_Ranges>(rs)...)) {
-    return zip_view<all_t<_Ranges>...>(std::forward<_Ranges>(rs)...);
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Ranges&&... __rs) const
+      noexcept(noexcept(zip_view<all_t<_Ranges&&>...>(std::forward<_Ranges>(__rs)...)))
+          -> decltype(zip_view<all_t<_Ranges&&>...>(std::forward<_Ranges>(__rs)...)) {
+    return zip_view<all_t<_Ranges>...>(std::forward<_Ranges>(__rs)...);
   }
 };
 
 } // namespace __zip
 inline namespace __cpo {
   inline constexpr auto zip = __zip::__fn{};
 } // namespace __cpo
 } // namespace views

libcxx/include/__support/win32/locale_win32.h

private:
     _locale_t __locale;
     const char* __locale_str;
     __lconv_storage *__lc = nullptr;
 };
 
 // Locale management functions
 #define freelocale _free_locale
 // FIXME: base currently unused. Needs manual work to construct the new locale
-locale_t newlocale( int mask, const char * locale, locale_t base );
+locale_t newlocale( int __mask, const char * __locale, locale_t __base );
 // uselocale can't be implemented on Windows because Windows allows partial modification
 // of thread-local locale and so _get_current_locale() returns a copy while uselocale does
 // not create any copies.
 // We can still implement raii even without uselocale though.
 
 
-lconv *localeconv_l( locale_t &loc );
-size_t mbrlen_l( const char *__restrict s, size_t n,
-                 mbstate_t *__restrict ps, locale_t loc);
-size_t mbsrtowcs_l( wchar_t *__restrict dst, const char **__restrict src,
-                    size_t len, mbstate_t *__restrict ps, locale_t loc );
-size_t wcrtomb_l( char *__restrict s, wchar_t wc, mbstate_t *__restrict ps,
-                  locale_t loc);
-size_t mbrtowc_l( wchar_t *__restrict pwc, const char *__restrict s,
-                  size_t n, mbstate_t *__restrict ps, locale_t loc);
-size_t mbsnrtowcs_l( wchar_t *__restrict dst, const char **__restrict src,
-                     size_t nms, size_t len, mbstate_t *__restrict ps, locale_t loc);
-size_t wcsnrtombs_l( char *__restrict dst, const wchar_t **__restrict src,
-                     size_t nwc, size_t len, mbstate_t *__restrict ps, locale_t loc);
-wint_t btowc_l( int c, locale_t loc );
-int wctob_l( wint_t c, locale_t loc );
+lconv *localeconv_l( locale_t & __loc );
+size_t mbrlen_l( const char *__restrict __s, size_t __n,
+                 mbstate_t *__restrict __ps, locale_t __loc);
+size_t mbsrtowcs_l( wchar_t *__restrict __dst, const char **__restrict __src,
+                    size_t __len, mbstate_t *__restrict __ps, locale_t __loc );
+size_t wcrtomb_l( char *__restrict __s, wchar_t __wc, mbstate_t *__restrict __ps,
+                  locale_t __loc);
+size_t mbrtowc_l( wchar_t *__restrict __pwc, const char *__restrict __s,
+                  size_t __n, mbstate_t *__restrict __ps, locale_t __loc);
+size_t mbsnrtowcs_l( wchar_t *__restrict __dst, const char **__restrict __src,
+                     size_t __nms, size_t __len, mbstate_t *__restrict __ps, locale_t __loc);
+size_t wcsnrtombs_l( char *__restrict __dst, const wchar_t **__restrict __src,
+                     size_t __nwc, size_t __len, mbstate_t *__restrict __ps, locale_t __loc);
+wint_t btowc_l( int __c, locale_t __loc );
+int wctob_l( wint_t __c, locale_t __loc );
 
 decltype(MB_CUR_MAX) MB_CUR_MAX_L( locale_t __l );
 
 // the *_l functions are prefixed on Windows, only available for msvcr80+, VS2005+
 #define mbtowc_l _mbtowc_l
 #define strtoll_l _strtoi64_l
 #define strtoull_l _strtoui64_l
 #define strtod_l _strtod_l
 #if defined(_LIBCPP_MSVCRT)
 #define strtof_l _strtof_l
 #define strtold_l _strtold_l
 #else
 _LIBCPP_FUNC_VIS float strtof_l(const char*, char**, locale_t);
 _LIBCPP_FUNC_VIS long double strtold_l(const char*, char**, locale_t);
 #endif
 inline _LIBCPP_INLINE_VISIBILITY
 int
-islower_l(int c, _locale_t loc)
+islower_l(int c, _locale_t __loc)
 {
- return _islower_l((int)c, loc);
+ return _islower_l((int)c, __loc);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 int
-isupper_l(int c, _locale_t loc)
+isupper_l(int c, _locale_t __loc)
 {
- return _isupper_l((int)c, loc);
+ return _isupper_l((int)c, __loc);
 }
 
 #define isdigit_l _isdigit_l
 #define isxdigit_l _isxdigit_l
 #define strcoll_l _strcoll_l
 #define strxfrm_l _strxfrm_l
 #define wcscoll_l _wcscoll_l
 #define wcsxfrm_l _wcsxfrm_l
_LIBCPP_FUNC_VIS size_t strftime_l(char *ret, size_t n, const char *format,
                                    const struct tm *tm, locale_t loc);
 #else
 #define strftime_l _strftime_l
 #endif
 #define sscanf_l( __s, __l, __f, ...) _sscanf_l( __s, __f, __l, __VA_ARGS__ )
 #define sprintf_l( __s, __l, __f, ... ) _sprintf_l( __s, __f, __l, __VA_ARGS__ )
 #define vsprintf_l( __s, __l, __f, ... ) _vsprintf_l( __s, __f, __l, __VA_ARGS__ )
 #define vsnprintf_l( __s, __n, __l, __f, ... ) _vsnprintf_l( __s, __n, __f, __l, __VA_ARGS__ )
-_LIBCPP_FUNC_VIS int snprintf_l(char *ret, size_t n, locale_t loc, const char *format, ...);
-_LIBCPP_FUNC_VIS int asprintf_l( char **ret, locale_t loc, const char *format, ... );
-_LIBCPP_FUNC_VIS int vasprintf_l( char **ret, locale_t loc, const char *format, va_list ap );
+_LIBCPP_FUNC_VIS int snprintf_l(char *__ret, size_t __n, locale_t __loc, const char *__format, ...);
+_LIBCPP_FUNC_VIS int asprintf_l( char **__ret, locale_t __loc, const char *__format, ... );
+_LIBCPP_FUNC_VIS int vasprintf_l( char **__ret, locale_t __loc, const char *__format, va_list __ap );
 
 // not-so-pressing FIXME: use locale to determine blank characters
-inline int isblank_l( int c, locale_t /*loc*/ )
+inline int isblank_l( int __c, locale_t /*loc*/ )
 {
-    return ( c == ' ' || c == '\t' );
+    return ( __c == ' ' || __c == '\t' );
 }
-inline int iswblank_l( wint_t c, locale_t /*loc*/ )
+inline int iswblank_l( wint_t __c, locale_t /*loc*/ )
 {
-    return ( c == L' ' || c == L'\t' );
+    return ( __c == L' ' || __c == L'\t' );
 }
 
 #endif // _LIBCPP_SUPPORT_WIN32_LOCALE_WIN32_H

libcxx/include/__threading_support

 int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m,
                                __libcpp_timespec_t *__ts);
 
 _LIBCPP_THREAD_ABI_VISIBILITY
 int __libcpp_condvar_destroy(__libcpp_condvar_t* __cv);
 
 // Execute once
 _LIBCPP_THREAD_ABI_VISIBILITY
-int __libcpp_execute_once(__libcpp_exec_once_flag *flag,
-                          void (*init_routine)());
+int __libcpp_execute_once(__libcpp_exec_once_flag *__flag,
+                          void (*__init_routine)());
 
 // Thread id
 _LIBCPP_THREAD_ABI_VISIBILITY
-bool __libcpp_thread_id_equal(__libcpp_thread_id t1, __libcpp_thread_id t2);
+bool __libcpp_thread_id_equal(__libcpp_thread_id __t1, __libcpp_thread_id __t2);
 
 _LIBCPP_THREAD_ABI_VISIBILITY
-bool __libcpp_thread_id_less(__libcpp_thread_id t1, __libcpp_thread_id t2);
+bool __libcpp_thread_id_less(__libcpp_thread_id __t1, __libcpp_thread_id __t2);
 
 // Thread
 _LIBCPP_THREAD_ABI_VISIBILITY
 bool __libcpp_thread_isnull(const __libcpp_thread_t *__t);
 
 _LIBCPP_THREAD_ABI_VISIBILITY
 int __libcpp_thread_create(__libcpp_thread_t *__t, void *(*__func)(void *),
                            void *__arg);

 }
 
 int __libcpp_condvar_destroy(__libcpp_condvar_t *__cv)
 {
   return pthread_cond_destroy(__cv);
 }
 
 // Execute once
-int __libcpp_execute_once(__libcpp_exec_once_flag *flag,
-                          void (*init_routine)()) {
-  return pthread_once(flag, init_routine);
+int __libcpp_execute_once(__libcpp_exec_once_flag *__flag,
+                          void (*__init_routine)()) {
+  return pthread_once(__flag, __init_routine);
 }
 
 // Thread id
 // Returns non-zero if the thread ids are equal, otherwise 0
-bool __libcpp_thread_id_equal(__libcpp_thread_id t1, __libcpp_thread_id t2)
+bool __libcpp_thread_id_equal(__libcpp_thread_id __t1, __libcpp_thread_id __t2)
 {
-  return t1 == t2;
+  return __t1 == __t2;
 }
 
 // Returns non-zero if t1 < t2, otherwise 0
-bool __libcpp_thread_id_less(__libcpp_thread_id t1, __libcpp_thread_id t2)
+bool __libcpp_thread_id_less(__libcpp_thread_id __t1, __libcpp_thread_id __t2)
 {
-  return t1 < t2;
+  return __t1 < __t2;
 }
 
 // Thread
 bool __libcpp_thread_isnull(const __libcpp_thread_t *__t) {
   return __libcpp_thread_get_id(__t) == 0;
 }
 
 int __libcpp_thread_create(__libcpp_thread_t *__t, void *(*__func)(void *),

libcxx/include/any

public:
 
   template <class _ValueType, class ..._Args,
     class _Tp = decay_t<_ValueType>,
     class = enable_if_t<
         is_constructible<_Tp, _Args...>::value &&
         is_copy_constructible<_Tp>::value>
     >
   _LIBCPP_INLINE_VISIBILITY
-  _Tp& emplace(_Args&&... args);
+  _Tp& emplace(_Args&&...);
 
   template <class _ValueType, class _Up, class ..._Args,
     class _Tp = decay_t<_ValueType>,
     class = enable_if_t<
         is_constructible<_Tp, initializer_list<_Up>&, _Args...>::value &&
         is_copy_constructible<_Tp>::value>
   >
   _LIBCPP_INLINE_VISIBILITY

libcxx/include/atomic

 struct __cxx_atomic_base_impl {
 
   _LIBCPP_INLINE_VISIBILITY
 #ifndef _LIBCPP_CXX03_LANG
     __cxx_atomic_base_impl() _NOEXCEPT = default;
 #else
     __cxx_atomic_base_impl() _NOEXCEPT : __a_value() {}
 #endif // _LIBCPP_CXX03_LANG
-  _LIBCPP_CONSTEXPR explicit __cxx_atomic_base_impl(_Tp value) _NOEXCEPT
-    : __a_value(value) {}
+  _LIBCPP_CONSTEXPR explicit __cxx_atomic_base_impl(_Tp __value) _NOEXCEPT
+    : __a_value(__value) {}
   _LIBCPP_DISABLE_EXTENSION_WARNING _Atomic(_Tp) __a_value;
 };
 
 #define __cxx_atomic_is_lock_free(__s) __c11_atomic_is_lock_free(__s)
 
 _LIBCPP_INLINE_VISIBILITY inline
 void __cxx_atomic_thread_fence(memory_order __order) _NOEXCEPT {
     __c11_atomic_thread_fence(static_cast<__memory_order_underlying_t>(__order));

 template <typename _Tp,
           typename _Base = __cxx_atomic_base_impl<_Tp> >
 #endif //_LIBCPP_ATOMIC_ONLY_USE_BUILTINS
 struct __cxx_atomic_impl : public _Base {
     static_assert(is_trivially_copyable<_Tp>::value,
       "std::atomic<T> requires that 'T' be a trivially copyable type");
 
   _LIBCPP_INLINE_VISIBILITY __cxx_atomic_impl() _NOEXCEPT = default;
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR explicit __cxx_atomic_impl(_Tp value) _NOEXCEPT
-    : _Base(value) {}
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR explicit __cxx_atomic_impl(_Tp __value) _NOEXCEPT
+    : _Base(__value) {}
 };
 
 #if defined(__linux__) || (defined(_AIX) && !defined(__64BIT__))
     using __cxx_contention_t = int32_t;
 #else
     using __cxx_contention_t = int64_t;
 #endif // __linux__ || (_AIX && !__64BIT__)
 

libcxx/include/barrier

public:
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     __barrier_base(ptrdiff_t __expected, _CompletionF __completion = _CompletionF())
             : __expected_(__expected), __base_(__construct_barrier_algorithm_base(this->__expected_),
                                                &__destroy_barrier_algorithm_base),
               __expected_adjustment_(0), __completion_(std::move(__completion)), __phase_(0)
     {
     }
     [[nodiscard]] _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    arrival_token arrive(ptrdiff_t update)
+    arrival_token arrive(ptrdiff_t __update)
     {
         auto const __old_phase = __phase_.load(memory_order_relaxed);
-        for(; update; --update)
+        for(; __update; --__update)
             if(__arrive_barrier_algorithm_base(__base_.get(), __old_phase)) {
                 __completion_();
                 __expected_ += __expected_adjustment_.load(memory_order_relaxed);
                 __expected_adjustment_.store(0, memory_order_relaxed);
                 __phase_.store(__old_phase + 2, memory_order_release);
                 __phase_.notify_all();
             }
         return __old_phase;
public:
     barrier(ptrdiff_t __count, _CompletionF __completion = _CompletionF())
         : __b(__count, _VSTD::move(__completion)) {
     }
 
     barrier(barrier const&) = delete;
     barrier& operator=(barrier const&) = delete;
 
     [[nodiscard]] _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    arrival_token arrive(ptrdiff_t update = 1)
+    arrival_token arrive(ptrdiff_t __update = 1)
     {
-        return __b.arrive(update);
+        return __b.arrive(__update);
     }
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     void wait(arrival_token&& __phase) const
     {
         __b.wait(_VSTD::move(__phase));
     }
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     void arrive_and_wait()

libcxx/include/charconv

if (__r.ec == errc::result_out_of_range)
         }
     }
 
     return __r;
 }
 
 template <typename _Tp, typename enable_if<is_unsigned<_Tp>::value, int>::type = 0>
 inline _LIBCPP_HIDE_FROM_ABI from_chars_result
 __from_chars_atoi(const char* __first, const char* __last, _Tp& __value)
 {
     using __tx = __itoa::__traits<_Tp>;
     using __output_type = typename __tx::type;
 
     return __subject_seq_combinator(
         __first, __last, __value,
-        [](const char* _First, const char* _Last,
+        [](const char* __f, const char* __l,
            _Tp& __val) -> from_chars_result {
             __output_type __a, __b;
-            auto __p = __tx::__read(_First, _Last, __a, __b);
-            if (__p == _Last || !__in_pattern(*__p))
+            auto __p = __tx::__read(__f, __l, __a, __b);
+            if (__p == __l || !__in_pattern(*__p))
             {
                 __output_type __m = numeric_limits<_Tp>::max();
                 if (__m >= __a && __m - __a >= __b)
                 {
                     __val = __a + __b;
                     return {__p, {}};
                 }
             }
             return {__p, errc::result_out_of_range};
         });
 }
 
 template <typename _Tp, typename enable_if<is_signed<_Tp>::value, int>::type = 0>
 inline _LIBCPP_HIDE_FROM_ABI from_chars_result
 __from_chars_atoi(const char* __first, const char* __last, _Tp& __value)
 {
     using __t = decltype(__to_unsigned_like(__value));
     return __sign_combinator(__first, __last, __value, __from_chars_atoi<__t>);
 }
 
 template <typename _Tp, typename enable_if<is_unsigned<_Tp>::value, int>::type = 0>
 inline _LIBCPP_HIDE_FROM_ABI from_chars_result
 __from_chars_integral(const char* __first, const char* __last, _Tp& __value,
                       int __base)
 {
     if (__base == 10)
         return __from_chars_atoi(__first, __last, __value);
 
     return __subject_seq_combinator(
         __first, __last, __value,
         [](const char* __p, const char* __lastp, _Tp& __val,
-           int _Base) -> from_chars_result {
+           int __b) -> from_chars_result {
             using __tl = numeric_limits<_Tp>;
-            auto __digits = __tl::digits / log2f(float(_Base));
-            _Tp __a = __in_pattern(*__p++, _Base).__val, __b = 0;
+            auto __digits = __tl::digits / log2f(float(__b));
+            _Tp __x = __in_pattern(*__p++, __b).__val, __y = 0;
 
             for (int __i = 1; __p != __lastp; ++__i, ++__p)
             {
-                if (auto __c = __in_pattern(*__p, _Base))
+                if (auto __c = __in_pattern(*__p, __b))
                 {
                     if (__i < __digits - 1)
-                        __a = __a * _Base + __c.__val;
+                        __x = __x * __b + __c.__val;
                     else
                     {
-                        if (!__itoa::__mul_overflowed(__a, _Base, __a))
+                        if (!__itoa::__mul_overflowed(__x, __b, __x))
                             ++__p;
-                        __b = __c.__val;
+                        __y = __c.__val;
                         break;
                     }
                 }
                 else
                     break;
             }
 
-            if (__p == __lastp || !__in_pattern(*__p, _Base))
+            if (__p == __lastp || !__in_pattern(*__p, __b))
             {
-                if (__tl::max() - __a >= __b)
+                if (__tl::max() - __x >= __y)
                 {
-                    __val = __a + __b;
+                    __val = __x + __y;
                     return {__p, {}};
                 }
             }
             return {__p, errc::result_out_of_range};
         },
         __base);
 }
 

libcxx/include/cmath

 using ::rintl _LIBCPP_USING_IF_EXISTS;
 using ::roundl _LIBCPP_USING_IF_EXISTS;
 using ::scalblnl _LIBCPP_USING_IF_EXISTS;
 using ::scalbnl _LIBCPP_USING_IF_EXISTS;
 using ::tgammal _LIBCPP_USING_IF_EXISTS;
 using ::truncl _LIBCPP_USING_IF_EXISTS;
 
 #if _LIBCPP_STD_VER > 14
-inline _LIBCPP_INLINE_VISIBILITY float       hypot(       float x,       float y,       float z ) { return sqrt(x*x + y*y + z*z); }
-inline _LIBCPP_INLINE_VISIBILITY double      hypot(      double x,      double y,      double z ) { return sqrt(x*x + y*y + z*z); }
-inline _LIBCPP_INLINE_VISIBILITY long double hypot( long double x, long double y, long double z ) { return sqrt(x*x + y*y + z*z); }
+inline _LIBCPP_INLINE_VISIBILITY float       hypot(       float __x,       float __y,       float __z ) { return sqrt(__x*__x + __y*__y + __z*__z); }
+inline _LIBCPP_INLINE_VISIBILITY double      hypot(      double __x,      double __y,      double __z ) { return sqrt(__x*__x + __y*__y + __z*__z); }
+inline _LIBCPP_INLINE_VISIBILITY long double hypot( long double __x, long double __y, long double __z ) { return sqrt(__x*__x + __y*__y + __z*__z); }
 
 template <class _A1, class _A2, class _A3>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if_t
 <
     is_arithmetic<_A1>::value &&
     is_arithmetic<_A2>::value &&
     is_arithmetic<_A3>::value,

libcxx/include/codecvt

 _LIBCPP_SUPPRESS_DEPRECATED_POP
 public:
     typedef wchar_t   intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
     _LIBCPP_INLINE_VISIBILITY
-    explicit __codecvt_utf8(size_t __refs, unsigned long _Maxcode,
-                            codecvt_mode _Mode)
-        : codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
-          _Mode_(_Mode) {}
+    explicit __codecvt_utf8(size_t __refs, unsigned long __maxcode,
+                            codecvt_mode __mode)
+        : codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(__maxcode),
+          _Mode_(__mode) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
         do_in(state_type& __st,
class _LIBCPP_TYPE_VIS __codecvt_utf8<char16_t>
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char16_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
-    explicit __codecvt_utf8(size_t __refs, unsigned long _Maxcode,
-                            codecvt_mode _Mode)
-        : codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
-          _Mode_(_Mode) {}
+    explicit __codecvt_utf8(size_t __refs, unsigned long __maxcode,
+                            codecvt_mode __mode)
+        : codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(__maxcode),
+          _Mode_(__mode) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
class _LIBCPP_TYPE_VIS __codecvt_utf8<char32_t>
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char32_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
-    explicit __codecvt_utf8(size_t __refs, unsigned long _Maxcode,
-                            codecvt_mode _Mode)
-        : codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
-          _Mode_(_Mode) {}
+    explicit __codecvt_utf8(size_t __refs, unsigned long __maxcode,
+                            codecvt_mode __mode)
+        : codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(__maxcode),
+          _Mode_(__mode) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result

 _LIBCPP_SUPPRESS_DEPRECATED_POP
 public:
     typedef wchar_t   intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
     _LIBCPP_INLINE_VISIBILITY
-    explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
-                            codecvt_mode _Mode)
-        : codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
-          _Mode_(_Mode) {}
+    explicit __codecvt_utf16(size_t __refs, unsigned long __maxcode,
+                            codecvt_mode __mode)
+        : codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(__maxcode),
+          _Mode_(__mode) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
         do_in(state_type& __st,

 _LIBCPP_SUPPRESS_DEPRECATED_POP
 public:
     typedef wchar_t   intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
     _LIBCPP_INLINE_VISIBILITY
-    explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
-                            codecvt_mode _Mode)
-        : codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
-          _Mode_(_Mode) {}
+    explicit __codecvt_utf16(size_t __refs, unsigned long __maxcode,
+                            codecvt_mode __mode)
+        : codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(__maxcode),
+          _Mode_(__mode) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
         do_in(state_type& __st,
class _LIBCPP_TYPE_VIS __codecvt_utf16<char16_t, false>
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char16_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
-    explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
-                            codecvt_mode _Mode)
-        : codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
-          _Mode_(_Mode) {}
+    explicit __codecvt_utf16(size_t __refs, unsigned long __maxcode,
+                            codecvt_mode __mode)
+        : codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(__maxcode),
+          _Mode_(__mode) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
class _LIBCPP_TYPE_VIS __codecvt_utf16<char16_t, true>
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char16_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
-    explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
-                            codecvt_mode _Mode)
-        : codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
-          _Mode_(_Mode) {}
+    explicit __codecvt_utf16(size_t __refs, unsigned long __maxcode,
+                            codecvt_mode __mode)
+        : codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(__maxcode),
+          _Mode_(__mode) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
class _LIBCPP_TYPE_VIS __codecvt_utf16<char32_t, false>
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char32_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
-    explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
-                            codecvt_mode _Mode)
-        : codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
-          _Mode_(_Mode) {}
+    explicit __codecvt_utf16(size_t __refs, unsigned long __maxcode,
+                            codecvt_mode __mode)
+        : codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(__maxcode),
+          _Mode_(__mode) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
class _LIBCPP_TYPE_VIS __codecvt_utf16<char32_t, true>
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char32_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
-    explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
-                            codecvt_mode _Mode)
-        : codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
-          _Mode_(_Mode) {}
+    explicit __codecvt_utf16(size_t __refs, unsigned long __maxcode,
+                            codecvt_mode __mode)
+        : codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(__maxcode),
+          _Mode_(__mode) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result

 _LIBCPP_SUPPRESS_DEPRECATED_POP
 public:
     typedef wchar_t   intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
     _LIBCPP_INLINE_VISIBILITY
-    explicit __codecvt_utf8_utf16(size_t __refs, unsigned long _Maxcode,
-                            codecvt_mode _Mode)
-        : codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
-          _Mode_(_Mode) {}
+    explicit __codecvt_utf8_utf16(size_t __refs, unsigned long __maxcode,
+                            codecvt_mode __mode)
+        : codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(__maxcode),
+          _Mode_(__mode) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
         do_in(state_type& __st,
class _LIBCPP_TYPE_VIS __codecvt_utf8_utf16<char32_t>
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char32_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
-    explicit __codecvt_utf8_utf16(size_t __refs, unsigned long _Maxcode,
-                            codecvt_mode _Mode)
-        : codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
-          _Mode_(_Mode) {}
+    explicit __codecvt_utf8_utf16(size_t __refs, unsigned long __maxcode,
+                            codecvt_mode __mode)
+        : codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(__maxcode),
+          _Mode_(__mode) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
class _LIBCPP_TYPE_VIS __codecvt_utf8_utf16<char16_t>
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char16_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
-    explicit __codecvt_utf8_utf16(size_t __refs, unsigned long _Maxcode,
-                            codecvt_mode _Mode)
-        : codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
-          _Mode_(_Mode) {}
+    explicit __codecvt_utf8_utf16(size_t __refs, unsigned long __maxcode,
+                            codecvt_mode __mode)
+        : codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(__maxcode),
+          _Mode_(__mode) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result

libcxx/include/condition_variable

condition_variable_any::wait_for(_Lock& __lock,
                                  const chrono::duration<_Rep, _Period>& __d,
                                  _Predicate __pred)
 {
     return wait_until(__lock, chrono::steady_clock::now() + __d,
                       _VSTD::move(__pred));
 }
 
 _LIBCPP_FUNC_VIS
-void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
+void notify_all_at_thread_exit(condition_variable&, unique_lock<mutex>);
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // !_LIBCPP_HAS_NO_THREADS
 
 #endif // _LIBCPP_CONDITION_VARIABLE

libcxx/include/exception

 inline _LIBCPP_INLINE_VISIBILITY
 bool operator!=(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT
     {return !(__x == __y);}
 
 _LIBCPP_FUNC_VIS void swap(exception_ptr&, exception_ptr&) _NOEXCEPT;
 
 _LIBCPP_FUNC_VIS exception_ptr __copy_exception_ptr(void *__except, const void* __ptr);
 _LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
-_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr p);
+_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr);
 
 // This is a built-in template function which automagically extracts the required
 // information.
 template <class _E> void *__GetExceptionInfo(_E);
 
 template<class _Ep>
 _LIBCPP_INLINE_VISIBILITY exception_ptr
 make_exception_ptr(_Ep __e) _NOEXCEPT

libcxx/include/experimental/simd

 
 // reductions [simd.reductions]
 template <class _Tp, class _Abi, class _BinaryOp = std::plus<_Tp>>
 _Tp reduce(const simd<_Tp, _Abi>&, _BinaryOp = _BinaryOp());
 
 template <class _MaskType, class _SimdType, class _BinaryOp>
 typename _SimdType::value_type
 reduce(const const_where_expression<_MaskType, _SimdType>&,
-       typename _SimdType::value_type neutral_element, _BinaryOp binary_op);
+       typename _SimdType::value_type __neutral_element, _BinaryOp);
 
 template <class _MaskType, class _SimdType>
 typename _SimdType::value_type
 reduce(const const_where_expression<_MaskType, _SimdType>&,
-       plus<typename _SimdType::value_type> binary_op = {});
+       plus<typename _SimdType::value_type> = {});
 
 template <class _MaskType, class _SimdType>
 typename _SimdType::value_type
 reduce(const const_where_expression<_MaskType, _SimdType>&,
-       multiplies<typename _SimdType::value_type> binary_op);
+       multiplies<typename _SimdType::value_type>);
 
 template <class _MaskType, class _SimdType>
 typename _SimdType::value_type
 reduce(const const_where_expression<_MaskType, _SimdType>&,
-       bit_and<typename _SimdType::value_type> binary_op);
+       bit_and<typename _SimdType::value_type>);
 
 template <class _MaskType, class _SimdType>
 typename _SimdType::value_type
 reduce(const const_where_expression<_MaskType, _SimdType>&,
-       bit_or<typename _SimdType::value_type> binary_op);
+       bit_or<typename _SimdType::value_type>);
 
 template <class _MaskType, class _SimdType>
 typename _SimdType::value_type
 reduce(const const_where_expression<_MaskType, _SimdType>&,
-       bit_xor<typename _SimdType::value_type> binary_op);
+       bit_xor<typename _SimdType::value_type>);
 
 template <class _Tp, class _Abi>
 _Tp hmin(const simd<_Tp, _Abi>&);
 template <class _MaskType, class _SimdType>
 typename _SimdType::value_type
 hmin(const const_where_expression<_MaskType, _SimdType>&);
 template <class _Tp, class _Abi>
 _Tp hmax(const simd<_Tp, _Abi>&);

libcxx/include/future

public:
     future_error(const future_error&) _NOEXCEPT = default;
     virtual ~future_error() _NOEXCEPT;
 };
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 #ifndef _LIBCPP_NO_EXCEPTIONS
 _LIBCPP_AVAILABILITY_FUTURE_ERROR
 #endif
-void __throw_future_error(future_errc _Ev)
+void __throw_future_error(future_errc __ev)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
-    throw future_error(make_error_code(_Ev));
+    throw future_error(make_error_code(__ev));
 #else
-    ((void)_Ev);
+    ((void)__ev);
     _VSTD::abort();
 #endif
 }
 
 class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE __assoc_sub_state
     : public __shared_count
 {
 protected:

 future<_Rp>::future(__assoc_state<_Rp>* __state)
     : __state_(__state)
 {
     __state_->__attach_future();
 }
 
 struct __release_shared_count
 {
-    void operator()(__shared_count* p) {p->__release_shared();}
+    void operator()(__shared_count* __p) {__p->__release_shared();}
 };
 
 template <class _Rp>
 future<_Rp>::~future()
 {
     if (__state_)
         __state_->__release_shared();
 }

libcxx/include/map

class __map_value_compare
     : private _Compare
 {
 public:
     _LIBCPP_INLINE_VISIBILITY
     __map_value_compare()
         _NOEXCEPT_(is_nothrow_default_constructible<_Compare>::value)
         : _Compare() {}
     _LIBCPP_INLINE_VISIBILITY
-    __map_value_compare(_Compare c)
+    __map_value_compare(_Compare __c)
         _NOEXCEPT_(is_nothrow_copy_constructible<_Compare>::value)
-        : _Compare(c) {}
+        : _Compare(__c) {}
     _LIBCPP_INLINE_VISIBILITY
     const _Compare& key_comp() const _NOEXCEPT {return *this;}
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _CP& __x, const _CP& __y) const
         {return static_cast<const _Compare&>(*this)(__x.__get_value().first, __y.__get_value().first);}
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _CP& __x, const _Key& __y) const
         {return static_cast<const _Compare&>(*this)(__x.__get_value().first, __y);}
class __map_value_compare<_Key, _CP, _Compare, false>
     _Compare comp;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     __map_value_compare()
         _NOEXCEPT_(is_nothrow_default_constructible<_Compare>::value)
         : comp() {}
     _LIBCPP_INLINE_VISIBILITY
-    __map_value_compare(_Compare c)
+    __map_value_compare(_Compare __c)
         _NOEXCEPT_(is_nothrow_copy_constructible<_Compare>::value)
-        : comp(c) {}
+        : comp(__c) {}
     _LIBCPP_INLINE_VISIBILITY
     const _Compare& key_comp() const _NOEXCEPT {return comp;}
 
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _CP& __x, const _CP& __y) const
         {return comp(__x.__get_value().first, __y.__get_value().first);}
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _CP& __x, const _Key& __y) const
public:
 
     class _LIBCPP_TEMPLATE_VIS value_compare
         : public __binary_function<value_type, value_type, bool>
     {
         friend class map;
     protected:
         key_compare comp;
 
-        _LIBCPP_INLINE_VISIBILITY value_compare(key_compare c) : comp(c) {}
+        _LIBCPP_INLINE_VISIBILITY value_compare(key_compare __c) : comp(__c) {}
     public:
         _LIBCPP_INLINE_VISIBILITY
         bool operator()(const value_type& __x, const value_type& __y) const
             {return comp(__x.first, __y.first);}
     };
 
 private:
 
public:
     class _LIBCPP_TEMPLATE_VIS value_compare
         : public __binary_function<value_type, value_type, bool>
     {
         friend class multimap;
     protected:
         key_compare comp;
 
         _LIBCPP_INLINE_VISIBILITY
-        value_compare(key_compare c) : comp(c) {}
+        value_compare(key_compare __c) : comp(__c) {}
     public:
         _LIBCPP_INLINE_VISIBILITY
         bool operator()(const value_type& __x, const value_type& __y) const
             {return comp(__x.first, __y.first);}
     };
 
 private:
 

libcxx/include/memory

 // `std::allocator<T>` to avoid additional instantiations.
 struct __builtin_new_allocator {
   struct __builtin_new_deleter {
     typedef void* pointer_type;
 
     _LIBCPP_CONSTEXPR explicit __builtin_new_deleter(size_t __size, size_t __align)
         : __size_(__size), __align_(__align) {}
 
-    void operator()(void* p) const _NOEXCEPT {
-        _VSTD::__libcpp_deallocate(p, __size_, __align_);
+    void operator()(void* __p) const _NOEXCEPT {
+        _VSTD::__libcpp_deallocate(__p, __size_, __align_);
     }
 
    private:
     size_t __size_;
     size_t __align_;
   };
 
   typedef unique_ptr<void, __builtin_new_deleter> __holder_t;

libcxx/include/regex

 regex_traits<_CharT>::isctype(char_type __c, char_class_type __m) const
 {
     if (__ct_->is(__m, __c))
         return true;
     return (__c == '_' && (__m & __regex_word));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
-bool __is_07(unsigned char c)
+bool __is_07(unsigned char __c)
 {
-    return (c & 0xF8u) ==
+    return (__c & 0xF8u) ==
 #if defined(__MVS__) && !defined(__NATIVE_ASCII_F)
         0xF0;
 #else
         0x30;
 #endif
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
-bool __is_89(unsigned char c)
+bool __is_89(unsigned char __c)
 {
-    return (c & 0xFEu) ==
+    return (__c & 0xFEu) ==
 #if defined(__MVS__) && !defined(__NATIVE_ASCII_F)
         0xF8;
 #else
         0x38;
 #endif
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
-unsigned char __to_lower(unsigned char c)
+unsigned char __to_lower(unsigned char __c)
 {
 #if defined(__MVS__) && !defined(__NATIVE_ASCII_F)
     return c & 0xBF;
 #else
-    return c | 0x20;
+    return __c | 0x20;
 #endif
 }
 
 template <class _CharT>
 int
 regex_traits<_CharT>::__regex_traits_value(unsigned char __ch, int __radix)
 {
     if (__is_07(__ch))  // '0' <= __ch && __ch <= '7'
else
         __s.__node_ = nullptr;
     }
 }
 
 // __l_anchor
 
 template <class _CharT>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-bool __is_eol(_CharT c)
+bool __is_eol(_CharT __c)
 {
-    return c == '\r' || c == '\n';
+    return __c == '\r' || __c == '\n';
 }
 
 template <class _CharT>
 class __l_anchor_multiline
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
template <class _ForwardIterator>
         __parse_class_escape(_ForwardIterator __first, _ForwardIterator __last,
                           basic_string<_CharT>& __str,
                           __bracket_expression<_CharT, _Traits>* __ml);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_awk_escape(_ForwardIterator __first, _ForwardIterator __last,
                           basic_string<_CharT>* __str = nullptr);
 
-    bool __test_back_ref(_CharT c);
+    bool __test_back_ref(_CharT);
 
     _LIBCPP_INLINE_VISIBILITY
     void __push_l_anchor();
     void __push_r_anchor();
     void __push_match_any();
     void __push_match_any_but_newline();
     _LIBCPP_INLINE_VISIBILITY
     void __push_greedy_inf_repeat(size_t __min, __owns_one_state<_CharT>* __s,
while (__first != __last)
         if (__first != __last)
             ++__first;
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 bool
-basic_regex<_CharT, _Traits>::__test_back_ref(_CharT c)
+basic_regex<_CharT, _Traits>::__test_back_ref(_CharT __c)
 {
-    unsigned __val = __traits_.value(c, 10);
+    unsigned __val = __traits_.value(__c, 10);
     if (__val >= 1 && __val <= 9)
     {
         if (__val > mark_count())
             __throw_regex_error<regex_constants::error_backref>();
         __push_back_ref(__val);
         return true;
     }
 

libcxx/include/scoped_allocator

protected:
     _LIBCPP_INLINE_VISIBILITY
     __scoped_allocator_storage() _NOEXCEPT {}
 
     template <class _OuterA2,
               class = typename enable_if<
                         is_constructible<outer_allocator_type, _OuterA2>::value
                       >::type>
         _LIBCPP_INLINE_VISIBILITY
-        __scoped_allocator_storage(_OuterA2&& __outerAlloc,
-                                   const _InnerAllocs& ...__innerAllocs) _NOEXCEPT
-            : outer_allocator_type(_VSTD::forward<_OuterA2>(__outerAlloc)),
-              __inner_(__innerAllocs...) {}
+        __scoped_allocator_storage(_OuterA2&& __outer_alloc,
+                                   const _InnerAllocs& ...__inner_allocs) _NOEXCEPT
+            : outer_allocator_type(_VSTD::forward<_OuterA2>(__outer_alloc)),
+              __inner_(__inner_allocs...) {}
 
     template <class _OuterA2,
               class = typename enable_if<
                         is_constructible<outer_allocator_type, const _OuterA2&>::value
                       >::type>
         _LIBCPP_INLINE_VISIBILITY
         __scoped_allocator_storage(
             const __scoped_allocator_storage<_OuterA2, _InnerAllocs...>& __other) _NOEXCEPT
protected:
     _LIBCPP_INLINE_VISIBILITY
     __scoped_allocator_storage() _NOEXCEPT {}
 
     template <class _OuterA2,
               class = typename enable_if<
                         is_constructible<outer_allocator_type, _OuterA2>::value
                       >::type>
         _LIBCPP_INLINE_VISIBILITY
-        __scoped_allocator_storage(_OuterA2&& __outerAlloc) _NOEXCEPT
-            : outer_allocator_type(_VSTD::forward<_OuterA2>(__outerAlloc)) {}
+        __scoped_allocator_storage(_OuterA2&& __outer_alloc) _NOEXCEPT
+            : outer_allocator_type(_VSTD::forward<_OuterA2>(__outer_alloc)) {}
 
     template <class _OuterA2,
               class = typename enable_if<
                         is_constructible<outer_allocator_type, const _OuterA2&>::value
                       >::type>
         _LIBCPP_INLINE_VISIBILITY
         __scoped_allocator_storage(
             const __scoped_allocator_storage<_OuterA2>& __other) _NOEXCEPT
public:
 
     _LIBCPP_INLINE_VISIBILITY
     scoped_allocator_adaptor() _NOEXCEPT {}
     template <class _OuterA2,
               class = typename enable_if<
                         is_constructible<outer_allocator_type, _OuterA2>::value
                       >::type>
         _LIBCPP_INLINE_VISIBILITY
-        scoped_allocator_adaptor(_OuterA2&& __outerAlloc,
-                                 const _InnerAllocs& ...__innerAllocs) _NOEXCEPT
-            : base(_VSTD::forward<_OuterA2>(__outerAlloc), __innerAllocs...) {}
+        scoped_allocator_adaptor(_OuterA2&& __outer_alloc,
+                                 const _InnerAllocs& ...__inner_allocs) _NOEXCEPT
+            : base(_VSTD::forward<_OuterA2>(__outer_alloc), __inner_allocs...) {}
     // scoped_allocator_adaptor(const scoped_allocator_adaptor& __other) = default;
     template <class _OuterA2,
               class = typename enable_if<
                         is_constructible<outer_allocator_type, const _OuterA2&>::value
                       >::type>
         _LIBCPP_INLINE_VISIBILITY
         scoped_allocator_adaptor(
             const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __other) _NOEXCEPT

libcxx/include/shared_mutex

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

libcxx/include/string_view

 #if _LIBCPP_STD_VER > 20 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
     template <class _Range>
       requires (
         !is_same_v<remove_cvref_t<_Range>, basic_string_view> &&
         ranges::contiguous_range<_Range> &&
         ranges::sized_range<_Range> &&
         is_same_v<ranges::range_value_t<_Range>, _CharT> &&
         !is_convertible_v<_Range, const _CharT*> &&
-        (!requires(remove_cvref_t<_Range>& d) {
-          d.operator _VSTD::basic_string_view<_CharT, _Traits>();
+        (!requires(remove_cvref_t<_Range>& __d) {
+          __d.operator _VSTD::basic_string_view<_CharT, _Traits>();
         }) &&
         (!requires {
          typename remove_reference_t<_Range>::traits_type;
         } || is_same_v<typename remove_reference_t<_Range>::traits_type, _Traits>)
       )
     constexpr _LIBCPP_HIDE_FROM_ABI
     basic_string_view(_Range&& __r) : __data(ranges::data(__r)), __size(ranges::size(__r)) {}
 #endif // _LIBCPP_STD_VER > 20 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)

libcxx/include/system_error

#endif
 
     friend class _LIBCPP_HIDDEN __do_message;
 };
 
 class _LIBCPP_HIDDEN __do_message
     : public error_category
 {
 public:
-    virtual string message(int ev) const;
+    virtual string message(int __ev) const;
 };
 
 _LIBCPP_FUNC_VIS const error_category& generic_category() _NOEXCEPT;
 _LIBCPP_FUNC_VIS const error_category& system_category() _NOEXCEPT;
 
 class _LIBCPP_TYPE_VIS error_condition
 {
     int __val_;
public:
     _LIBCPP_INLINE_VISIBILITY
     const error_code& code() const _NOEXCEPT {return __ec_;}
 
 private:
     static string __init(const error_code&, string);
 };
 
 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS
-void __throw_system_error(int ev, const char* what_arg);
+void __throw_system_error(int __ev, const char* __what_arg);
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_SYSTEM_ERROR

libcxx/include/variant

 #undef _LIBCPP_VARIANT_UNION
 
 template <_Trait _DestructibleTrait, class... _Types>
 class _LIBCPP_TEMPLATE_VIS __base {
 public:
   using __index_t = __variant_index_t<sizeof...(_Types)>;
 
   inline _LIBCPP_INLINE_VISIBILITY
-  explicit constexpr __base(__valueless_t tag) noexcept
-      : __data(tag), __index(__variant_npos<__index_t>) {}
+  explicit constexpr __base(__valueless_t __tag) noexcept
+      : __data(__tag), __index(__variant_npos<__index_t>) {}
 
   template <size_t _Ip, class... _Args>
   inline _LIBCPP_INLINE_VISIBILITY
   explicit constexpr __base(in_place_index_t<_Ip>, _Args&&... __args)
       :
         __data(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...),
         __index(_Ip) {}
 

libcxx/include/vector

 #endif
     }
 #endif
 
     _LIBCPP_INLINE_VISIBILITY void pop_back() {--__size_;}
 
 #if _LIBCPP_STD_VER > 11
     template <class... _Args>
-   _LIBCPP_INLINE_VISIBILITY iterator emplace(const_iterator position, _Args&&... __args)
-        { return insert ( position, value_type ( _VSTD::forward<_Args>(__args)... )); }
+   _LIBCPP_INLINE_VISIBILITY iterator emplace(const_iterator __position, _Args&&... __args)
+        { return insert ( __position, value_type ( _VSTD::forward<_Args>(__args)... )); }
 #endif
 
     iterator insert(const_iterator __position, const value_type& __x);
     iterator insert(const_iterator __position, size_type __n, const value_type& __x);
     template <class _InputIterator>
         typename enable_if
         <
              __is_cpp17_input_iterator  <_InputIterator>::value &&

libcxx/include/wchar.h

 const wchar_t* wmemchr(const wchar_t* __s, wchar_t __c, size_t __n) {return __libcpp_wmemchr(__s, __c, __n);}
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
       wchar_t* wmemchr(      wchar_t* __s, wchar_t __c, size_t __n) {return __libcpp_wmemchr(__s, __c, __n);}
 }
 #endif
 
 #if defined(__cplusplus) && (defined(_LIBCPP_MSVCRT_LIKE) || defined(__MVS__))
 extern "C" {
-size_t mbsnrtowcs(wchar_t *__restrict dst, const char **__restrict src,
-                  size_t nmc, size_t len, mbstate_t *__restrict ps);
-size_t wcsnrtombs(char *__restrict dst, const wchar_t **__restrict src,
-                  size_t nwc, size_t len, mbstate_t *__restrict ps);
+size_t mbsnrtowcs(wchar_t *__restrict __dst, const char **__restrict __src,
+                  size_t __nmc, size_t __len, mbstate_t *__restrict __ps);
+size_t wcsnrtombs(char *__restrict __dst, const wchar_t **__restrict __src,
+                  size_t __nwc, size_t __len, mbstate_t *__restrict __ps);
 }  // extern "C"
 #endif  // __cplusplus && (_LIBCPP_MSVCRT || __MVS__)
 
 #endif // _LIBCPP_WCHAR_H