Rename list::base to list::__base.

[dlj]

Summary

Even though the base typedef is private, it still participates in lookup. For example:

void base() {}
struct X : private std::list<int> {
  X() { base(); }
};

include/list

#if _LIBCPP_DEBUG_LEVEL >= 2
     __db->unlock();
 #endif
 }
 
 template <class _Tp, class _Alloc /*= allocator<_Tp>*/>
 class _LIBCPP_TEMPLATE_VIS list
     : private __list_imp<_Tp, _Alloc>
 {
-    typedef __list_imp<_Tp, _Alloc> base;
-    typedef typename base::__node              __node;
-    typedef typename base::__node_allocator    __node_allocator;
-    typedef typename base::__node_pointer      __node_pointer;
-    typedef typename base::__node_alloc_traits __node_alloc_traits;
-    typedef typename base::__node_base         __node_base;
-    typedef typename base::__node_base_pointer __node_base_pointer;
-    typedef typename base::__link_pointer __link_pointer;
+    typedef __list_imp<_Tp, _Alloc> __base;
+    typedef typename __base::__node              __node;
+    typedef typename __base::__node_allocator    __node_allocator;
+    typedef typename __base::__node_pointer      __node_pointer;
+    typedef typename __base::__node_alloc_traits __node_alloc_traits;
+    typedef typename __base::__node_base         __node_base;
+    typedef typename __base::__node_base_pointer __node_base_pointer;
+    typedef typename __base::__link_pointer      __link_pointer;
 
 public:
     typedef _Tp                                      value_type;
     typedef _Alloc                                   allocator_type;
     static_assert((is_same<value_type, typename allocator_type::value_type>::value),
                   "Invalid allocator::value_type");
     typedef value_type&                              reference;
     typedef const value_type&                        const_reference;
-    typedef typename base::pointer                   pointer;
-    typedef typename base::const_pointer             const_pointer;
-    typedef typename base::size_type                 size_type;
-    typedef typename base::difference_type           difference_type;
-    typedef typename base::iterator                  iterator;
-    typedef typename base::const_iterator            const_iterator;
-    typedef _VSTD::reverse_iterator<iterator>         reverse_iterator;
-    typedef _VSTD::reverse_iterator<const_iterator>   const_reverse_iterator;
+    typedef typename __base::pointer                 pointer;
+    typedef typename __base::const_pointer           const_pointer;
+    typedef typename __base::size_type               size_type;
+    typedef typename __base::difference_type         difference_type;
+    typedef typename __base::iterator                iterator;
+    typedef typename __base::const_iterator          const_iterator;
+    typedef _VSTD::reverse_iterator<iterator>        reverse_iterator;
+    typedef _VSTD::reverse_iterator<const_iterator>  const_reverse_iterator;
 
     _LIBCPP_INLINE_VISIBILITY
     list()
         _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
     {
 #if _LIBCPP_DEBUG_LEVEL >= 2
         __get_db()->__insert_c(this);
 #endif
     }
     _LIBCPP_INLINE_VISIBILITY
-    explicit list(const allocator_type& __a) : base(__a)
+    explicit list(const allocator_type& __a) : __base(__a)
     {
 #if _LIBCPP_DEBUG_LEVEL >= 2
         __get_db()->__insert_c(this);
 #endif
     }
     explicit list(size_type __n);
 #if _LIBCPP_STD_VER > 11
     explicit list(size_type __n, const allocator_type& __a);
template <class _InpIter>
         void assign(_InpIter __f, _InpIter __l,
              typename enable_if<__is_input_iterator<_InpIter>::value>::type* = 0);
     void assign(size_type __n, const value_type& __x);
 
     _LIBCPP_INLINE_VISIBILITY
     allocator_type get_allocator() const _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
-    size_type size() const _NOEXCEPT     {return base::__sz();}
+    size_type size() const _NOEXCEPT     {return __base::__sz();}
     _LIBCPP_INLINE_VISIBILITY
-    bool empty() const _NOEXCEPT         {return base::empty();}
+    bool empty() const _NOEXCEPT         {return __base::empty();}
     _LIBCPP_INLINE_VISIBILITY
     size_type max_size() const _NOEXCEPT
         {
             return std::min<size_type>(
-                base::__node_alloc_max_size(),
+                __base::__node_alloc_max_size(),
                 numeric_limits<difference_type >::max());
         }
 
     _LIBCPP_INLINE_VISIBILITY
-          iterator begin() _NOEXCEPT        {return base::begin();}
+          iterator begin() _NOEXCEPT        {return __base::begin();}
     _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin()  const _NOEXCEPT {return base::begin();}
+    const_iterator begin()  const _NOEXCEPT {return __base::begin();}
     _LIBCPP_INLINE_VISIBILITY
-          iterator end() _NOEXCEPT          {return base::end();}
+          iterator end() _NOEXCEPT          {return __base::end();}
     _LIBCPP_INLINE_VISIBILITY
-    const_iterator end()    const _NOEXCEPT {return base::end();}
+    const_iterator end()    const _NOEXCEPT {return __base::end();}
     _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin() const _NOEXCEPT {return base::begin();}
+    const_iterator cbegin() const _NOEXCEPT {return __base::begin();}
     _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend()   const _NOEXCEPT {return base::end();}
+    const_iterator cend()   const _NOEXCEPT {return __base::end();}
 
     _LIBCPP_INLINE_VISIBILITY
           reverse_iterator rbegin() _NOEXCEPT
             {return       reverse_iterator(end());}
     _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator rbegin()  const _NOEXCEPT
         {return const_reverse_iterator(end());}
     _LIBCPP_INLINE_VISIBILITY
           reverse_iterator rend() _NOEXCEPT
             {return       reverse_iterator(begin());}
     _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator rend()    const _NOEXCEPT
         {return const_reverse_iterator(begin());}
     _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator crbegin() const _NOEXCEPT
         {return const_reverse_iterator(end());}
     _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator crend()   const _NOEXCEPT
         {return const_reverse_iterator(begin());}
 
     _LIBCPP_INLINE_VISIBILITY
     reference front()
     {
         _LIBCPP_ASSERT(!empty(), "list::front called on empty list");
-        return base::__end_.__next_->__as_node()->__value_;
+        return __base::__end_.__next_->__as_node()->__value_;
     }
     _LIBCPP_INLINE_VISIBILITY
     const_reference front() const
     {
         _LIBCPP_ASSERT(!empty(), "list::front called on empty list");
-        return base::__end_.__next_->__as_node()->__value_;
+        return __base::__end_.__next_->__as_node()->__value_;
     }
     _LIBCPP_INLINE_VISIBILITY
     reference back()
     {
         _LIBCPP_ASSERT(!empty(), "list::back called on empty list");
-        return base::__end_.__prev_->__as_node()->__value_;
+        return __base::__end_.__prev_->__as_node()->__value_;
     }
     _LIBCPP_INLINE_VISIBILITY
     const_reference back() const
     {
         _LIBCPP_ASSERT(!empty(), "list::back called on empty list");
-        return base::__end_.__prev_->__as_node()->__value_;
+        return __base::__end_.__prev_->__as_node()->__value_;
     }
 
 #ifndef _LIBCPP_CXX03_LANG
     void push_front(value_type&& __x);
     void push_back(value_type&& __x);
 
     template <class... _Args>
 #if _LIBCPP_STD_VER > 14
#endif  // _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     void swap(list& __c)
 #if _LIBCPP_STD_VER >= 14
         _NOEXCEPT_DEBUG
 #else
         _NOEXCEPT_DEBUG_(!__node_alloc_traits::propagate_on_container_swap::value ||
                    __is_nothrow_swappable<__node_allocator>::value)
 #endif
-        {base::swap(__c);}
+        {__base::swap(__c);}
     _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT {base::clear();}
+    void clear() _NOEXCEPT {__base::clear();}
 
     void pop_front();
     void pop_back();
 
     iterator erase(const_iterator __p);
     iterator erase(const_iterator __f, const_iterator __l);
 
     void resize(size_type __n);

 }
 
 // Link in nodes [__f, __l] at the front of the list
 template <class _Tp, class _Alloc>
 inline
 void
 list<_Tp, _Alloc>::__link_nodes_at_front(__link_pointer __f, __link_pointer __l)
 {
-    __f->__prev_ = base::__end_as_link();
-    __l->__next_ = base::__end_.__next_;
+    __f->__prev_ = __base::__end_as_link();
+    __l->__next_ = __base::__end_.__next_;
     __l->__next_->__prev_ = __l;
-    base::__end_.__next_ = __f;
+    __base::__end_.__next_ = __f;
 }
 
 // Link in nodes [__f, __l] at the front of the list
 template <class _Tp, class _Alloc>
 inline
 void
 list<_Tp, _Alloc>::__link_nodes_at_back(__link_pointer __f, __link_pointer __l)
 {
-    __l->__next_ = base::__end_as_link();
-    __f->__prev_ = base::__end_.__prev_;
+    __l->__next_ = __base::__end_as_link();
+    __f->__prev_ = __base::__end_.__prev_;
     __f->__prev_->__next_ = __f;
-    base::__end_.__prev_ = __l;
+    __base::__end_.__prev_ = __l;
 }
 
 
 template <class _Tp, class _Alloc>
 inline
 typename list<_Tp, _Alloc>::iterator
 list<_Tp, _Alloc>::__iterator(size_type __n)
 {
-    return __n <= base::__sz() / 2 ? _VSTD::next(begin(), __n)
-                                   : _VSTD::prev(end(), base::__sz() - __n);
+    return __n <= __base::__sz() / 2 ? _VSTD::next(begin(), __n)
+                                     : _VSTD::prev(end(), __base::__sz() - __n);
 }
 
 template <class _Tp, class _Alloc>
 list<_Tp, _Alloc>::list(size_type __n)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
     for (; __n > 0; --__n)
 #ifndef _LIBCPP_CXX03_LANG
         emplace_back();
 #else
         push_back(value_type());
 #endif
 }
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp, class _Alloc>
-list<_Tp, _Alloc>::list(size_type __n, const allocator_type& __a) : base(__a)
+list<_Tp, _Alloc>::list(size_type __n, const allocator_type& __a) : __base(__a)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
     for (; __n > 0; --__n)
         emplace_back();
 }
 #endif
 
 template <class _Tp, class _Alloc>
 list<_Tp, _Alloc>::list(size_type __n, const value_type& __x)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
     for (; __n > 0; --__n)
         push_back(__x);
 }
 
 template <class _Tp, class _Alloc>
 list<_Tp, _Alloc>::list(size_type __n, const value_type& __x, const allocator_type& __a)
