[libc++] Simplify debug iterators, and fix a couple of non-explicit constructors.

[• Quuxplusone]

Summary

This is actually three related commits in one:

commit 11d578daf3e499100b8126e9c8f574f58ebe6f2c (HEAD -> list-debug-mode)
Author: Arthur O'Dwyer <[e-mail]>
Date:   Sun Apr 18 15:15:10 2021 -0400

    [libc++] __bit_iterator's constructor needs explicit.

commit 34df8a2d303a40ef1e498f9f86d3dd1d7610d3c0
Author: Arthur O'Dwyer <[e-mail]>
Date:   Sun Apr 18 14:10:16 2021 -0400

    [libc++] __wrap_iter's constructor needs explicit; make it look like __list_iterator.

    The "regression test" is https://godbolt.org/z/7jv71vnjc , but in fact that test
    seems to be relying on a nonconformance in Clang's overload resolution algorithm:
    on Clang and ICC, `foo({0,0})` will prefer the public non-explicit constructor of
    `pair<int,int>` over the explicit constructor of `vector<int>::iterator`, but
    I think that's actually nonconforming.

commit 1adf6ac48d2e255ff59e1851fb2f33861464b107
Author: Arthur O'Dwyer <[e-mail]>
Date:   Sun Apr 18 14:02:12 2021 -0400

    [libc++] Give list::iterator the same constructor in debug and non-debug modes.
    
    Inlining will take care of the codegen; get rid of a lot of #ifs.

[• Quuxplusone]

libcxx/include/span

346–350

@mclow.lists added the debug iterators for span. Personally I'm not convinced that span really ought to count as a "container" in the debug-iterator sense, and maybe it ought to just use plain old raw pointers as its iterators; but for the purposes of this patch, I left it as-is.

I was too lazy to add a test (especially given the previous paragraph), but this PR does incidentally fix span in debug mode. Example of current brokenness: https://godbolt.org/z/hP6sa68sM

[• Quuxplusone]

Turns out that my regression test "proving" that {0,0} is not a vector::iterator actually may indicate a non-conformance in Clang's overload resolution rules — GCC and MSVC disagree with Clang. So I plan to just remove those two new tests (but not revert the addition of explicit to those constructors, since that's obviously a good idea).
Example of disagreement between GCC and Clang: https://godbolt.org/z/cedPxnzz1

[• Quuxplusone]

Remove the regression tests for the explicit constructors of __wrap_iter and __bit_iterator, because they failed on GCC, which alerted me to the possibility that they're probably relying on nonconforming behavior of the Clang compiler, and therefore they might break in the future as Clang becomes more conforming.

[EricWF]

I would need to see analysis of the cost of always passing an additional parameter to these iterators constructors before I approve this.

libcxx/include/list

297

We're now always passing another parameter to the constructor, eating a register.
We don't want to pay that cost in non-debug mode.

There was a reason this code was written in this ugly manner.

[• Quuxplusone]

libcxx/include/list

297

@EricWF: What compiler/target are you concerned about? I'm sure Clang/LLVM on x86 is smart enough to inline these inline functions — I can work on getting evidence for that — but I'm guessing you had something more obscure in mind?

[• Quuxplusone]

libcxx/include/list

297

@EricWF:
Hm, I see, in non-debug mode, clang++ -O1 isn't quite smart enough to avoid eating that register. (At -O2 and up, it is smart enough, and produces identical codegen.)
OTOH, std::vector::__make_iter has existed since 2011-or-earlier, and produces the exact same symptom: it eats one more register (at -O1 or lower, in non-debug mode) than it really needs to. I verified this by adding an ifdef that "manually inlines" all the calls to __make_iter(__p), and observing the difference in codegen.

Another idea I had was to add a std::list::__make_iter method analogous to vector's, but then make it static when not in debug mode:

#if _LIBCPP_DEBUG_LEVEL == 2
    iterator __make_iter(pointer __p) { return iterator(__p, this); }
#else
    static iterator __make_iter(pointer __p) { return iterator(__p); }
#endif

However, obviously this would give worse codegen at -O0 than we have today, because it's introducing a layer of indirection. And it still isn't quite as good at -O1 as "manually inlining" __make_iter. (I tried out a static version of vector::__make_iter and could still see some tiny diffs relative to the "manually inlined" version.)

