[libc++] Use __debug_iterator instead of const_iterator to interact with the debug mode

[ldionne]

Summary

This will become useful when adding the debug mode to classes that
don't have a const_iterator, such as std::span.

[philnik]

How would it be useful? AFAICT you're not using __debug_iterator outside the class anywhere. Right now this only adds an indirection where none is needed.

[ldionne]

In D127356#3568390, @philnik wrote:

How would it be useful? AFAICT you're not using __debug_iterator outside the class anywhere. Right now this only adds an indirection where none is needed.

As I mention in the review summary, it's useful e.g. for std::span, which doesn't have const_iterator. I uploaded DD127401 to show the follow-up.

[ldionne]

Actually, upon making more progress on the successor to D127401, I'm not sure this will be relevant. Putting on the ice for now.

libcxx/include/__debug

struct _C_node
     virtual bool __addable(const void*, ptrdiff_t) const;
     virtual bool __subscriptable(const void*, ptrdiff_t) const;
 };
 
 template <class _Cont>
 inline bool
 _C_node<_Cont>::__dereferenceable(const void* __i) const
 {
-    typedef typename _Cont::const_iterator iterator;
+    typedef typename _Cont::__debug_iterator iterator;
     const iterator* __j = static_cast<const iterator*>(__i);
     _Cont* _Cp = static_cast<_Cont*>(__c_);
     return _Cp->__dereferenceable(__j);
 }
 
 template <class _Cont>
 inline bool
 _C_node<_Cont>::__decrementable(const void* __i) const
 {
-    typedef typename _Cont::const_iterator iterator;
+    typedef typename _Cont::__debug_iterator iterator;
     const iterator* __j = static_cast<const iterator*>(__i);
     _Cont* _Cp = static_cast<_Cont*>(__c_);
     return _Cp->__decrementable(__j);
 }
 
 template <class _Cont>
 inline bool
 _C_node<_Cont>::__addable(const void* __i, ptrdiff_t __n) const
 {
-    typedef typename _Cont::const_iterator iterator;
+    typedef typename _Cont::__debug_iterator iterator;
     const iterator* __j = static_cast<const iterator*>(__i);
     _Cont* _Cp = static_cast<_Cont*>(__c_);
     return _Cp->__addable(__j, __n);
 }
 
 template <class _Cont>
 inline bool
 _C_node<_Cont>::__subscriptable(const void* __i, ptrdiff_t __n) const
 {
-    typedef typename _Cont::const_iterator iterator;
+    typedef typename _Cont::__debug_iterator iterator;
     const iterator* __j = static_cast<const iterator*>(__i);
     _Cont* _Cp = static_cast<_Cont*>(__c_);
     return _Cp->__subscriptable(__j, __n);
 }
 
 class _LIBCPP_TYPE_VIS __libcpp_db
 {
     __c_node** __cbeg_;

libcxx/include/__hash_table

#endif
     {
         _LIBCPP_ASSERT(__n < bucket_count(),
             "unordered container::cend(n) called with n >= bucket_count()");
         return const_local_iterator(nullptr, __n, bucket_count(), this);
     }
 
 #ifdef _LIBCPP_ENABLE_DEBUG_MODE
 
-    bool __dereferenceable(const const_iterator* __i) const;
-    bool __decrementable(const const_iterator* __i) const;
-    bool __addable(const const_iterator* __i, ptrdiff_t __n) const;
-    bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const;
+    using __debug_iterator = const_iterator;
+    bool __dereferenceable(const __debug_iterator* __i) const;
+    bool __decrementable(const __debug_iterator* __i) const;
+    bool __addable(const __debug_iterator* __i, ptrdiff_t __n) const;
+    bool __subscriptable(const __debug_iterator* __i, ptrdiff_t __n) const;
 
 #endif // _LIBCPP_ENABLE_DEBUG_MODE
 
 private:
     void __rehash(size_type __n);
 
     template <class ..._Args>
     __node_holder __construct_node(_Args&& ...__args);

 {
     __x.swap(__y);
 }
 
 #ifdef _LIBCPP_ENABLE_DEBUG_MODE
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 bool
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__dereferenceable(const const_iterator* __i) const
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__dereferenceable(const __debug_iterator* __i) const
 {
     return __i->__node_ != nullptr;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 bool
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__decrementable(const const_iterator*) const
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__decrementable(const __debug_iterator*) const
 {
     return false;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 bool
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__addable(const const_iterator*, ptrdiff_t) const
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__addable(const __debug_iterator*, ptrdiff_t) const
 {
     return false;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 bool
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__subscriptable(const const_iterator*, ptrdiff_t) const
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__subscriptable(const __debug_iterator*, ptrdiff_t) const
 {
     return false;
 }
 
 #endif // _LIBCPP_ENABLE_DEBUG_MODE
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___HASH_TABLE

libcxx/include/list

#endif
     __hold_pointer __allocate_node(__node_allocator& __na) {
       __node_pointer __p = __node_alloc_traits::allocate(__na, 1);
       __p->__prev_ = nullptr;
       return __hold_pointer(__p, __node_destructor(__na, 1));
     }
 
 #ifdef _LIBCPP_ENABLE_DEBUG_MODE
 
-    bool __dereferenceable(const const_iterator* __i) const;
-    bool __decrementable(const const_iterator* __i) const;
-    bool __addable(const const_iterator* __i, ptrdiff_t __n) const;
-    bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const;
+    using __debug_iterator = const_iterator;
+    bool __dereferenceable(const __debug_iterator* __i) const;
+    bool __decrementable(const __debug_iterator* __i) const;
+    bool __addable(const __debug_iterator* __i, ptrdiff_t __n) const;
+    bool __subscriptable(const __debug_iterator* __i, ptrdiff_t __n) const;
 
 #endif // _LIBCPP_ENABLE_DEBUG_MODE
 
 private:
     _LIBCPP_INLINE_VISIBILITY
     static void __link_nodes  (__link_pointer __p, __link_pointer __f, __link_pointer __l);
     _LIBCPP_INLINE_VISIBILITY
     void __link_nodes_at_front(__link_pointer __f, __link_pointer __l);

 {
     return size() == _VSTD::distance(begin(), end());
 }
 
 #ifdef _LIBCPP_ENABLE_DEBUG_MODE
 
 template <class _Tp, class _Alloc>
 bool
-list<_Tp, _Alloc>::__dereferenceable(const const_iterator* __i) const
+list<_Tp, _Alloc>::__dereferenceable(const __debug_iterator* __i) const
 {
     return __i->__ptr_ != this->__end_as_link();
 }
 
 template <class _Tp, class _Alloc>
 bool
-list<_Tp, _Alloc>::__decrementable(const const_iterator* __i) const
+list<_Tp, _Alloc>::__decrementable(const __debug_iterator* __i) const
 {
     return !empty() &&  __i->__ptr_ != base::__end_.__next_;
 }
 
 template <class _Tp, class _Alloc>
 bool
-list<_Tp, _Alloc>::__addable(const const_iterator*, ptrdiff_t) const
+list<_Tp, _Alloc>::__addable(const __debug_iterator*, ptrdiff_t) const
 {
     return false;
 }
 
 template <class _Tp, class _Alloc>
 bool
-list<_Tp, _Alloc>::__subscriptable(const const_iterator*, ptrdiff_t) const
+list<_Tp, _Alloc>::__subscriptable(const __debug_iterator*, ptrdiff_t) const
 {
     return false;
 }
 
 #endif // _LIBCPP_ENABLE_DEBUG_MODE
 
 template <class _Tp, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY

libcxx/include/string

 #endif
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 bool __invariants() const;
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 void __clear_and_shrink() _NOEXCEPT;
 
 #ifdef _LIBCPP_ENABLE_DEBUG_MODE
 
-    bool __dereferenceable(const const_iterator* __i) const;
-    bool __decrementable(const const_iterator* __i) const;
-    bool __addable(const const_iterator* __i, ptrdiff_t __n) const;
-    bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const;
+    using __debug_iterator = const_iterator;
+    bool __dereferenceable(const __debug_iterator* __i) const;
+    bool __decrementable(const __debug_iterator* __i) const;
+    bool __addable(const __debug_iterator* __i, ptrdiff_t __n) const;
+    bool __subscriptable(const __debug_iterator* __i, ptrdiff_t __n) const;
 
 #endif // _LIBCPP_ENABLE_DEBUG_MODE
 
 private:
     template<class _Alloc>
     inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
     bool friend operator==(const basic_string<char, char_traits<char>, _Alloc>& __lhs,
                            const basic_string<char, char_traits<char>, _Alloc>& __rhs) _NOEXCEPT;
inline _LIBCPP_HIDE_FROM_ABI
   return __old_size - __str.size();
 }
 #endif
 
 #ifdef _LIBCPP_ENABLE_DEBUG_MODE
 
 template<class _CharT, class _Traits, class _Allocator>
 bool
-basic_string<_CharT, _Traits, _Allocator>::__dereferenceable(const const_iterator* __i) const
+basic_string<_CharT, _Traits, _Allocator>::__dereferenceable(const __debug_iterator* __i) const
 {
     return data() <= std::__to_address(__i->base()) &&
            std::__to_address(__i->base()) < data() + size();
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 bool
-basic_string<_CharT, _Traits, _Allocator>::__decrementable(const const_iterator* __i) const
+basic_string<_CharT, _Traits, _Allocator>::__decrementable(const __debug_iterator* __i) const
 {
     return data() < std::__to_address(__i->base()) &&
            std::__to_address(__i->base()) <= data() + size();
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 bool
-basic_string<_CharT, _Traits, _Allocator>::__addable(const const_iterator* __i, ptrdiff_t __n) const
+basic_string<_CharT, _Traits, _Allocator>::__addable(const __debug_iterator* __i, ptrdiff_t __n) const
 {
     const value_type* __p = std::__to_address(__i->base()) + __n;
     return data() <= __p && __p <= data() + size();
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 bool
-basic_string<_CharT, _Traits, _Allocator>::__subscriptable(const const_iterator* __i, ptrdiff_t __n) const
+basic_string<_CharT, _Traits, _Allocator>::__subscriptable(const __debug_iterator* __i, ptrdiff_t __n) const
 {
     const value_type* __p = std::__to_address(__i->base()) + __n;
     return data() <= __p && __p < data() + size();
 }
 
 #endif // _LIBCPP_ENABLE_DEBUG_MODE
 
 #if _LIBCPP_STD_VER > 11

libcxx/include/unordered_map

#endif
     void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);}
     _LIBCPP_INLINE_VISIBILITY
     void rehash(size_type __n) {__table_.rehash(__n);}
     _LIBCPP_INLINE_VISIBILITY
     void reserve(size_type __n) {__table_.reserve(__n);}
 
 #ifdef _LIBCPP_ENABLE_DEBUG_MODE
 
-    bool __dereferenceable(const const_iterator* __i) const
+    using __debug_iterator = const_iterator;
+    bool __dereferenceable(const __debug_iterator* __i) const
         {return __table_.__dereferenceable(_VSTD::addressof(__i->__i_));}
-    bool __decrementable(const const_iterator* __i) const
+    bool __decrementable(const __debug_iterator* __i) const
         {return __table_.__decrementable(_VSTD::addressof(__i->__i_));}
-    bool __addable(const const_iterator* __i, ptrdiff_t __n) const
+    bool __addable(const __debug_iterator* __i, ptrdiff_t __n) const
         {return __table_.__addable(_VSTD::addressof(__i->__i_), __n);}
-    bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const
+    bool __subscriptable(const __debug_iterator* __i, ptrdiff_t __n) const
         {return __table_.__addable(_VSTD::addressof(__i->__i_), __n);}
 
 #endif // _LIBCPP_ENABLE_DEBUG_MODE
 
 private:
 
 #ifdef _LIBCPP_CXX03_LANG
     __node_holder __construct_node_with_key(const key_type& __k);

libcxx/include/unordered_set

#endif // _LIBCPP_STD_VER > 17
     void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);}
     _LIBCPP_INLINE_VISIBILITY
     void rehash(size_type __n) {__table_.rehash(__n);}
     _LIBCPP_INLINE_VISIBILITY
     void reserve(size_type __n) {__table_.reserve(__n);}
 
 #ifdef _LIBCPP_ENABLE_DEBUG_MODE
 
-    bool __dereferenceable(const const_iterator* __i) const
+    using __debug_iterator = const_iterator;
+    bool __dereferenceable(const __debug_iterator* __i) const
         {return __table_.__dereferenceable(__i);}
-    bool __decrementable(const const_iterator* __i) const
+    bool __decrementable(const __debug_iterator* __i) const
         {return __table_.__decrementable(__i);}
-    bool __addable(const const_iterator* __i, ptrdiff_t __n) const
+    bool __addable(const __debug_iterator* __i, ptrdiff_t __n) const
         {return __table_.__addable(__i, __n);}
-    bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const
+    bool __subscriptable(const __debug_iterator* __i, ptrdiff_t __n) const
         {return __table_.__addable(__i, __n);}
 
 #endif // _LIBCPP_ENABLE_DEBUG_MODE
 
 };
 
 #if _LIBCPP_STD_VER >= 17
 template<class _InputIterator,

libcxx/include/vector

#else
         _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
                     __is_nothrow_swappable<allocator_type>::value);
 #endif
 
     bool __invariants() const;
 
 #ifdef _LIBCPP_ENABLE_DEBUG_MODE
 
-    bool __dereferenceable(const const_iterator* __i) const;
-    bool __decrementable(const const_iterator* __i) const;
-    bool __addable(const const_iterator* __i, ptrdiff_t __n) const;
-    bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const;
+    using __debug_iterator = const_iterator;
+    bool __dereferenceable(const __debug_iterator* __i) const;
+    bool __decrementable(const __debug_iterator* __i) const;
+    bool __addable(const __debug_iterator* __i, ptrdiff_t __n) const;
+    bool __subscriptable(const __debug_iterator* __i, ptrdiff_t __n) const;
 
 #endif // _LIBCPP_ENABLE_DEBUG_MODE
 
 private:
     pointer __begin_ = nullptr;
     pointer __end_ = nullptr;
     __compressed_pair<pointer, allocator_type> __end_cap_ =
         __compressed_pair<pointer, allocator_type>(nullptr, __default_init_tag());