-    : base(__a)
+    : __base(__a)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
     for (; __n > 0; --__n)
         push_back(__x);
 }
 
 template <class _Tp, class _Alloc>
 template <class _InpIter>
 list<_Tp, _Alloc>::list(_InpIter __f, _InpIter __l,
                         typename enable_if<__is_input_iterator<_InpIter>::value>::type*)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
     for (; __f != __l; ++__f)
         push_back(*__f);
 }
 
 template <class _Tp, class _Alloc>
 template <class _InpIter>
 list<_Tp, _Alloc>::list(_InpIter __f, _InpIter __l, const allocator_type& __a,
                         typename enable_if<__is_input_iterator<_InpIter>::value>::type*)
-    : base(__a)
+    : __base(__a)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
     for (; __f != __l; ++__f)
         push_back(*__f);
 }
 
 template <class _Tp, class _Alloc>
 list<_Tp, _Alloc>::list(const list& __c)
-    : base(allocator_type(
+    : __base(allocator_type(
              __node_alloc_traits::select_on_container_copy_construction(
                   __c.__node_alloc())))
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
     for (const_iterator __i = __c.begin(), __e = __c.end(); __i != __e; ++__i)
         push_back(*__i);
 }
 
 template <class _Tp, class _Alloc>
 list<_Tp, _Alloc>::list(const list& __c, const allocator_type& __a)
-    : base(__a)
+    : __base(__a)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
     for (const_iterator __i = __c.begin(), __e = __c.end(); __i != __e; ++__i)
         push_back(*__i);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Alloc>
 list<_Tp, _Alloc>::list(initializer_list<value_type> __il, const allocator_type& __a)
-    : base(__a)
+    : __base(__a)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
     for (typename initializer_list<value_type>::const_iterator __i = __il.begin(),
             __e = __il.end(); __i != __e; ++__i)
         push_back(*__i);
 }
 
 template <class _Tp, class _Alloc>
 list<_Tp, _Alloc>::list(initializer_list<value_type> __il)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
     for (typename initializer_list<value_type>::const_iterator __i = __il.begin(),
             __e = __il.end(); __i != __e; ++__i)
         push_back(*__i);
 }
 
 template <class _Tp, class _Alloc>
 inline
 list<_Tp, _Alloc>::list(list&& __c)
     _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value)