In short: You're right, this hurts register allocation at -O1.

However, I continue to think that people who care about optimization should really be using -O2, and that we should make this PR's change to simplify the code of <list> and bring its debug iterators into line with <vector> and <string>.

Here's a playground where you can (for the next few weeks at least — until I update my P1144 branch) play around with the various possibilities I've implemented via ifdefs: https://godbolt.org/z/jWhfPGjcf

[• Quuxplusone]

libcxx/include/list

297

@EricWF ping for your thoughts? My playground is still up.

[• Quuxplusone]

Abandoning: The explicit ctors landed in D119894 and D120937; I don't care enough about the _LIBCPP_DEBUG_LEVEL == 2 changes to keep the rest of this open.

libcxx/include/__bit_reference

     _LIBCPP_INLINE_VISIBILITY friend bool operator<=(const __bit_iterator& __x, const __bit_iterator& __y)
         {return !(__y < __x);}
 
     _LIBCPP_INLINE_VISIBILITY friend bool operator>=(const __bit_iterator& __x, const __bit_iterator& __y)
         {return !(__x < __y);}
 
 private:
     _LIBCPP_INLINE_VISIBILITY
-    __bit_iterator(__storage_pointer __s, unsigned __ctz) _NOEXCEPT
+    explicit __bit_iterator(__storage_pointer __s, unsigned __ctz) _NOEXCEPT
         : __seg_(__s), __ctz_(__ctz) {}
 
     friend typename _Cp::__self;
 
     friend class __bit_reference<_Cp>;
     friend class __bit_const_reference<_Cp>;
     friend class __bit_iterator<_Cp, true>;
     template <class _Dp> friend struct __bit_array;

libcxx/include/iterator

                    "Attempted to subscript iterator outside of valid range");
 #endif
         return __i[__n];
     }
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG iterator_type base() const _NOEXCEPT {return __i;}
 
 private:
-#if _LIBCPP_DEBUG_LEVEL == 2
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter(const void* __p, iterator_type __x) : __i(__x)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG explicit __wrap_iter(iterator_type __x, const void* __c) : __i(__x)
     {
-        __get_db()->__insert_ic(this, __p);
-    }
+#if _LIBCPP_DEBUG_LEVEL == 2
+        __get_db()->__insert_ic(this, __c);
 #else
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter(iterator_type __x) _NOEXCEPT : __i(__x) {}
+        (void)__c;
 #endif
+    }
 
     template <class _Up> friend class __wrap_iter;
     template <class _CharT, class _Traits, class _Alloc> friend class basic_string;
     template <class _Tp, class _Alloc> friend class _LIBCPP_TEMPLATE_VIS vector;
     template <class _Tp, size_t> friend class _LIBCPP_TEMPLATE_VIS span;
 
     template <class _Iter1, class _Iter2>
     _LIBCPP_CONSTEXPR_IF_NODEBUG friend

libcxx/include/list

 template <class _Tp, class _VoidPtr>
 class _LIBCPP_TEMPLATE_VIS __list_iterator
 {
     typedef __list_node_pointer_traits<_Tp, _VoidPtr> _NodeTraits;
     typedef typename _NodeTraits::__link_pointer __link_pointer;
 
     __link_pointer __ptr_;
 
-#if _LIBCPP_DEBUG_LEVEL == 2
     _LIBCPP_INLINE_VISIBILITY
     explicit __list_iterator(__link_pointer __p, const void* __c) _NOEXCEPT
         : __ptr_(__p)
     {
+#if _LIBCPP_DEBUG_LEVEL == 2
         __get_db()->__insert_ic(this, __c);
-    }
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __list_iterator(__link_pointer __p) _NOEXCEPT : __ptr_(__p) {}
+        (void)__c;
 #endif
-
-
+    }
 
     template<class, class> friend class list;
     template<class, class> friend class __list_imp;
     template<class, class> friend class __list_const_iterator;
 public:
     typedef bidirectional_iterator_tag       iterator_category;
     typedef _Tp                              value_type;
     typedef value_type&                      reference;

 template <class _Tp, class _VoidPtr>
 class _LIBCPP_TEMPLATE_VIS __list_const_iterator
 {
     typedef __list_node_pointer_traits<_Tp, _VoidPtr> _NodeTraits;
     typedef typename _NodeTraits::__link_pointer __link_pointer;
 
     __link_pointer __ptr_;
 
-#if _LIBCPP_DEBUG_LEVEL == 2
     _LIBCPP_INLINE_VISIBILITY
     explicit __list_const_iterator(__link_pointer __p, const void* __c) _NOEXCEPT
         : __ptr_(__p)
     {
+#if _LIBCPP_DEBUG_LEVEL == 2
         __get_db()->__insert_ic(this, __c);
-    }
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __list_const_iterator(__link_pointer __p) _NOEXCEPT : __ptr_(__p) {}
+        (void)__c;
 #endif
+    }
 
     template<class, class> friend class list;
     template<class, class> friend class __list_imp;
 public:
     typedef bidirectional_iterator_tag       iterator_category;
     typedef _Tp                              value_type;
     typedef const value_type&                reference;
     typedef typename __rebind_pointer<_VoidPtr, const value_type>::type pointer;
