[libc++] Change vector<bool>::const_iterator::reference to bool in ABIv2

[philnik]

Summary

vector<bool>::const_reference and vector<bool>::const_iterator::reference should be the same type.

[philnik]

• Try to fix CI

[Mordante]

I see _LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL isn't mentioned in the release notes, can you add an entry?

LGTM modulo some small nits.

libcxx/test/std/containers/sequences/vector.bool/iterators.pass.cpp

35

Interestingly the test libcxx/test/std/containers/sequences/vector.bool/types.pass.cpp isn't affected.

It would be nice when you can add the const_reference to the synopsis and add tests for pointer, const_pointer, and const_reference.

[philnik]

• Address comments

libcxx/test/std/containers/sequences/vector.bool/iterators.pass.cpp

35

I don't think there is anything portable to test for pointer and const_pointer.

[Mordante]

LGTM with one suggestion.

libcxx/test/std/containers/sequences/vector.bool/types.pass.cpp

27

For consistency I would use a typedef here.

[miyuki]

libcxx/include/__bit_reference

1115

Hi. This line causes breakages when compiling with -std=c++03:

/include/libcxx/__bit_reference:1115:79: error: a space is required between consecutive right angle brackets (use '> >')
    using reference = typename conditional<_IsConst, bool, __bit_reference<_Cp>>::type;

                                                                                 ^

Could you please fix this?

[philnik]

libcxx/include/__bit_reference

1115

Fixed it in 6b257a. Just out of interest, why do you use the unstable ABI in C++03? It's clearly not for ABI reasons. Also as a side note: I don't think we officially support using the unstable ABI pre-C++11, so you should probably not use that combination. But the fix is simple enough.

[miyuki]

libcxx/include/__bit_reference

1115

Because we are an embedded toolchain vendor and ABI stability is less of a concern for us, so we use a custom subset of unstable ABI features (and _LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL improves results of conformance tests). We do claim C++03 support, though.

Also as a side note: I don't think we officially support using the unstable ABI pre-C++11

I was not aware of this; thanks for pointing it out.

[miyuki]

libcxx/include/__bit_reference

1115

But the fix is simple enough.

Thanks.

libcxx/docs/ReleaseNotes.rst

 
 - The C++14 function ``std::quoted(const char*)`` is no longer supported in
   C++03 or C++11 modes.
 
 - Setting a custom debug handler with ``std::__libcpp_debug_function`` is not
   supported anymore. Please migrate to using the new support for
   :ref:`assertions <assertions-mode>` instead.
 
+- ``vector<bool>::const_reference``, ``vector<bool>::const_iterator::reference``
+  and ``bitset::const_reference`` are now aliases for `bool` in the unstable ABI.
+
 ABI Changes
 -----------
 
 - The ``_LIBCPP_ABI_USE_CXX03_NULLPTR_EMULATION`` macro controlling whether we use an
   emulation for ``std::nullptr_t`` in C++03 mode has been removed. After this change,
   ``_LIBCPP_ABI_USE_CXX03_NULLPTR_EMULATION`` will not be honoured anymore and there
   will be no way to opt back into the C++03 emulation of ``std::nullptr_t``.
 

libcxx/include/__bit_reference

 template <class _Cp, bool _IsConst,
           typename _Cp::__storage_type>
 class __bit_iterator
 {
 public:
     typedef typename _Cp::difference_type                                                          difference_type;
     typedef bool                                                                                  value_type;
     typedef __bit_iterator                                                                        pointer;
+#ifndef _LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL
     typedef typename conditional<_IsConst, __bit_const_reference<_Cp>, __bit_reference<_Cp> >::type reference;
+#else
+    using reference = typename conditional<_IsConst, bool, __bit_reference<_Cp>>::type;
+#endif
     typedef random_access_iterator_tag                                                            iterator_category;
 
 private:
     typedef typename _Cp::__storage_type                                           __storage_type;
     typedef typename conditional<_IsConst, typename _Cp::__const_storage_pointer,
                                            typename _Cp::__storage_pointer>::type  __storage_pointer;
     static const unsigned __bits_per_word = _Cp::__bits_per_word;
 
#endif
     // implicitly generated and trivial.
     _LIBCPP_INLINE_VISIBILITY
     __bit_iterator& operator=(const _If<_IsConst, struct __private_nat, __bit_iterator>& __it) {
         __seg_ = __it.__seg_;
         __ctz_ = __it.__ctz_;
         return *this;
     }
 
-    _LIBCPP_INLINE_VISIBILITY reference operator*() const _NOEXCEPT
-        {return reference(__seg_, __storage_type(1) << __ctz_);}
+    _LIBCPP_INLINE_VISIBILITY reference operator*() const _NOEXCEPT {
+        return typename conditional<_IsConst, __bit_const_reference<_Cp>, __bit_reference<_Cp> >
+                ::type(__seg_, __storage_type(1) << __ctz_);
+    }
 
     _LIBCPP_INLINE_VISIBILITY __bit_iterator& operator++()
     {
         if (__ctz_ != __bits_per_word-1)
             ++__ctz_;
         else
         {
             __ctz_ = 0;

libcxx/test/std/containers/sequences/vector.bool/iterators.pass.cpp

 #include <cassert>
 #include <iterator>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
+    using IterRefT = std::iterator_traits<std::vector<bool>::iterator>::reference;
+    ASSERT_SAME_TYPE(IterRefT, std::vector<bool>::reference);
+
+    using ConstIterRefT = std::iterator_traits<std::vector<bool>::const_iterator>::reference;
+#if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL)
+    ASSERT_SAME_TYPE(ConstIterRefT, bool);
+#else
+    ASSERT_SAME_TYPE(ConstIterRefT, std::__bit_const_reference<std::vector<bool> >);
+#endif
     {
         typedef bool T;
         typedef std::vector<T> C;
         C c;
         C::iterator i = c.begin();
         C::iterator j = c.end();
         assert(std::distance(i, j) == 0);
         assert(i == j);

libcxx/test/std/containers/sequences/vector.bool/types.pass.cpp

 //     typedef implementation-defined                   iterator;
 //     typedef implementation-defined                   const_iterator;
 //     typedef typename allocator_type::size_type       size_type;
 //     typedef typename allocator_type::difference_type difference_type;
 //     typedef typename allocator_type::pointer         pointer;
 //     typedef typename allocator_type::const_pointer   const_pointer;
 //     typedef std::reverse_iterator<iterator>          reverse_iterator;
 //     typedef std::reverse_iterator<const_iterator>    const_reverse_iterator;
+//     typedef bool                                     const_reference;
 // };
 
 #include <vector>
 #include <iterator>
 #include <type_traits>
 
 #include "test_macros.h"
 #include "test_allocator.h"
static_assert((std::is_same<
         typename std::iterator_traits<typename C::const_iterator>::iterator_category,
         std::random_access_iterator_tag>::value), "");
     static_assert((std::is_same<
         typename C::reverse_iterator,
         std::reverse_iterator<typename C::iterator> >::value), "");
     static_assert((std::is_same<
         typename C::const_reverse_iterator,
         std::reverse_iterator<typename C::const_iterator> >::value), "");
+#if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL)
+    static_assert(std::is_same<typename C::const_reference, bool>::value, "");
+#endif
 }
 
 int main(int, char**)
 {
     test<test_allocator<bool> >();
     test<std::allocator<bool> >();
     static_assert((std::is_same<std::vector<bool>::allocator_type,
                                 std::allocator<bool> >::value), "");
 #if TEST_STD_VER >= 11
     test<min_allocator<bool> >();
 #endif
 
   return 0;
 }