-    : base(allocator_type(_VSTD::move(__c.__node_alloc())))
+    : __base(allocator_type(_VSTD::move(__c.__node_alloc())))
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
     splice(end(), __c);
 }
 
 template <class _Tp, class _Alloc>
 inline
 list<_Tp, _Alloc>::list(list&& __c, const allocator_type& __a)
-    : base(__a)
+    : __base(__a)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
     if (__a == __c.get_allocator())
         splice(end(), __c);
     else
     {
__move_assign(__c, integral_constant<bool,
           __node_alloc_traits::propagate_on_container_move_assignment::value>());
     return *this;
 }
 
 template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::__move_assign(list& __c, false_type)
 {
-    if (base::__node_alloc() != __c.__node_alloc())
+    if (__base::__node_alloc() != __c.__node_alloc())
     {
         typedef move_iterator<iterator> _Ip;
         assign(_Ip(__c.begin()), _Ip(__c.end()));
     }
     else
         __move_assign(__c, true_type());
 }
 
 template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::__move_assign(list& __c, true_type)
         _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value)
 {
     clear();
-    base::__move_assign_alloc(__c);
+    __base::__move_assign_alloc(__c);
     splice(end(), __c);
 }
 
 #endif  // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Alloc>
 inline
 list<_Tp, _Alloc>&
 list<_Tp, _Alloc>::operator=(const list& __c)
 {
     if (this != &__c)
     {
-        base::__copy_assign_alloc(__c);
+        __base::__copy_assign_alloc(__c);
         assign(__c.begin(), __c.end());
     }
     return *this;
 }
 
 template <class _Tp, class _Alloc>
 template <class _InpIter>
 void

 #endif
 }
 
 template <class _Tp, class _Alloc>
 inline
 _Alloc
 list<_Tp, _Alloc>::get_allocator() const _NOEXCEPT
 {
-    return allocator_type(base::__node_alloc());
+    return allocator_type(__base::__node_alloc());
 }
 
 template <class _Tp, class _Alloc>
 typename list<_Tp, _Alloc>::iterator
 list<_Tp, _Alloc>::insert(const_iterator __p, const value_type& __x)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
         "list::insert(iterator, x) called with an iterator not"
         " referring to this list");
 #endif