#endif
     ~__list_imp();
     void clear() _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT {return __sz() == 0;}
 
     _LIBCPP_INLINE_VISIBILITY
     iterator begin() _NOEXCEPT
     {
-#if _LIBCPP_DEBUG_LEVEL == 2
         return iterator(__end_.__next_, this);
-#else
-        return iterator(__end_.__next_);
-#endif
     }
     _LIBCPP_INLINE_VISIBILITY
     const_iterator begin() const  _NOEXCEPT
     {
-#if _LIBCPP_DEBUG_LEVEL == 2
         return const_iterator(__end_.__next_, this);
-#else
-        return const_iterator(__end_.__next_);
-#endif
     }
     _LIBCPP_INLINE_VISIBILITY
     iterator end() _NOEXCEPT
     {
-#if _LIBCPP_DEBUG_LEVEL == 2
         return iterator(__end_as_link(), this);
-#else
-        return iterator(__end_as_link());
-#endif
     }
     _LIBCPP_INLINE_VISIBILITY
     const_iterator end() const _NOEXCEPT
     {
-#if _LIBCPP_DEBUG_LEVEL == 2
         return const_iterator(__end_as_link(), this);
-#else
-        return const_iterator(__end_as_link());
-#endif
     }
 
     void swap(__list_imp& __c)
 #if _LIBCPP_STD_VER >= 14
         _NOEXCEPT;
 #else
         _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
                     __is_nothrow_swappable<allocator_type>::value);
_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();
     __hold_pointer __hold = __allocate_node(__na);
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
     __link_nodes(__p.__ptr_, __hold->__as_link(), __hold->__as_link());
     ++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
+    iterator __r(__p.__ptr_, this);
     if (__n > 0)
     {
         size_type __ds = 0;
         __node_allocator& __na = base::__node_alloc();
         __hold_pointer __hold = __allocate_node(__na);
         __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
         ++__ds;
-#if _LIBCPP_DEBUG_LEVEL == 2
         __r = iterator(__hold->__as_link(), this);
-#else
-        __r = iterator(__hold->__as_link());
-#endif
         __hold.release();
         iterator __e = __r;
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             for (--__n; __n != 0; --__n, ++__e, ++__ds)
             {
#ifndef _LIBCPP_NO_EXCEPTIONS
         {
             while (true)
             {
                 __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e));
                 __link_pointer __prev = __e.__ptr_->__prev_;
                 __node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1);
                 if (__prev == 0)
                     break;
-#if _LIBCPP_DEBUG_LEVEL == 2
                 __e = iterator(__prev, this);
-#else
-                __e = iterator(__prev);
-#endif
             }
             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
         __link_nodes(__p.__ptr_, __r.__ptr_, __e.__ptr_);
         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_cpp17_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
+    iterator __r(__p.__ptr_, this);
     if (__f != __l)
     {
         size_type __ds = 0;
         __node_allocator& __na = base::__node_alloc();
         __hold_pointer __hold = __allocate_node(__na);
         __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), *__f);
         ++__ds;
-#if _LIBCPP_DEBUG_LEVEL == 2
         __r = iterator(__hold.get()->__as_link(), this);
