[libc++] Enable readability-identifier-naming for private member functions and fix any problems

[philnik]

Try to fix CI

libcxx/.clang-tidy

CheckOptions:
   - key:   readability-identifier-naming.PrivateMemberPrefix
     value: __
   - key:   readability-identifier-naming.PrivateMemberSuffix
     value: _
   - key:   readability-identifier-naming.LocalVariableCase
     value: lower_case
   - key:   readability-identifier-naming.LocalVariablePrefix
     value: __
+  - key:   readability-identifier-naming.PrivateMethodCase
+    value: lower_case
+  - key:   readability-identifier-naming.PrivateMethodPrefix
+    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/__chrono/parser_std_format_spec.h

case _CharT('w'):
       break;
 
     case _CharT('q'):
     case _CharT('Q'):
       __format_spec::__validate_duration(__flags);
       break;
 
     case _CharT('E'):
-      __parse_modifier_E(__begin, __end, __flags);
+      __parse_modifier_e(__begin, __end, __flags);
       break;
 
     case _CharT('O'):
-      __parse_modifier_O(__begin, __end, __flags);
+      __parse_modifier_o(__begin, __end, __flags);
       break;
 
     case _CharT('z'):
     case _CharT('Z'):
       // Currently there's no time zone information. However some clocks have a
       // hard-coded "time zone", for these clocks the information can be used.
       // TODO FMT implement time zones.
       __format_spec::__validate_time_zone(__flags);
       break;
 
     default: // unknown type;
       std::__throw_format_error("The date time type specifier is invalid");
     }
   }
 
   /// \pre *__begin == 'E'
   /// \post __begin is incremented by one.
   _LIBCPP_HIDE_FROM_ABI constexpr void