-    __node_allocator& __na = base::__node_alloc();
+    __node_allocator& __na = __base::__node_alloc();
     typedef __allocator_destructor<__node_allocator> _Dp;
     unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
     __hold->__prev_ = 0;
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
     __link_nodes(__p.__ptr_, __hold->__as_link(), __hold->__as_link());
-    ++base::__sz();
+    ++__base::__sz();
 #if _LIBCPP_DEBUG_LEVEL >= 2
     return iterator(__hold.release()->__as_link(), this);
 #else
     return iterator(__hold.release()->__as_link());
 #endif
 }
 
 template <class _Tp, class _Alloc>
 typename list<_Tp, _Alloc>::iterator
 list<_Tp, _Alloc>::insert(const_iterator __p, size_type __n, const value_type& __x)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
         "list::insert(iterator, n, x) called with an iterator not"
         " referring to this list");
     iterator __r(__p.__ptr_, this);
 #else
     iterator __r(__p.__ptr_);
 #endif
     if (__n > 0)
     {
         size_type __ds = 0;
-        __node_allocator& __na = base::__node_alloc();
+        __node_allocator& __na = __base::__node_alloc();
         typedef __allocator_destructor<__node_allocator> _Dp;
         unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
         __hold->__prev_ = 0;
         __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
         ++__ds;
 #if _LIBCPP_DEBUG_LEVEL >= 2
         __r = iterator(__hold->__as_link(), this);
 #else

 #else
                 __e = iterator(__prev);
 #endif
             }
             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
         __link_nodes(__p.__ptr_, __r.__ptr_, __e.__ptr_);
-        base::__sz() += __ds;
+        __base::__sz() += __ds;
     }
     return __r;
 }
 
 template <class _Tp, class _Alloc>
 template <class _InpIter>
 typename list<_Tp, _Alloc>::iterator
 list<_Tp, _Alloc>::insert(const_iterator __p, _InpIter __f, _InpIter __l,
              typename enable_if<__is_input_iterator<_InpIter>::value>::type*)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
         "list::insert(iterator, range) called with an iterator not"
         " referring to this list");
     iterator __r(__p.__ptr_, this);
 #else
     iterator __r(__p.__ptr_);
 #endif
     if (__f != __l)
     {
         size_type __ds = 0;
-        __node_allocator& __na = base::__node_alloc();
+        __node_allocator& __na = __base::__node_alloc();
         typedef __allocator_destructor<__node_allocator> _Dp;
         unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
         __hold->__prev_ = 0;
         __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), *__f);
         ++__ds;
 #if _LIBCPP_DEBUG_LEVEL >= 2
         __r = iterator(__hold.get()->__as_link(), this);
 #else

 #else
                 __e = iterator(__prev);
 #endif
             }
             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
         __link_nodes(__p.__ptr_, __r.__ptr_, __e.__ptr_);