-#else
-        __r = iterator(__hold.get()->__as_link());
-#endif
         __hold.release();
         iterator __e = __r;
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             for (++__f; __f != __l; ++__f, (void) ++__e, (void) ++__ds)
             {
#ifndef _LIBCPP_NO_EXCEPTIONS
         {
             while (true)
             {
                 __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e));
                 __link_pointer __prev = __e.__ptr_->__prev_;
                 __node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1);
                 if (__prev == 0)
                     break;
-#if _LIBCPP_DEBUG_LEVEL == 2
                 __e = iterator(__prev, this);
-#else
-                __e = iterator(__prev);
-#endif
             }
             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
         __link_nodes(__p.__ptr_, __r.__ptr_, __e.__ptr_);
         base::__sz() += __ds;
     }
     return __r;

 #endif
     __node_allocator& __na = base::__node_alloc();
     __hold_pointer __hold = __allocate_node(__na);
     __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();
     __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();
     __hold_pointer __hold = __allocate_node(__na);
     __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();
     __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()
 {
for (__i_node** __ip = __c->end_; __ip != __c->beg_; )
                 _VSTD::memmove(__ip, __ip+1, (__c->end_ - __ip)*sizeof(__i_node*));
         }
     }
     __get_db()->unlock();
 #endif
     __node_pointer __np = __n->__as_node();
     __node_alloc_traits::destroy(__na, _VSTD::addressof(__np->__value_));
     __node_alloc_traits::deallocate(__na, __np, 1);
-#if _LIBCPP_DEBUG_LEVEL == 2
     return iterator(__r, this);
-#else
-    return iterator(__r);
-#endif
 }
 
 template <class _Tp, class _Alloc>
 typename list<_Tp, _Alloc>::iterator
 list<_Tp, _Alloc>::erase(const_iterator __f, const_iterator __l)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__f) == this,
#if _LIBCPP_DEBUG_LEVEL == 2
             }
             __get_db()->unlock();
 #endif
             __node_pointer __np = __n->__as_node();
             __node_alloc_traits::destroy(__na, _VSTD::addressof(__np->__value_));
             __node_alloc_traits::deallocate(__na, __np, 1);
         }
     }
-#if _LIBCPP_DEBUG_LEVEL == 2
     return iterator(__l.__ptr_, this);
-#else
-    return iterator(__l.__ptr_);
-#endif
 }
 
 template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::resize(size_type __n)
 {
     if (__n < base::__sz())
         erase(__iterator(__n), end());
     else if (__n > base::__sz())
     {
         __n -= base::__sz();
         size_type __ds = 0;
         __node_allocator& __na = base::__node_alloc();
         __hold_pointer __hold = __allocate_node(__na);
         __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_));
         ++__ds;
-#if _LIBCPP_DEBUG_LEVEL == 2
         iterator __r = iterator(__hold.release()->__as_link(), this);
-#else
-        iterator __r = iterator(__hold.release()->__as_link());
-#endif
         iterator __e = __r;
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             for (--__n; __n != 0; --__n, ++__e, ++__ds)
             {
                 __hold.reset(__node_alloc_traits::allocate(__na, 1));
                 __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_));
                 __e.__ptr_->__next_ = __hold.get()->__as_link();
                 __hold->__prev_ = __e.__ptr_;
                 __hold.release();
             }
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
         {
             while (true)
             {
                 __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e));
                 __link_pointer __prev = __e.__ptr_->__prev_;
                 __node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1);
                 if (__prev == 0)
                     break;
-#if _LIBCPP_DEBUG_LEVEL == 2
                 __e = iterator(__prev, this);
-#else
-                __e = iterator(__prev);
-#endif
             }
             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
         __link_nodes_at_back(__r.__ptr_, __e.__ptr_);
         base::__sz() += __ds;
     }
 }
 
 template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::resize(size_type __n, const value_type& __x)
 {
     if (__n < base::__sz())
         erase(__iterator(__n), end());
     else if (__n > base::__sz())
     {
         __n -= base::__sz();
         size_type __ds = 0;
         __node_allocator& __na = base::__node_alloc();
         __hold_pointer __hold = __allocate_node(__na);
         __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);
-#else
-        iterator __r = iterator(__nl);
-#endif
         iterator __e = __r;
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             for (--__n; __n != 0; --__n, ++__e, ++__ds)
             {
                 __hold.reset(__node_alloc_traits::allocate(__na, 1));
                 __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
                 __e.__ptr_->__next_ = __hold.get()->__as_link();
                 __hold->__prev_ = __e.__ptr_;
                 __hold.release();
             }
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
         {
             while (true)
             {
                 __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e));
                 __link_pointer __prev = __e.__ptr_->__prev_;
                 __node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1);
                 if (__prev == 0)
                     break;