-  __parse_modifier_E(_ConstIterator& __begin, _ConstIterator __end, __flags __flags) {
+  __parse_modifier_e(_ConstIterator& __begin, _ConstIterator __end, __flags __flags) {
     ++__begin;
     if (__begin == __end)
       std::__throw_format_error("End of input while parsing the modifier E");
 
     switch (*__begin) {
     case _CharT('X'):
       __parser_.__hour_ = true;
       __format_spec::__validate_time(__flags);
__parse_modifier_e(_ConstIterator& __begin, _ConstIterator __end, __flags __flags) {
     default:
       std::__throw_format_error("The date time type specifier for modifier E is invalid");
     }
   }
 
   /// \pre *__begin == 'O'
   /// \post __begin is incremented by one.
   _LIBCPP_HIDE_FROM_ABI constexpr void
-  __parse_modifier_O(_ConstIterator& __begin, _ConstIterator __end, __flags __flags) {
+  __parse_modifier_o(_ConstIterator& __begin, _ConstIterator __end, __flags __flags) {
     ++__begin;
     if (__begin == __end)
       std::__throw_format_error("End of input while parsing the modifier O");
 
     switch (*__begin) {
     case _CharT('S'):
       __format_spec::__validate_second(__flags);
       break;

libcxx/include/__hash_table

private:
     // --- Member data begin ---
     __bucket_list                                         __bucket_list_;
     __compressed_pair<__first_node, __node_allocator>     __p1_;
     __compressed_pair<size_type, hasher>                  __p2_;
     __compressed_pair<float, key_equal>                   __p3_;
     // --- Member data end ---
 
     _LIBCPP_INLINE_VISIBILITY
-    size_type& size() _NOEXCEPT {return __p2_.first();}
+    size_type& __size() _NOEXCEPT {return __p2_.first();}
 public:
     _LIBCPP_INLINE_VISIBILITY
     size_type  size() const _NOEXCEPT {return __p2_.first();}
 
     _LIBCPP_INLINE_VISIBILITY
     hasher& hash_function() _NOEXCEPT {return __p2_.second();}
     _LIBCPP_INLINE_VISIBILITY
     const hasher& hash_function() const _NOEXCEPT {return __p2_.second();}
: __bucket_list_(_VSTD::move(__u.__bucket_list_)),
       __p2_(_VSTD::move(__u.__p2_)),
       __p3_(_VSTD::move(__u.__p3_))
 {
     if (size() > 0)
     {
         __bucket_list_[std::__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] =
             __p1_.first().__ptr();
         __u.__p1_.first().__next_ = nullptr;
-        __u.size() = 0;
+        __u.__size() = 0;
     }
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u,
                                                        const allocator_type& __a)
     : __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
       __p1_(__default_init_tag(), __node_allocator(__a)),
       __p2_(0, _VSTD::move(__u.hash_function())),
       __p3_(_VSTD::move(__u.__p3_))
 {
     if (__a == allocator_type(__u.__node_alloc()))
     {
         __bucket_list_.reset(__u.__bucket_list_.release());
         __bucket_list_.get_deleter().size() = __u.__bucket_list_.get_deleter().size();
         __u.__bucket_list_.get_deleter().size() = 0;
-        if (__u.size() > 0)
+        if (__u.__size() > 0)
         {
             __p1_.first().__next_ = __u.__p1_.first().__next_;
             __u.__p1_.first().__next_ = nullptr;
             __bucket_list_[std::__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] =
                 __p1_.first().__ptr();
-            size() = __u.size();
-            __u.size() = 0;
+            size() = __u.__size();
+            __u.__size() = 0;
         }
     }
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::~__hash_table()
 {
 #if defined(_LIBCPP_CXX03_LANG)
_NOEXCEPT_(
         is_nothrow_move_assignable<hasher>::value &&
         is_nothrow_move_assignable<key_equal>::value)
 {
     clear();
     __bucket_list_.reset(__u.__bucket_list_.release());
     __bucket_list_.get_deleter().size() = __u.__bucket_list_.get_deleter().size();
     __u.__bucket_list_.get_deleter().size() = 0;
     __move_assign_alloc(__u);
-    size() = __u.size();
+    size() = __u.__size();
     hash_function() = _VSTD::move(__u.hash_function());
     max_load_factor() = __u.max_load_factor();
     key_eq() = _VSTD::move(__u.key_eq());
     __p1_.first().__next_ = __u.__p1_.first().__next_;
     if (size() > 0)
     {
         __bucket_list_[std::__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] =
             __p1_.first().__ptr();
         __u.__p1_.first().__next_ = nullptr;
-        __u.size() = 0;
+        __u.__size() = 0;
     }
     std::__debug_db_swap(this, std::addressof(__u));
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 void
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
         __hash_table& __u, false_type)
 {
     if (__node_alloc() == __u.__node_alloc())
         __move_assign(__u, true_type());
     else
     {
         hash_function() = _VSTD::move(__u.hash_function());
         key_eq() = _VSTD::move(__u.key_eq());
         max_load_factor() = __u.max_load_factor();
         if (bucket_count() != 0)
         {
             __next_pointer __cache = __detach();
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
             try
             {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
                 const_iterator __i = __u.begin();
-                while (__cache != nullptr && __u.size() != 0)
+                while (__cache != nullptr && __u.__size() != 0)
                 {
                     __cache->__upcast()->__value_ =
                         _VSTD::move(__u.remove(__i++)->__value_);
                     __next_pointer __next = __cache->__next_;
                     __node_insert_multi(__cache->__upcast());
                     __cache = __next;
                 }
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
             }
             catch (...)
             {
                 __deallocate_node(__cache);
                 throw;
             }
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
             __deallocate_node(__cache);
         }
         const_iterator __i = __u.begin();
-        while (__u.size() != 0)
+        while (__u.__size() != 0)
         {
             __node_holder __h = __construct_node(_NodeTypes::__move(__u.remove(__i++)->__value_));
             __node_insert_multi(__h.get());
             __h.release();
         }
     }
 }
 
if (__bc != 0)
         }
         else
         {
             __h->__next_ = __pn->__next_;
             __pn->__next_ = static_cast<__next_pointer>(__h.get());
         }
         __nd = static_cast<__next_pointer>(__h.release());
         // increment size
-        ++size();
+        ++__size();
         __inserted = true;
     }
 __done:
     return pair<iterator, bool>(iterator(__nd, this), __inserted);
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class... _Args>
_VSTD::__swap_allocator(__bucket_list_.get_deleter().__alloc(),
              __u.__bucket_list_.get_deleter().__alloc());
     _VSTD::__swap_allocator(__node_alloc(), __u.__node_alloc());
     _VSTD::swap(__p1_.first().__next_, __u.__p1_.first().__next_);
     __p2_.swap(__u.__p2_);
     __p3_.swap(__u.__p3_);
     if (size() > 0)
         __bucket_list_[std::__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] =
             __p1_.first().__ptr();
-    if (__u.size() > 0)
+    if (__u.__size() > 0)
         __u.__bucket_list_[std::__constrain_hash(__u.__p1_.first().__next_->__hash(), __u.bucket_count())] =
             __u.__p1_.first().__ptr();
     std::__debug_db_swap(this, std::addressof(__u));
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::size_type
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::bucket_size(size_type __n) const

libcxx/include/__locale

public:
     static const locale& classic();
 
 private:
     class __imp;
     __imp* __locale_;
 
     void __install_ctor(const locale&, facet*, long);
     static locale& __global();
+    // NOLINTBEGIN(readability-identifier-naming) // These are in the dylib, so we can't just change the name
     bool has_facet(id&) const;
     const facet* use_facet(id&) const;
+    // NOLINTEND(readability-identifier-naming)
 
     template <class _Facet> friend bool has_facet(const locale&)  _NOEXCEPT;
     template <class _Facet> friend const _Facet& use_facet(const locale&);
 };
 
 class _LIBCPP_TYPE_VIS locale::facet
     : public __shared_count
 {

libcxx/include/__memory_resource/memory_resource.h

public:
   [[__gnu__::__nonnull__]] _LIBCPP_HIDE_FROM_ABI void
   deallocate(void* __p, size_t __bytes, size_t __align = __max_align) {
     do_deallocate(__p, __bytes, __align);
   }
 
   _LIBCPP_HIDE_FROM_ABI bool is_equal(const memory_resource& __other) const noexcept { return do_is_equal(__other); }
 
 private:
+  // NOLINTBEGIN(readability-identifier-naming) // These are visible, even though they are private
   virtual void* do_allocate(size_t, size_t)                       = 0;
   virtual void do_deallocate(void*, size_t, size_t)               = 0;
   virtual bool do_is_equal(memory_resource const&) const noexcept = 0;
+  // NOLINTEND(readability-identifier-naming)
 };
 
 // [mem.res.eq]
 
 inline _LIBCPP_HIDE_FROM_ABI bool operator==(const memory_resource& __lhs, const memory_resource& __rhs) noexcept {
   return &__lhs == &__rhs || __lhs.is_equal(__rhs);
 }
 

libcxx/include/__random/linear_congruential_engine.h

#endif
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const linear_congruential_engine& __x,
                     const linear_congruential_engine& __y)
         {return !(__x == __y);}
 
 private:
 
     _LIBCPP_INLINE_VISIBILITY
-    void seed(true_type, true_type, result_type __s) {__x_ = __s == 0 ? 1 : __s;}
+    void __seed(true_type, true_type, result_type __s) {__x_ = __s == 0 ? 1 : __s;}
     _LIBCPP_INLINE_VISIBILITY
-    void seed(true_type, false_type, result_type __s) {__x_ = __s;}
+    void __seed(true_type, false_type, result_type __s) {__x_ = __s;}
     _LIBCPP_INLINE_VISIBILITY
-    void seed(false_type, true_type, result_type __s) {__x_ = __s % __m == 0 ?
+    void __seed(false_type, true_type, result_type __s) {__x_ = __s % __m == 0 ?
                                                                  1 : __s % __m;}
     _LIBCPP_INLINE_VISIBILITY
-    void seed(false_type, false_type, result_type __s) {__x_ = __s % __m;}
+    void __seed(false_type, false_type, result_type __s) {__x_ = __s % __m;}
 
     template<class _Sseq>
         void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
     template<class _Sseq>
         void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
 
     template <class _CharT, class _Traits,
               class _Up, _Up _Ap, _Up _Cp, _Up _Np>

libcxx/include/__random/subtract_with_carry_engine.h

template <class _CharT, class _Traits,
               class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
     friend
     basic_istream<_CharT, _Traits>&
     operator>>(basic_istream<_CharT, _Traits>& __is,
                subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
 
 private:
 
-    void seed(result_type __sd, integral_constant<unsigned, 1>);
-    void seed(result_type __sd, integral_constant<unsigned, 2>);
+    void __seed(result_type __sd, integral_constant<unsigned, 1>);
+    void __seed(result_type __sd, integral_constant<unsigned, 2>);
     template<class _Sseq>
         void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
     template<class _Sseq>
         void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
 };
 
 template<class _UIntType, size_t __w, size_t __s, size_t __r>
     _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::word_size;
 
 template<class _UIntType, size_t __w, size_t __s, size_t __r>
     _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::short_lag;
 
 template<class _UIntType, size_t __w, size_t __s, size_t __r>
     _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::long_lag;
 
 template<class _UIntType, size_t __w, size_t __s, size_t __r>
     _LIBCPP_CONSTEXPR const typename subtract_with_carry_engine<_UIntType, __w, __s, __r>::result_type
     subtract_with_carry_engine<_UIntType, __w, __s, __r>::default_seed;
 
 template<class _UIntType, size_t __w, size_t __s, size_t __r>
 void
-subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd,
+subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(result_type __sd,
         integral_constant<unsigned, 1>)
 {
     linear_congruential_engine<result_type, 40014u, 0u, 2147483563u>
         __e(__sd == 0u ? default_seed : __sd);
     for (size_t __i = 0; __i < __r; ++__i)
         __x_[__i] = static_cast<result_type>(__e() & _Max);
     __c_ = __x_[__r-1] == 0;
     __i_ = 0;
 }
 
 template<class _UIntType, size_t __w, size_t __s, size_t __r>
 void
-subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd,
+subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(result_type __sd,
         integral_constant<unsigned, 2>)
 {
     linear_congruential_engine<result_type, 40014u, 0u, 2147483563u>
         __e(__sd == 0u ? default_seed : __sd);
     for (size_t __i = 0; __i < __r; ++__i)
     {
         result_type __e0 = __e();
         __x_[__i] = static_cast<result_type>(

libcxx/include/__tree

private:
     _LIBCPP_INLINE_VISIBILITY
     const __iter_pointer& __begin_node() const _NOEXCEPT {return __begin_node_;}
 public:
     _LIBCPP_INLINE_VISIBILITY
     allocator_type __alloc() const _NOEXCEPT
         {return allocator_type(__node_alloc());}
 private:
     _LIBCPP_INLINE_VISIBILITY
-          size_type& size() _NOEXCEPT {return __pair3_.first();}
+          size_type& __size() _NOEXCEPT {return __pair3_.first();}
 public:
     _LIBCPP_INLINE_VISIBILITY
     const size_type& size() const _NOEXCEPT {return __pair3_.first();}
     _LIBCPP_INLINE_VISIBILITY
           value_compare& value_comp() _NOEXCEPT {return __pair3_.second();}
     _LIBCPP_INLINE_VISIBILITY
     const value_compare& value_comp() const _NOEXCEPT
         {return __pair3_.second();}
private:
     __node_base_pointer&
         __find_equal(const_iterator __hint, __parent_pointer& __parent,
                      __node_base_pointer& __dummy,
                      const _Key& __v);
 
     template <class ..._Args>
     __node_holder __construct_node(_Args&& ...__args);
 
-    void destroy(__node_pointer __nd) _NOEXCEPT;
+    void __destroy(__node_pointer __nd) _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     void __copy_assign_alloc(const __tree& __t)
         {__copy_assign_alloc(__t, integral_constant<bool,
              __node_traits::propagate_on_container_copy_assignment::value>());}
 
     _LIBCPP_INLINE_VISIBILITY
     void __copy_assign_alloc(const __tree& __t, true_type)
struct _DetachedTreeCache {
         __cache_elem_ = __cache_root_;
         if (__cache_root_) {
           __cache_root_ = __detach_next(__cache_root_);
         }
       }
 
       _LIBCPP_INLINE_VISIBILITY
       ~_DetachedTreeCache() {
-        __t_->destroy(__cache_elem_);
+        __t_->__destroy(__cache_elem_);
         if (__cache_root_) {
           while (__cache_root_->__parent_ != nullptr)
             __cache_root_ = static_cast<__node_pointer>(__cache_root_->__parent_);
-          __t_->destroy(__cache_root_);
+          __t_->__destroy(__cache_root_);
         }
       }
 
        _DetachedTreeCache(_DetachedTreeCache const&) = delete;
        _DetachedTreeCache& operator=(_DetachedTreeCache const&) = delete;
 
     private:
       _LIBCPP_INLINE_VISIBILITY

 template <class _Tp, class _Compare, class _Allocator>
 typename __tree<_Tp, _Compare, _Allocator>::__node_pointer
 __tree<_Tp, _Compare, _Allocator>::_DetachedTreeCache::__detach_from_tree(__tree *__t) _NOEXCEPT
 {
     __node_pointer __cache = static_cast<__node_pointer>(__t->__begin_node());
     __t->__begin_node() = __t->__end_node();
     __t->__end_node()->__left_->__parent_ = nullptr;
     __t->__end_node()->__left_ = nullptr;
-    __t->size() = 0;
+    __t->__size() = 0;
     // __cache->__left_ == nullptr
     if (__cache->__right_ != nullptr)
         __cache = static_cast<__node_pointer>(__cache->__right_);
     // __cache->__left_ == nullptr
     // __cache->__right_ == nullptr
     return __cache;
 }
 

 {
     if (size() == 0)
         __begin_node() = __end_node();
     else
     {
         __end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
         __t.__begin_node() = __t.__end_node();
         __t.__end_node()->__left_ = nullptr;
-        __t.size() = 0;
+        __t.__size() = 0;
     }
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t, const allocator_type& __a)
     : __pair1_(__default_init_tag(), __node_allocator(__a)),
       __pair3_(0, _VSTD::move(__t.value_comp()))
 {
     if (__a == __t.__alloc())
     {
-        if (__t.size() == 0)
+        if (__t.__size() == 0)
             __begin_node() = __end_node();
         else
         {
             __begin_node() = __t.__begin_node();
             __end_node()->__left_ = __t.__end_node()->__left_;
             __end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
-            size() = __t.size();
+            size() = __t.__size();
             __t.__begin_node() = __t.__end_node();
             __t.__end_node()->__left_ = nullptr;
-            __t.size() = 0;
+            __t.__size() = 0;
         }
     }
     else
     {
         __begin_node() = __end_node();
     }
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 void
 __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, true_type)
     _NOEXCEPT_(is_nothrow_move_assignable<value_compare>::value &&
                is_nothrow_move_assignable<__node_allocator>::value)
 {
-    destroy(static_cast<__node_pointer>(__end_node()->__left_));
+    __destroy(static_cast<__node_pointer>(__end_node()->__left_));
     __begin_node_ = __t.__begin_node_;
     __pair1_.first() = __t.__pair1_.first();
     __move_assign_alloc(__t);
     __pair3_ = _VSTD::move(__t.__pair3_);
     if (size() == 0)
         __begin_node() = __end_node();
     else
     {
         __end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
         __t.__begin_node() = __t.__end_node();
         __t.__end_node()->__left_ = nullptr;
-        __t.size() = 0;
+        __t.__size() = 0;
     }
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 void
 __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type)
 {
     if (__node_alloc() == __t.__node_alloc())
         __move_assign(__t, true_type());
     else
     {
         value_comp() = _VSTD::move(__t.value_comp());
         const_iterator __e = end();
         if (size() != 0)
         {
             _DetachedTreeCache __cache(this);
-            while (__cache.__get() != nullptr && __t.size() != 0) {
+            while (__cache.__get() != nullptr && __t.__size() != 0) {
               __cache.__get()->__value_ = _VSTD::move(__t.remove(__t.begin())->__value_);
               __node_insert_multi(__cache.__get());
               __cache.__advance();
             }
         }
-        while (__t.size() != 0)
+        while (__t.__size() != 0)
             __insert_multi(__e, _NodeTypes::__move(__t.remove(__t.begin())->__value_));
     }
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>&
 __tree<_Tp, _Compare, _Allocator>::operator=(__tree&& __t)
     _NOEXCEPT_(
         __node_traits::propagate_on_container_move_assignment::value &&
         is_nothrow_move_assignable<value_compare>::value &&
         is_nothrow_move_assignable<__node_allocator>::value)
 
 {
     __move_assign(__t, integral_constant<bool,
                   __node_traits::propagate_on_container_move_assignment::value>());
     return *this;
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>::~__tree()
 {
     static_assert((is_copy_constructible<value_compare>::value),
                  "Comparator must be copy-constructible.");
-  destroy(__root());
+  __destroy(__root());
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 void
-__tree<_Tp, _Compare, _Allocator>::destroy(__node_pointer __nd) _NOEXCEPT
+__tree<_Tp, _Compare, _Allocator>::__destroy(__node_pointer __nd) _NOEXCEPT
 {
     if (__nd != nullptr)
     {
-        destroy(static_cast<__node_pointer>(__nd->__left_));
-        destroy(static_cast<__node_pointer>(__nd->__right_));
+        __destroy(static_cast<__node_pointer>(__nd->__left_));
+        __destroy(static_cast<__node_pointer>(__nd->__right_));
         __node_allocator& __na = __node_alloc();
         __node_traits::destroy(__na, _NodeTypes::__get_ptr(__nd->__value_));
         __node_traits::deallocate(__na, __nd, 1);
     }
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 void
#endif
     swap(__begin_node_, __t.__begin_node_);
     swap(__pair1_.first(), __t.__pair1_.first());
     _VSTD::__swap_allocator(__node_alloc(), __t.__node_alloc());
     __pair3_.swap(__t.__pair3_);
     if (size() == 0)
         __begin_node() = __end_node();
     else
         __end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
-    if (__t.size() == 0)
+    if (__t.__size() == 0)
         __t.__begin_node() = __t.__end_node();
     else
         __t.__end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__t.__end_node());
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 void
 __tree<_Tp, _Compare, _Allocator>::clear() _NOEXCEPT
 {
-    destroy(__root());
+    __destroy(__root());
     size() = 0;
     __begin_node() = __end_node();
     __end_node()->__left_ = nullptr;
 }
 
 // Find lower_bound place to insert
 // Set __parent to parent of null leaf
 // Return reference to null leaf

 
 template <class _Tp, class _Compare, class _Allocator>
 typename __tree<_Tp, _Compare, _Allocator>::iterator
 __tree<_Tp, _Compare, _Allocator>::erase(const_iterator __p)
 {
     __node_pointer __np = __p.__get_np();
     iterator __r = __remove_node_pointer(__np);
     __node_allocator& __na = __node_alloc();
-    __node_traits::destroy(__na, _NodeTypes::__get_ptr(
+    __node_traits::__destroy(__na, _NodeTypes::__get_ptr(
         const_cast<__node_value_type&>(*__p)));
     __node_traits::deallocate(__na, __np, 1);
     return __r;
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 typename __tree<_Tp, _Compare, _Allocator>::iterator
 __tree<_Tp, _Compare, _Allocator>::erase(const_iterator __f, const_iterator __l)

libcxx/include/bitset

protected:
     void operator&=(const __bitset& __v) _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
     void operator|=(const __bitset& __v) _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
     void operator^=(const __bitset& __v) _NOEXCEPT;
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void flip() _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long to_ulong() const
-        {return to_ulong(integral_constant<bool, _Size < sizeof(unsigned long) * CHAR_BIT>());}
+        {return __to_ulong(integral_constant<bool, _Size < sizeof(unsigned long) * CHAR_BIT>());}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long to_ullong() const
-        {return to_ullong(integral_constant<bool, _Size < sizeof(unsigned long long) * CHAR_BIT>());}
+        {return __to_ullong(integral_constant<bool, _Size < sizeof(unsigned long long) * CHAR_BIT>());}
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool all() const _NOEXCEPT;
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool any() const _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     size_t __hash_code() const _NOEXCEPT;
 private:
 #ifdef _LIBCPP_CXX03_LANG
     void __init(unsigned long long __v, false_type) _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     void __init(unsigned long long __v, true_type) _NOEXCEPT;
 #endif // _LIBCPP_CXX03_LANG
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-    unsigned long to_ulong(false_type) const;
+    unsigned long __to_ulong(false_type) const;
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    unsigned long to_ulong(true_type) const;
+    unsigned long __to_ulong(true_type) const;
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-    unsigned long long to_ullong(false_type) const;
+    unsigned long long __to_ullong(false_type) const;
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    unsigned long long to_ullong(true_type) const;
+    unsigned long long __to_ullong(true_type) const;
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    unsigned long long to_ullong(true_type, false_type) const;
+    unsigned long long __to_ullong(true_type, false_type) const;
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-    unsigned long long to_ullong(true_type, true_type) const;
+    unsigned long long __to_ullong(true_type, true_type) const;
 };
 
 template <size_t _N_words, size_t _Size>
 inline
 _LIBCPP_CONSTEXPR
 __bitset<_N_words, _Size>::__bitset() _NOEXCEPT
 #ifndef _LIBCPP_CXX03_LANG
     : __first_{0}
if (__n > 0)
         __storage_type __b = *__p & __m;
         *__p &= ~__m;
         *__p |= ~__b & __m;
     }
 }
 
 template <size_t _N_words, size_t _Size>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long
-__bitset<_N_words, _Size>::to_ulong(false_type) const
+__bitset<_N_words, _Size>::__to_ulong(false_type) const
 {
     const_iterator __e = __make_iter(_Size);
     const_iterator __i = _VSTD::find(__make_iter(sizeof(unsigned long) * CHAR_BIT), __e, true);
     if (__i != __e)
         __throw_overflow_error("bitset to_ulong overflow error");
 
     return __first_[0];
 }
 
 template <size_t _N_words, size_t _Size>
 inline
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long
-__bitset<_N_words, _Size>::to_ulong(true_type) const
+__bitset<_N_words, _Size>::__to_ulong(true_type) const
 {
     return __first_[0];
 }
 
 template <size_t _N_words, size_t _Size>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long
-__bitset<_N_words, _Size>::to_ullong(false_type) const
+__bitset<_N_words, _Size>::__to_ullong(false_type) const
 {
     const_iterator __e = __make_iter(_Size);
     const_iterator __i = _VSTD::find(__make_iter(sizeof(unsigned long long) * CHAR_BIT), __e, true);
     if (__i != __e)
         __throw_overflow_error("bitset to_ullong overflow error");
 
-    return to_ullong(true_type());
+    return __to_ullong(true_type());
 }
 
 template <size_t _N_words, size_t _Size>
 inline
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long
-__bitset<_N_words, _Size>::to_ullong(true_type) const
+__bitset<_N_words, _Size>::__to_ullong(true_type) const
 {
-    return to_ullong(true_type(), integral_constant<bool, sizeof(__storage_type) < sizeof(unsigned long long)>());
+    return __to_ullong(true_type(), integral_constant<bool, sizeof(__storage_type) < sizeof(unsigned long long)>());
 }
 
 template <size_t _N_words, size_t _Size>
 inline
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long
-__bitset<_N_words, _Size>::to_ullong(true_type, false_type) const
+__bitset<_N_words, _Size>::__to_ullong(true_type, false_type) const
 {
     return __first_[0];
 }
 
 template <size_t _N_words, size_t _Size>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long
-__bitset<_N_words, _Size>::to_ullong(true_type, true_type) const
+__bitset<_N_words, _Size>::__to_ullong(true_type, true_type) const
 {
     unsigned long long __r = __first_[0];
     for (size_t __i = 1; __i < sizeof(unsigned long long) / sizeof(__storage_type); ++__i)
         __r |= static_cast<unsigned long long>(__first_[__i]) << (sizeof(__storage_type) * CHAR_BIT);
     return __r;
 }
 
 template <size_t _N_words, size_t _Size>

libcxx/include/experimental/memory_resource

void deallocate(void * __p, size_t __bytes, size_t __align = __max_align)
         { do_deallocate(__p, __bytes, __align); }
 
     _LIBCPP_INLINE_VISIBILITY
     bool is_equal(memory_resource const & __other) const _NOEXCEPT
         { return do_is_equal(__other); }
 
 // 8.5.3, memory.resource.priv
 private:
+  // NOLINTBEGIN(readability-identifier-naming) // These are visible, even though they are private
     virtual void* do_allocate(size_t, size_t) = 0;
     virtual void do_deallocate(void*, size_t, size_t) = 0;
     virtual bool do_is_equal(memory_resource const &) const _NOEXCEPT = 0;
+  // NOLINTEND(readability-identifier-naming)
 };
 
 // 8.5.4, memory.resource.eq
 _LIBCPP_DEPCREATED_MEMORY_RESOURCE("operator==(memory_resource, memory_resource)") inline _LIBCPP_INLINE_VISIBILITY
 bool operator==(memory_resource const & __lhs,
                 memory_resource const & __rhs) _NOEXCEPT
 {
     return &__lhs == &__rhs || __lhs.is_equal(__rhs);

libcxx/include/locale

protected:
     explicit __time_get_storage(const char* __nm);
     explicit __time_get_storage(const string& __nm);
 
     _LIBCPP_INLINE_VISIBILITY ~__time_get_storage() {}
 
     time_base::dateorder __do_date_order() const;
 
 private:
-    void init(const ctype<_CharT>&);
+    void init(const ctype<_CharT>&); // NOLINT(readability-identifier-naming) // The symbol is part of the dylib
     string_type __analyze(char __fmt, const ctype<_CharT>&);
 };
 
 #define _LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION(_CharT) \
 template <> _LIBCPP_FUNC_VIS time_base::dateorder __time_get_storage<_CharT>::__do_date_order() const; \
 template <> _LIBCPP_FUNC_VIS __time_get_storage<_CharT>::__time_get_storage(const char*); \
 template <> _LIBCPP_FUNC_VIS __time_get_storage<_CharT>::__time_get_storage(const string&); \
 template <> _LIBCPP_FUNC_VIS void __time_get_storage<_CharT>::init(const ctype<_CharT>&); \
private:
     string      __grouping_;
     string_type __curr_symbol_;
     string_type __positive_sign_;
     string_type __negative_sign_;
     int         __frac_digits_;
     pattern     __pos_format_;
     pattern     __neg_format_;
 
-    void init(const char*);
+    void init(const char*); // NOLINT(readability-identifier-naming) // The symbol is part of the dylib
 };
 
+// NOLINTBEGIN(readability-identifier-naming) // The symbols are part of the dylib
 template<> _LIBCPP_FUNC_VIS void moneypunct_byname<char, false>::init(const char*);
 template<> _LIBCPP_FUNC_VIS void moneypunct_byname<char, true>::init(const char*);
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<char, false>;
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<char, true>;
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template<> _LIBCPP_FUNC_VIS void moneypunct_byname<wchar_t, false>::init(const char*);
 template<> _LIBCPP_FUNC_VIS void moneypunct_byname<wchar_t, true>::init(const char*);
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<wchar_t, false>;
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<wchar_t, true>;
 #endif
+// NOLINTEND(readability-identifier-naming)
 
 // money_get
 
 template <class _CharT>
 class __money_get
 {
 protected:
     typedef _CharT                  char_type;

libcxx/include/regex

private:
     template <class _ForwardIterator>
         _ForwardIterator
         __parse(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_basic_reg_exp(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
-        __parse_RE_expression(_ForwardIterator __first, _ForwardIterator __last);
+        __parse_re_expression(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
-        __parse_simple_RE(_ForwardIterator __first, _ForwardIterator __last);
+        __parse_simple_re(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
-        __parse_nondupl_RE(_ForwardIterator __first, _ForwardIterator __last);
+        __parse_nondupl_re(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
-        __parse_one_char_or_coll_elem_RE(_ForwardIterator __first, _ForwardIterator __last);
+        __parse_one_char_or_coll_elem_re(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
-        __parse_Back_open_paren(_ForwardIterator __first, _ForwardIterator __last);
+        __parse_back_open_paren(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
-        __parse_Back_close_paren(_ForwardIterator __first, _ForwardIterator __last);
+        __parse_back_close_paren(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
-        __parse_Back_open_brace(_ForwardIterator __first, _ForwardIterator __last);
+        __parse_back_open_brace(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
-        __parse_Back_close_brace(_ForwardIterator __first, _ForwardIterator __last);
+        __parse_back_close_brace(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
-        __parse_BACKREF(_ForwardIterator __first, _ForwardIterator __last);
+        __parse_backref(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
-        __parse_ORD_CHAR(_ForwardIterator __first, _ForwardIterator __last);
+        __parse_ord_char(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
-        __parse_QUOTED_CHAR(_ForwardIterator __first, _ForwardIterator __last);
+        __parse_quoted_char(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
-        __parse_RE_dupl_symbol(_ForwardIterator __first, _ForwardIterator __last,
+        __parse_re_dupl_symbol(_ForwardIterator __first, _ForwardIterator __last,
                                __owns_one_state<_CharT>* __s,
                                unsigned __mexp_begin, unsigned __mexp_end);
     template <class _ForwardIterator>
         _ForwardIterator
-        __parse_ERE_dupl_symbol(_ForwardIterator __first, _ForwardIterator __last,
+        __parse_ere_dupl_symbol(_ForwardIterator __first, _ForwardIterator __last,
                                 __owns_one_state<_CharT>* __s,
                                 unsigned __mexp_begin, unsigned __mexp_end);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_bracket_expression(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_follow_list(_ForwardIterator __first, _ForwardIterator __last,
template <class _ForwardIterator>
         __parse_character_class(_ForwardIterator __first, _ForwardIterator __last,
                                 __bracket_expression<_CharT, _Traits>* __ml);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_collating_symbol(_ForwardIterator __first, _ForwardIterator __last,
                                  basic_string<_CharT>& __col_sym);
     template <class _ForwardIterator>
         _ForwardIterator
-        __parse_DUP_COUNT(_ForwardIterator __first, _ForwardIterator __last, int& __c);
+        __parse_dup_count(_ForwardIterator __first, _ForwardIterator __last, int& __c);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_extended_reg_exp(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
-        __parse_ERE_branch(_ForwardIterator __first, _ForwardIterator __last);
+        __parse_ere_branch(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
-        __parse_ERE_expression(_ForwardIterator __first, _ForwardIterator __last);
+        __parse_ere_expression(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
-        __parse_one_char_or_coll_elem_ERE(_ForwardIterator __first, _ForwardIterator __last);
+        __parse_one_char_or_coll_elem_ere(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
-        __parse_ORD_CHAR_ERE(_ForwardIterator __first, _ForwardIterator __last);
+        __parse_ord_char_ere(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
-        __parse_QUOTED_CHAR_ERE(_ForwardIterator __first, _ForwardIterator __last);
+        __parse_quoted_char_ere(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_ecma_exp(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_alternative(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
basic_regex<_CharT, _Traits>::__parse_basic_reg_exp(_ForwardIterator __first,
     {
         if (*__first == '^')
         {
             __push_l_anchor();
             ++__first;
         }
         if (__first != __last)
         {
-            __first = __parse_RE_expression(__first, __last);
+            __first = __parse_re_expression(__first, __last);
             if (__first != __last)
             {
                 _ForwardIterator __temp = _VSTD::next(__first);
                 if (__temp == __last && *__first == '$')
                 {
                     __push_r_anchor();
                     ++__first;
                 }
             }
         }
         if (__first != __last)
             __throw_regex_error<regex_constants::__re_err_empty>();
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_extended_reg_exp(_ForwardIterator __first,
                                                        _ForwardIterator __last)
 {
     __owns_one_state<_CharT>* __sa = __end_;
-    _ForwardIterator __temp = __parse_ERE_branch(__first, __last);
+    _ForwardIterator __temp = __parse_ere_branch(__first, __last);
     if (__temp == __first)
         __throw_regex_error<regex_constants::__re_err_empty>();
     __first = __temp;
     while (__first != __last && *__first == '|')
     {
         __owns_one_state<_CharT>* __sb = __end_;
-        __temp = __parse_ERE_branch(++__first, __last);
+        __temp = __parse_ere_branch(++__first, __last);
         if (__temp == __first)
             __throw_regex_error<regex_constants::__re_err_empty>();
         __push_alternation(__sa, __sb);
         __first = __temp;
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_ERE_branch(_ForwardIterator __first,
+basic_regex<_CharT, _Traits>::__parse_ere_branch(_ForwardIterator __first,
                                                  _ForwardIterator __last)
 {
-    _ForwardIterator __temp = __parse_ERE_expression(__first, __last);
+    _ForwardIterator __temp = __parse_ere_expression(__first, __last);
     if (__temp == __first)
         __throw_regex_error<regex_constants::__re_err_empty>();
     do
     {
         __first = __temp;
-        __temp = __parse_ERE_expression(__first, __last);
+        __temp = __parse_ere_expression(__first, __last);
     } while (__temp != __first);
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_ERE_expression(_ForwardIterator __first,
+basic_regex<_CharT, _Traits>::__parse_ere_expression(_ForwardIterator __first,
                                                      _ForwardIterator __last)
 {
     __owns_one_state<_CharT>* __e = __end_;
     unsigned __mexp_begin = __marked_count_;
-    _ForwardIterator __temp = __parse_one_char_or_coll_elem_ERE(__first, __last);
+    _ForwardIterator __temp = __parse_one_char_or_coll_elem_ere(__first, __last);
     if (__temp == __first && __temp != __last)
     {
         switch (*__temp)
         {
         case '^':
             __push_l_anchor();
             ++__temp;
             break;
if (__temp == __first && __temp != __last)
                 __throw_regex_error<regex_constants::error_paren>();
             __push_end_marked_subexpression(__temp_count);
             --__open_count_;
             ++__temp;
             break;
         }
     }
     if (__temp != __first)
-        __temp = __parse_ERE_dupl_symbol(__temp, __last, __e, __mexp_begin+1,
+        __temp = __parse_ere_dupl_symbol(__temp, __last, __e, __mexp_begin+1,
                                          __marked_count_+1);
     __first = __temp;
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_RE_expression(_ForwardIterator __first,
+basic_regex<_CharT, _Traits>::__parse_re_expression(_ForwardIterator __first,
                                                     _ForwardIterator __last)
 {
     while (true)
     {
-        _ForwardIterator __temp = __parse_simple_RE(__first, __last);
+        _ForwardIterator __temp = __parse_simple_re(__first, __last);
         if (__temp == __first)
             break;
         __first = __temp;
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_simple_RE(_ForwardIterator __first,
+basic_regex<_CharT, _Traits>::__parse_simple_re(_ForwardIterator __first,
                                                 _ForwardIterator __last)
 {
     if (__first != __last)
     {
         __owns_one_state<_CharT>* __e = __end_;
         unsigned __mexp_begin = __marked_count_;
-        _ForwardIterator __temp = __parse_nondupl_RE(__first, __last);
+        _ForwardIterator __temp = __parse_nondupl_re(__first, __last);
         if (__temp != __first)
-            __first = __parse_RE_dupl_symbol(__temp, __last, __e,
+            __first = __parse_re_dupl_symbol(__temp, __last, __e,
                                              __mexp_begin+1, __marked_count_+1);
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_nondupl_RE(_ForwardIterator __first,
+basic_regex<_CharT, _Traits>::__parse_nondupl_re(_ForwardIterator __first,
                                                  _ForwardIterator __last)
 {
     _ForwardIterator __temp = __first;
-    __first = __parse_one_char_or_coll_elem_RE(__first, __last);
+    __first = __parse_one_char_or_coll_elem_re(__first, __last);
     if (__temp == __first)
     {
-        __temp = __parse_Back_open_paren(__first, __last);
+        __temp = __parse_back_open_paren(__first, __last);
         if (__temp != __first)
         {
             __push_begin_marked_subexpression();
             unsigned __temp_count = __marked_count_;
-            __first = __parse_RE_expression(__temp, __last);
-            __temp = __parse_Back_close_paren(__first, __last);
+            __first = __parse_re_expression(__temp, __last);
+            __temp = __parse_back_close_paren(__first, __last);
             if (__temp == __first)
                 __throw_regex_error<regex_constants::error_paren>();
             __push_end_marked_subexpression(__temp_count);
             __first = __temp;
         }
         else
-            __first = __parse_BACKREF(__first, __last);
+            __first = __parse_backref(__first, __last);
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_one_char_or_coll_elem_RE(
+basic_regex<_CharT, _Traits>::__parse_one_char_or_coll_elem_re(
                                                        _ForwardIterator __first,
                                                        _ForwardIterator __last)
 {
-    _ForwardIterator __temp = __parse_ORD_CHAR(__first, __last);
+    _ForwardIterator __temp = __parse_ord_char(__first, __last);
     if (__temp == __first)
     {
-        __temp = __parse_QUOTED_CHAR(__first, __last);
+        __temp = __parse_quoted_char(__first, __last);
         if (__temp == __first)
         {
             if (__temp != __last && *__temp == '.')
             {
                 __push_match_any();
                 ++__temp;
             }
             else
                 __temp = __parse_bracket_expression(__first, __last);
         }
     }
     __first = __temp;
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_one_char_or_coll_elem_ERE(
+basic_regex<_CharT, _Traits>::__parse_one_char_or_coll_elem_ere(
                                                        _ForwardIterator __first,
                                                        _ForwardIterator __last)
 {
-    _ForwardIterator __temp = __parse_ORD_CHAR_ERE(__first, __last);
+    _ForwardIterator __temp = __parse_ord_char_ere(__first, __last);
     if (__temp == __first)
     {
-        __temp = __parse_QUOTED_CHAR_ERE(__first, __last);
+        __temp = __parse_quoted_char_ere(__first, __last);
         if (__temp == __first)
         {
             if (__temp != __last && *__temp == '.')
             {
                 __push_match_any();
                 ++__temp;
             }
             else
                 __temp = __parse_bracket_expression(__first, __last);
         }
     }
     __first = __temp;
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_Back_open_paren(_ForwardIterator __first,
+basic_regex<_CharT, _Traits>::__parse_back_open_paren(_ForwardIterator __first,
                                                       _ForwardIterator __last)
 {
     if (__first != __last)
     {
         _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp != __last)
         {
             if (*__first == '\\' && *__temp == '(')
                 __first = ++__temp;
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_Back_close_paren(_ForwardIterator __first,
+basic_regex<_CharT, _Traits>::__parse_back_close_paren(_ForwardIterator __first,
                                                        _ForwardIterator __last)
 {
     if (__first != __last)
     {
         _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp != __last)
         {
             if (*__first == '\\' && *__temp == ')')
                 __first = ++__temp;
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_Back_open_brace(_ForwardIterator __first,
+basic_regex<_CharT, _Traits>::__parse_back_open_brace(_ForwardIterator __first,
                                                       _ForwardIterator __last)
 {
     if (__first != __last)
     {
         _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp != __last)
         {
             if (*__first == '\\' && *__temp == '{')
                 __first = ++__temp;
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_Back_close_brace(_ForwardIterator __first,
+basic_regex<_CharT, _Traits>::__parse_back_close_brace(_ForwardIterator __first,
                                                        _ForwardIterator __last)
 {
     if (__first != __last)
     {
         _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp != __last)
         {
             if (*__first == '\\' && *__temp == '}')
                 __first = ++__temp;
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_BACKREF(_ForwardIterator __first,
+basic_regex<_CharT, _Traits>::__parse_backref(_ForwardIterator __first,
                                               _ForwardIterator __last)
 {
     if (__first != __last)
     {
         _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp != __last && *__first == '\\' && __test_back_ref(*__temp))
             __first = ++__temp;
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_ORD_CHAR(_ForwardIterator __first,
+basic_regex<_CharT, _Traits>::__parse_ord_char(_ForwardIterator __first,
                                                _ForwardIterator __last)
 {
     if (__first != __last)
     {
         _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp == __last && *__first == '$')
             return __first;
         // Not called inside a bracket
         if (*__first == '.' || *__first == '\\' || *__first == '[')
             return __first;
         __push_char(*__first);
         ++__first;
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_ORD_CHAR_ERE(_ForwardIterator __first,
+basic_regex<_CharT, _Traits>::__parse_ord_char_ere(_ForwardIterator __first,
                                                    _ForwardIterator __last)
 {
     if (__first != __last)
     {
         switch (*__first)
         {
         case '^':
         case '.':
if (__first != __last)
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR(_ForwardIterator __first,
+basic_regex<_CharT, _Traits>::__parse_quoted_char(_ForwardIterator __first,
                                                   _ForwardIterator __last)
 {
     if (__first != __last)
     {
         _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp != __last)
         {
             if (*__first == '\\')
if (__first != __last)
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR_ERE(_ForwardIterator __first,
+basic_regex<_CharT, _Traits>::__parse_quoted_char_ere(_ForwardIterator __first,
                                                       _ForwardIterator __last)
 {
     if (__first != __last)
     {
         _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp != __last)
         {
             if (*__first == '\\')
if (__first != __last)
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_RE_dupl_symbol(_ForwardIterator __first,
+basic_regex<_CharT, _Traits>::__parse_re_dupl_symbol(_ForwardIterator __first,
                                                      _ForwardIterator __last,
                                                      __owns_one_state<_CharT>* __s,
                                                      unsigned __mexp_begin,
                                                      unsigned __mexp_end)
 {
     if (__first != __last)
     {
         if (*__first == '*')
         {
             __push_greedy_inf_repeat(0, __s, __mexp_begin, __mexp_end);
             ++__first;
         }
         else
         {
-            _ForwardIterator __temp = __parse_Back_open_brace(__first, __last);
+            _ForwardIterator __temp = __parse_back_open_brace(__first, __last);
             if (__temp != __first)
             {
                 int __min = 0;
                 __first = __temp;
-                __temp = __parse_DUP_COUNT(__first, __last, __min);
+                __temp = __parse_dup_count(__first, __last, __min);
                 if (__temp == __first)
                     __throw_regex_error<regex_constants::error_badbrace>();
                 __first = __temp;
                 if (__first == __last)
                     __throw_regex_error<regex_constants::error_brace>();
                 if (*__first != ',')
                 {
-                    __temp = __parse_Back_close_brace(__first, __last);
+                    __temp = __parse_back_close_brace(__first, __last);
                     if (__temp == __first)
                         __throw_regex_error<regex_constants::error_brace>();
                     __push_loop(__min, __min, __s, __mexp_begin, __mexp_end,
                                     true);
                     __first = __temp;
                 }
                 else
                 {
                     ++__first;  // consume ','
                     int __max = -1;
-                    __first = __parse_DUP_COUNT(__first, __last, __max);
-                    __temp = __parse_Back_close_brace(__first, __last);
+                    __first = __parse_dup_count(__first, __last, __max);
+                    __temp = __parse_back_close_brace(__first, __last);
                     if (__temp == __first)
                         __throw_regex_error<regex_constants::error_brace>();
                     if (__max == -1)
                         __push_greedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
                     else
                     {
                         if (__max < __min)
                             __throw_regex_error<regex_constants::error_badbrace>();
                         __push_loop(__min, __max, __s, __mexp_begin, __mexp_end,
                                     true);
                     }
                     __first = __temp;
                 }
             }
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_ERE_dupl_symbol(_ForwardIterator __first,
+basic_regex<_CharT, _Traits>::__parse_ere_dupl_symbol(_ForwardIterator __first,
                                                       _ForwardIterator __last,
                                                       __owns_one_state<_CharT>* __s,
                                                       unsigned __mexp_begin,
                                                       unsigned __mexp_end)
 {
     if (__first != __last)
     {
         unsigned __grammar = __get_grammar(__flags_);
if (__first != __last)
                 __push_loop(0, 1, __s, __mexp_begin, __mexp_end, false);
             }
             else
                 __push_loop(0, 1, __s, __mexp_begin, __mexp_end);
             break;
         case '{':
             {
                 int __min;
-                _ForwardIterator __temp = __parse_DUP_COUNT(++__first, __last, __min);
+                _ForwardIterator __temp = __parse_dup_count(++__first, __last, __min);
                 if (__temp == __first)
                     __throw_regex_error<regex_constants::error_badbrace>();
                 __first = __temp;
                 if (__first == __last)
                     __throw_regex_error<regex_constants::error_brace>();
                 switch (*__first)
                 {
                 case '}':
if (__first != __last)
                             __push_nongreedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
                         }
                         else
                             __push_greedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
                     }
                     else
                     {
                         int __max = -1;
-                        __temp = __parse_DUP_COUNT(__first, __last, __max);
+                        __temp = __parse_dup_count(__first, __last, __max);
                         if (__temp == __first)
                             __throw_regex_error<regex_constants::error_brace>();
                         __first = __temp;
                         if (__first == __last || *__first != '}')
                             __throw_regex_error<regex_constants::error_brace>();
                         ++__first;
                         if (__max < __min)
                             __throw_regex_error<regex_constants::error_badbrace>();
basic_regex<_CharT, _Traits>::__parse_collating_symbol(_ForwardIterator __first,
     }
     __first = _VSTD::next(__temp, 2);
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_DUP_COUNT(_ForwardIterator __first,
+basic_regex<_CharT, _Traits>::__parse_dup_count(_ForwardIterator __first,
                                                 _ForwardIterator __last,
                                                 int& __c)
 {
     if (__first != __last )
     {
         int __val = __traits_.value(*__first, 10);
         if ( __val != -1 )
         {

 {
     _ForwardIterator __temp = __parse_assertion(__first, __last);
     if (__temp == __first)
     {
         __owns_one_state<_CharT>* __e = __end_;
         unsigned __mexp_begin = __marked_count_;
         __temp = __parse_atom(__first, __last);
         if (__temp != __first)
-            __first = __parse_ERE_dupl_symbol(__temp, __last, __e,
+            __first = __parse_ere_dupl_symbol(__temp, __last, __e,
                                               __mexp_begin+1, __marked_count_+1);
     }
     else
         __first = __temp;
     return __first;
 }
 
 template <class _CharT, class _Traits>