-        base::__sz() += __ds;
+        __base::__sz() += __ds;
     }
     return __r;
 }
 
 template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::push_front(const value_type& __x)
 {
-    __node_allocator& __na = base::__node_alloc();
+    __node_allocator& __na = __base::__node_alloc();
     typedef __allocator_destructor<__node_allocator> _Dp;
     unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
     __link_pointer __nl = __hold->__as_link();
     __link_nodes_at_front(__nl, __nl);
-    ++base::__sz();
+    ++__base::__sz();
     __hold.release();
 }
 
 template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::push_back(const value_type& __x)
 {
-    __node_allocator& __na = base::__node_alloc();
+    __node_allocator& __na = __base::__node_alloc();
     typedef __allocator_destructor<__node_allocator> _Dp;
     unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
     __link_nodes_at_back(__hold.get()->__as_link(), __hold.get()->__as_link());
-    ++base::__sz();
+    ++__base::__sz();
     __hold.release();
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::push_front(value_type&& __x)
 {
-    __node_allocator& __na = base::__node_alloc();
+    __node_allocator& __na = __base::__node_alloc();
     typedef __allocator_destructor<__node_allocator> _Dp;
     unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x));
     __link_nodes_at_front(__hold.get()->__as_link(), __hold.get()->__as_link());
-    ++base::__sz();
+    ++__base::__sz();
     __hold.release();
 }
 
 template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::push_back(value_type&& __x)
 {
-    __node_allocator& __na = base::__node_alloc();
+    __node_allocator& __na = __base::__node_alloc();
     typedef __allocator_destructor<__node_allocator> _Dp;
     unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x));
     __link_nodes_at_back(__hold.get()->__as_link(), __hold.get()->__as_link());
-    ++base::__sz();
+    ++__base::__sz();
     __hold.release();
 }
 
 template <class _Tp, class _Alloc>
 template <class... _Args>
 #if _LIBCPP_STD_VER > 14
 typename list<_Tp, _Alloc>::reference
 #else
 void
 #endif
 list<_Tp, _Alloc>::emplace_front(_Args&&... __args)
 {
-    __node_allocator& __na = base::__node_alloc();
+    __node_allocator& __na = __base::__node_alloc();
     typedef __allocator_destructor<__node_allocator> _Dp;
     unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...);
     __link_nodes_at_front(__hold.get()->__as_link(), __hold.get()->__as_link());
-    ++base::__sz();
+    ++__base::__sz();
 #if _LIBCPP_STD_VER > 14
     return __hold.release()->__value_;
 #else
     __hold.release();
 #endif
 }
 
 template <class _Tp, class _Alloc>
 template <class... _Args>
 #if _LIBCPP_STD_VER > 14
 typename list<_Tp, _Alloc>::reference
 #else
 void
 #endif
 list<_Tp, _Alloc>::emplace_back(_Args&&... __args)
 {
-    __node_allocator& __na = base::__node_alloc();
+    __node_allocator& __na = __base::__node_alloc();
     typedef __allocator_destructor<__node_allocator> _Dp;
     unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...);
     __link_pointer __nl = __hold->__as_link();
     __link_nodes_at_back(__nl, __nl);
-    ++base::__sz();
+    ++__base::__sz();
 #if _LIBCPP_STD_VER > 14
     return __hold.release()->__value_;
 #else
     __hold.release();
 #endif
 }
 
 template <class _Tp, class _Alloc>
 template <class... _Args>
 typename list<_Tp, _Alloc>::iterator
 list<_Tp, _Alloc>::emplace(const_iterator __p, _Args&&... __args)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
         "list::emplace(iterator, args...) called with an iterator not"
         " referring to this list");
 #endif
-    __node_allocator& __na = base::__node_alloc();
+    __node_allocator& __na = __base::__node_alloc();
     typedef __allocator_destructor<__node_allocator> _Dp;
     unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
     __hold->__prev_ = 0;
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...);
     __link_pointer __nl = __hold.get()->__as_link();
     __link_nodes(__p.__ptr_, __nl, __nl);
-    ++base::__sz();
+    ++__base::__sz();
     __hold.release();
 #if _LIBCPP_DEBUG_LEVEL >= 2
     return iterator(__nl, this);
 #else
     return iterator(__nl);
 #endif
 }
 
 template <class _Tp, class _Alloc>
 typename list<_Tp, _Alloc>::iterator
 list<_Tp, _Alloc>::insert(const_iterator __p, value_type&& __x)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
         "list::insert(iterator, x) called with an iterator not"
         " referring to this list");
 #endif
-    __node_allocator& __na = base::__node_alloc();
+    __node_allocator& __na = __base::__node_alloc();
     typedef __allocator_destructor<__node_allocator> _Dp;
     unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
     __hold->__prev_ = 0;
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x));
     __link_pointer __nl = __hold->__as_link();
     __link_nodes(__p.__ptr_, __nl, __nl);