-#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;
     }
 }

libcxx/include/span

//  ~span() noexcept = default;
     _LIBCPP_INLINE_VISIBILITY constexpr reference back() const noexcept
     {
         _LIBCPP_ASSERT(!empty(), "span<T, N>::back() on empty span");
         return __data[size()-1];
     }
 
     _LIBCPP_INLINE_VISIBILITY constexpr pointer data()                         const noexcept { return __data; }
 
 // [span.iter], span iterator support
-    _LIBCPP_INLINE_VISIBILITY constexpr iterator                 begin() const noexcept { return iterator(data()); }
-    _LIBCPP_INLINE_VISIBILITY constexpr iterator                   end() const noexcept { return iterator(data() + size()); }
+    _LIBCPP_INLINE_VISIBILITY constexpr iterator                 begin() const noexcept { return iterator(data(), this); }
+    _LIBCPP_INLINE_VISIBILITY constexpr iterator                   end() const noexcept { return iterator(data() + size(), this); }
     _LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator        rbegin() const noexcept { return reverse_iterator(end()); }
     _LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator          rend() const noexcept { return reverse_iterator(begin()); }
 
     _LIBCPP_INLINE_VISIBILITY span<const byte, _Extent * sizeof(element_type)> __as_bytes() const noexcept
     { return span<const byte, _Extent * sizeof(element_type)>{reinterpret_cast<const byte *>(data()), size_bytes()}; }
 
     _LIBCPP_INLINE_VISIBILITY span<byte, _Extent * sizeof(element_type)> __as_writable_bytes() const noexcept
     { return span<byte, _Extent * sizeof(element_type)>{reinterpret_cast<byte *>(data()), size_bytes()}; }
 
 private:
     pointer    __data;
-
 };
 
 
 template <typename _Tp>
 class _LIBCPP_TEMPLATE_VIS span<_Tp, dynamic_extent> {
 private:
 
 public:
_LIBCPP_INLINE_VISIBILITY constexpr reference back() const noexcept
         _LIBCPP_ASSERT(!empty(), "span<T>[].back() on empty span");
         return __data[size()-1];
     }
 
 
     _LIBCPP_INLINE_VISIBILITY constexpr pointer data()                         const noexcept { return __data; }
 
 // [span.iter], span iterator support
-    _LIBCPP_INLINE_VISIBILITY constexpr iterator                 begin() const noexcept { return iterator(data()); }
-    _LIBCPP_INLINE_VISIBILITY constexpr iterator                   end() const noexcept { return iterator(data() + size()); }
+    _LIBCPP_INLINE_VISIBILITY constexpr iterator                 begin() const noexcept { return iterator(data(), this); }
+    _LIBCPP_INLINE_VISIBILITY constexpr iterator                   end() const noexcept { return iterator(data() + size(), this); }
     _LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator        rbegin() const noexcept { return reverse_iterator(end()); }
     _LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator          rend() const noexcept { return reverse_iterator(begin()); }
 
     _LIBCPP_INLINE_VISIBILITY span<const byte, dynamic_extent> __as_bytes() const noexcept
     { return {reinterpret_cast<const byte *>(data()), size_bytes()}; }
 
     _LIBCPP_INLINE_VISIBILITY span<byte, dynamic_extent> __as_writable_bytes() const noexcept
     { return {reinterpret_cast<byte *>(data()), size_bytes()}; }

libcxx/include/string