-    ++base::__sz();
+    ++__base::__sz();
     __hold.release();
 #if _LIBCPP_DEBUG_LEVEL >= 2
     return iterator(__nl, this);
 #else
     return iterator(__nl);
 #endif
 }
 
 #endif  // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::pop_front()
 {
     _LIBCPP_ASSERT(!empty(), "list::pop_front() called with empty list");
-    __node_allocator& __na = base::__node_alloc();
-    __link_pointer __n = base::__end_.__next_;
-    base::__unlink_nodes(__n, __n);
-    --base::__sz();
+    __node_allocator& __na = __base::__node_alloc();
+    __link_pointer __n = __base::__end_.__next_;
+    __base::__unlink_nodes(__n, __n);
+    --__base::__sz();
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __c_node* __c = __get_db()->__find_c_and_lock(this);
     for (__i_node** __p = __c->end_; __p != __c->beg_; )
     {
         --__p;
         iterator* __i = static_cast<iterator*>((*__p)->__i_);
         if (__i->__ptr_ == __n)
         {
#endif
     __node_alloc_traits::deallocate(__na, __np, 1);
 }
 
 template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::pop_back()
 {
     _LIBCPP_ASSERT(!empty(), "list::pop_back() called with empty list");
-    __node_allocator& __na = base::__node_alloc();
-    __link_pointer __n = base::__end_.__prev_;
-    base::__unlink_nodes(__n, __n);
-    --base::__sz();
+    __node_allocator& __na = __base::__node_alloc();
+    __link_pointer __n = __base::__end_.__prev_;
+    __base::__unlink_nodes(__n, __n);
+    --__base::__sz();
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __c_node* __c = __get_db()->__find_c_and_lock(this);
     for (__i_node** __p = __c->end_; __p != __c->beg_; )
     {
         --__p;
         iterator* __i = static_cast<iterator*>((*__p)->__i_);
         if (__i->__ptr_ == __n)
         {

 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
         "list::erase(iterator) called with an iterator not"
         " referring to this list");
 #endif
     _LIBCPP_ASSERT(__p != end(),
         "list::erase(iterator) called with a non-dereferenceable iterator");
-    __node_allocator& __na = base::__node_alloc();
+    __node_allocator& __na = __base::__node_alloc();
     __link_pointer __n = __p.__ptr_;
     __link_pointer __r = __n->__next_;
-    base::__unlink_nodes(__n, __n);
-    --base::__sz();
+    __base::__unlink_nodes(__n, __n);
+    --__base::__sz();
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __c_node* __c = __get_db()->__find_c_and_lock(this);
     for (__i_node** __ip = __c->end_; __ip != __c->beg_; )
     {
         --__ip;
         iterator* __i = static_cast<iterator*>((*__ip)->__i_);
         if (__i->__ptr_ == __n)
         {
_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__f) == this,
         "list::erase(iterator, iterator) called with an iterator not"
         " referring to this list");
    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__l) == this,
         "list::erase(iterator, iterator) called with an iterator not"
         " referring to this list");
 #endif
     if (__f != __l)
     {
-        __node_allocator& __na = base::__node_alloc();
-        base::__unlink_nodes(__f.__ptr_, __l.__ptr_->__prev_);
+        __node_allocator& __na = __base::__node_alloc();
+        __base::__unlink_nodes(__f.__ptr_, __l.__ptr_->__prev_);
         while (__f != __l)
         {
             __link_pointer __n = __f.__ptr_;
             ++__f;
-            --base::__sz();
+            --__base::__sz();
 #if _LIBCPP_DEBUG_LEVEL >= 2
             __c_node* __c = __get_db()->__find_c_and_lock(this);
             for (__i_node** __p = __c->end_; __p != __c->beg_; )
             {
                 --__p;
                 iterator* __i = static_cast<iterator*>((*__p)->__i_);
                 if (__i->__ptr_ == __n)
                 {
#else
     return iterator(__l.__ptr_);
 #endif
 }
 
 template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::resize(size_type __n)
 {
-    if (__n < base::__sz())
+    if (__n < __base::__sz())
         erase(__iterator(__n), end());
-    else if (__n > base::__sz())
+    else if (__n > __base::__sz())
     {
-        __n -= base::__sz();
+        __n -= __base::__sz();
         size_type __ds = 0;
-        __node_allocator& __na = base::__node_alloc();
+        __node_allocator& __na = __base::__node_alloc();
         typedef __allocator_destructor<__node_allocator> _Dp;
         unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
         __hold->__prev_ = 0;
         __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_));
         ++__ds;
 #if _LIBCPP_DEBUG_LEVEL >= 2
         iterator __r = iterator(__hold.release()->__as_link(), this);
 #else

 #else
                 __e = iterator(__prev);
 #endif
             }
             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
         __link_nodes_at_back(__r.__ptr_, __e.__ptr_);
-        base::__sz() += __ds;
+        __base::__sz() += __ds;
     }
 }
 
 template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::resize(size_type __n, const value_type& __x)
 {
-    if (__n < base::__sz())
+    if (__n < __base::__sz())
         erase(__iterator(__n), end());
-    else if (__n > base::__sz())
+    else if (__n > __base::__sz())
     {
-        __n -= base::__sz();
+        __n -= __base::__sz();
         size_type __ds = 0;
-        __node_allocator& __na = base::__node_alloc();
+        __node_allocator& __na = __base::__node_alloc();
         typedef __allocator_destructor<__node_allocator> _Dp;
         unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
         __hold->__prev_ = 0;
         __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
         ++__ds;
         __link_pointer __nl = __hold.release()->__as_link();
 #if _LIBCPP_DEBUG_LEVEL >= 2
         iterator __r = iterator(__nl, this);
#if _LIBCPP_DEBUG_LEVEL >= 2
                 __e = iterator(__prev, this);
 #else
                 __e = iterator(__prev);
 #endif
             }
             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
-        __link_nodes(base::__end_as_link(), __r.__ptr_, __e.__ptr_);
-        base::__sz() += __ds;
+        __link_nodes(__base::__end_as_link(), __r.__ptr_, __e.__ptr_);
+        __base::__sz() += __ds;
     }
 }
 
 template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::splice(const_iterator __p, list& __c)
 {
     _LIBCPP_ASSERT(this != &__c,
                    "list::splice(iterator, list) called with this == &list");
 #if _LIBCPP_DEBUG_LEVEL >= 2
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
         "list::splice(iterator, list) called with an iterator not"
         " referring to this list");
 #endif
     if (!__c.empty())
     {
         __link_pointer __f = __c.__end_.__next_;
         __link_pointer __l = __c.__end_.__prev_;
-        base::__unlink_nodes(__f, __l);
+        __base::__unlink_nodes(__f, __l);
         __link_nodes(__p.__ptr_, __f, __l);
-        base::__sz() += __c.__sz();
+        __base::__sz() += __c.__sz();
         __c.__sz() = 0;
 #if _LIBCPP_DEBUG_LEVEL >= 2
         __libcpp_db* __db = __get_db();
         __c_node* __cn1 = __db->__find_c_and_lock(this);
         __c_node* __cn2 = __db->__find_c(&__c);
         for (__i_node** __ip = __cn2->end_; __ip != __cn2->beg_;)
         {
             --__ip;
_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__i) == &__c,
         " referring to list argument");
     _LIBCPP_ASSERT(__get_const_db()->__dereferenceable(&__i),
         "list::splice(iterator, list, iterator) called with second iterator not"
         " derefereceable");
 #endif
     if (__p.__ptr_ != __i.__ptr_ && __p.__ptr_ != __i.__ptr_->__next_)
     {
         __link_pointer __f = __i.__ptr_;
-        base::__unlink_nodes(__f, __f);
+        __base::__unlink_nodes(__f, __f);
         __link_nodes(__p.__ptr_, __f, __f);
         --__c.__sz();
-        ++base::__sz();
+        ++__base::__sz();
 #if _LIBCPP_DEBUG_LEVEL >= 2
         __libcpp_db* __db = __get_db();
         __c_node* __cn1 = __db->__find_c_and_lock(this);
         __c_node* __cn2 = __db->__find_c(&__c);
         for (__i_node** __ip = __cn2->end_; __ip != __cn2->beg_;)
         {
             --__ip;
             iterator* __j = static_cast<iterator*>((*__ip)->__i_);
#if _LIBCPP_DEBUG_LEVEL >= 2
     }
 #endif
     if (__f != __l)
     {
         if (this != &__c)
         {
             size_type __s = _VSTD::distance(__f, __l);
             __c.__sz() -= __s;
-            base::__sz() += __s;
+            __base::__sz() += __s;
         }
         __link_pointer __first = __f.__ptr_;
         --__l;
         __link_pointer __last = __l.__ptr_;
-        base::__unlink_nodes(__first, __last);
+        __base::__unlink_nodes(__first, __last);
         __link_nodes(__p.__ptr_, __first, __last);
 #if _LIBCPP_DEBUG_LEVEL >= 2
         __libcpp_db* __db = __get_db();
         __c_node* __cn1 = __db->__find_c_and_lock(this);
         __c_node* __cn2 = __db->__find_c(&__c);
         for (__i_node** __ip = __cn2->end_; __ip != __cn2->beg_;)
         {
             --__ip;
if (this != &__c)
         while (__f1 != __e1 && __f2 != __e2)
         {
             if (__comp(*__f2, *__f1))
             {
                 size_type __ds = 1;
                 iterator __m2 = _VSTD::next(__f2);
                 for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2, ++__ds)
                     ;
-                base::__sz() += __ds;
+                __base::__sz() += __ds;
                 __c.__sz() -= __ds;
                 __link_pointer __f = __f2.__ptr_;
                 __link_pointer __l = __m2.__ptr_->__prev_;
                 __f2 = __m2;
-                base::__unlink_nodes(__f, __l);
+                __base::__unlink_nodes(__f, __l);
                 __m2 = _VSTD::next(__f1);
                 __link_nodes(__f1.__ptr_, __f, __l);
                 __f1 = __m2;
             }
             else
                 ++__f1;
         }
         splice(__e1, __c);

 }
 
 template <class _Tp, class _Alloc>
 template <class _Comp>
 inline
 void
 list<_Tp, _Alloc>::sort(_Comp __comp)
 {
-    __sort(begin(), end(), base::__sz(), __comp);
+    __sort(begin(), end(), __base::__sz(), __comp);
 }
 
 template <class _Tp, class _Alloc>
 template <class _Comp>
 typename list<_Tp, _Alloc>::iterator
 list<_Tp, _Alloc>::__sort(iterator __f1, iterator __e2, size_type __n, _Comp& __comp)
 {
     switch (__n)
     {
     case 0:
     case 1:
         return __f1;
     case 2:
         if (__comp(*--__e2, *__f1))
         {
             __link_pointer __f = __e2.__ptr_;
-            base::__unlink_nodes(__f, __f);
+            __base::__unlink_nodes(__f, __f);
             __link_nodes(__f1.__ptr_, __f, __f);
             return __e2;
         }
         return __f1;
     }
     size_type __n2 = __n / 2;
     iterator __e1 = _VSTD::next(__f1, __n2);
     iterator  __r = __f1 = __sort(__f1, __e1, __n2, __comp);
     iterator __f2 = __e1 = __sort(__e1, __e2, __n - __n2, __comp);
     if (__comp(*__f2, *__f1))
     {
         iterator __m2 = _VSTD::next(__f2);
         for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2)
             ;
         __link_pointer __f = __f2.__ptr_;
         __link_pointer __l = __m2.__ptr_->__prev_;
         __r = __f2;
         __e1 = __f2 = __m2;
-        base::__unlink_nodes(__f, __l);
+        __base::__unlink_nodes(__f, __l);
         __m2 = _VSTD::next(__f1);
         __link_nodes(__f1.__ptr_, __f, __l);
         __f1 = __m2;
     }
     else
         ++__f1;
     while (__f1 != __e1 && __f2 != __e2)
     {
         if (__comp(*__f2, *__f1))
         {
             iterator __m2 = _VSTD::next(__f2);
             for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2)
                 ;
             __link_pointer __f = __f2.__ptr_;
             __link_pointer __l = __m2.__ptr_->__prev_;
             if (__e1 == __f2)
                 __e1 = __m2;
             __f2 = __m2;
-            base::__unlink_nodes(__f, __l);
+            __base::__unlink_nodes(__f, __l);
             __m2 = _VSTD::next(__f1);
             __link_nodes(__f1.__ptr_, __f, __l);
             __f1 = __m2;
         }
         else
             ++__f1;
     }
     return __r;
 }
 
 template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::reverse() _NOEXCEPT
 {
-    if (base::__sz() > 1)
+    if (__base::__sz() > 1)
     {
         iterator __e = end();
         for (iterator __i = begin(); __i.__ptr_ != __e.__ptr_;)
         {
             _VSTD::swap(__i.__ptr_->__prev_, __i.__ptr_->__next_);
             __i.__ptr_ = __i.__ptr_->__prev_;
         }
         _VSTD::swap(__e.__ptr_->__prev_, __e.__ptr_->__next_);

 {
     return __i->__ptr_ != this->__end_as_link();
 }
 
 template <class _Tp, class _Alloc>
 bool
 list<_Tp, _Alloc>::__decrementable(const const_iterator* __i) const
 {
-    return !empty() &&  __i->__ptr_ != base::__end_.__next_;
+    return !empty() &&  __i->__ptr_ != __base::__end_.__next_;
 }
 
 template <class _Tp, class _Alloc>
 bool
 list<_Tp, _Alloc>::__addable(const const_iterator*, ptrdiff_t) const
 {
     return false;
 }