#ifndef _LIBCPP_CXX03_LANG
     basic_string& operator=(basic_string&& __str)
         _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value));
      _LIBCPP_INLINE_VISIBILITY
     basic_string& operator=(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
 #endif
     _LIBCPP_INLINE_VISIBILITY basic_string& operator=(const value_type* __s) {return assign(__s);}
     basic_string& operator=(value_type __c);
 
-#if _LIBCPP_DEBUG_LEVEL == 2
-    _LIBCPP_INLINE_VISIBILITY
-    iterator begin() _NOEXCEPT
-        {return iterator(this, __get_pointer());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin() const _NOEXCEPT
-        {return const_iterator(this, __get_pointer());}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator end() _NOEXCEPT
-        {return iterator(this, __get_pointer() + size());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end() const _NOEXCEPT
-        {return const_iterator(this, __get_pointer() + size());}
-#else
     _LIBCPP_INLINE_VISIBILITY
     iterator begin() _NOEXCEPT
-        {return iterator(__get_pointer());}
+        {return iterator(__get_pointer(), this);}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator begin() const _NOEXCEPT
-        {return const_iterator(__get_pointer());}
+        {return const_iterator(__get_pointer(), this);}
     _LIBCPP_INLINE_VISIBILITY
     iterator end() _NOEXCEPT
-        {return iterator(__get_pointer() + size());}
+        {return iterator(__get_pointer() + size(), this);}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator end() const _NOEXCEPT
-        {return const_iterator(__get_pointer() + size());}
-#endif  // _LIBCPP_DEBUG_LEVEL == 2
+        {return const_iterator(__get_pointer() + size(), this);}
     _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

 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->__invalidate_all(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 void
-basic_string<_CharT, _Traits, _Allocator>::__invalidate_iterators_past(size_type
-#if _LIBCPP_DEBUG_LEVEL == 2
-                                                                        __pos
-#endif
-                                                                      )
+basic_string<_CharT, _Traits, _Allocator>::__invalidate_iterators_past(size_type __pos)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     __c_node* __c = __get_db()->__find_c_and_lock(this);
     if (__c)
     {
         const_pointer __new_last = __get_pointer() + __pos;
         for (__i_node** __p = __c->end_; __p != __c->beg_; )
         {
             --__p;
             const_iterator* __i = static_cast<const_iterator*>((*__p)->__i_);
             if (__i->base() > __new_last)
             {
                 (*__p)->__c_ = nullptr;
                 if (--__c->end_ != __p)
                     _VSTD::memmove(__p, __p+1, (__c->end_ - __p)*sizeof(__i_node*));
             }
         }
         __get_db()->unlock();
     }
+#else
+    (void)__pos;
 #endif  // _LIBCPP_DEBUG_LEVEL == 2
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline
 basic_string<_CharT, _Traits, _Allocator>::basic_string()
     _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
      : __r_(__default_init_tag(), __default_init_tag())

libcxx/include/vector

     __invalidate_all_iterators();
 }
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 typename vector<_Tp, _Allocator>::iterator
 vector<_Tp, _Allocator>::__make_iter(pointer __p) _NOEXCEPT
 {
-#if _LIBCPP_DEBUG_LEVEL == 2
-    return iterator(this, __p);
-#else
-    return iterator(__p);
-#endif
+    return iterator(__p, this);
 }
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 typename vector<_Tp, _Allocator>::const_iterator
 vector<_Tp, _Allocator>::__make_iter(const_pointer __p) const _NOEXCEPT
 {
-#if _LIBCPP_DEBUG_LEVEL == 2
-    return const_iterator(this, __p);
-#else
-    return const_iterator(__p);
-#endif
+    return const_iterator(__p, this);
 }
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 typename vector<_Tp, _Allocator>::iterator
 vector<_Tp, _Allocator>::begin() _NOEXCEPT
 {
     return __make_iter(this->__begin_);

libcxx/test/libcxx/containers/sequences/vector/explicit_iterator_cons.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <vector>
+
+// Test that vector::iterator's constructor is not inconveniently implicit.
+
+#include <vector>
+#include <utility>
+
+#include "test_macros.h"
+
+int foo(std::pair<int, int>);
+void foo(std::vector<int>::iterator);
+void foo(std::vector<int>::const_iterator);
+void foo(std::vector<bool>::iterator);
+void foo(std::vector<bool>::const_iterator);
+
+int i = foo({0,0});  // should not be ambiguous

libcxx/test/libcxx/strings/basic.string/string.iterators/explicit_iterator_cons.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <string>
+
+// Test that string::iterator's constructor is not inconveniently implicit.
+
+#include <string>
+#include <utility>
+
+#include "test_macros.h"
+
+int foo(std::pair<int, int>);
+void foo(std::string::iterator);
+void foo(std::string::const_iterator);
+
+int i = foo({0,0});  // should not be ambiguous