Fix vector<bool>::const_reference to be 'bool'.

[EricWF]

Summary

Our vector<bool>::const_reference is non-conforming because the standard requires it to be `bool` but we define it as a bit wrapper type.

This patch changes the const_reference typedef guarded under the ABI flag _LIBCPP_ABI_VECTOR_BOOL_CORRECT_CONST_REFERENCE_TYPE.

[mclow.lists]

Other than those nits, this looks fine to me.

include/__config

68

Is this testing detritus?

test/std/containers/sequences/vector.bool/insert_iter_size_value.pass.cpp

70

You should also assert(v2.size() == 3) and that v[0] == cv[0]

[mclow.lists]

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

63–64

ASSERT_SAME_TYPE

[EricWF]

• Convert the tests to ASSERT_SAME_TYPE

include/vector

2418

This is a drive-by fix because we never actually defined this function and because the const value_type& overload is sufficient in all cases.

[mclow.lists]

See https://stackoverflow.com/questions/31974237/why-is-libcs-vectorboolconst-reference-not-bool/31974238#31974238 for Howard's explanation of vector<bool>::const_reference

[ldionne]

Wow, vector<bool> is such a mess.

[EricWF]

I've come around to Howards position that this is a beneficial extension, and so I'm abandoning this change.

I'll follow up with a patch that adds documentation for the extension and its rational.

include/__config

 #  define _LIBCPP_OBJECT_FORMAT_MACHO 1
 #elif defined(_WIN32)
 #  define _LIBCPP_OBJECT_FORMAT_COFF  1
 #elif defined(__wasm__)
 #  define _LIBCPP_OBJECT_FORMAT_WASM  1
 #else
 #  error Unknown object file format
 #endif
 
 #if defined(_LIBCPP_ABI_UNSTABLE) || _LIBCPP_ABI_VERSION >= 2
 // Change short string representation so that string data starts at offset 0,
 // improving its alignment in some cases.
 #  define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
 // Fix deque iterator type in order to support incomplete types.
 #  define _LIBCPP_ABI_INCOMPLETE_TYPES_IN_DEQUE
 // Fix undefined behavior in how std::list stores its linked nodes.
 #  define _LIBCPP_ABI_LIST_REMOVE_NODE_POINTER_UB

 #  define _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
 // Use the smallest possible integer type to represent the index of the variant.
 // Previously libc++ used "unsigned int" exclusively.
 #  define _LIBCPP_ABI_VARIANT_INDEX_TYPE_OPTIMIZATION
 // Unstable attempt to provide a more optimized std::function
 #  define _LIBCPP_ABI_OPTIMIZED_FUNCTION
 // All the regex constants must be distinct and nonzero.
 #  define _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO
+// Fix std::vector<bool>::const_reference to actually be a bool.
+#define _LIBCPP_ABI_VECTOR_BOOL_CORRECT_CONST_REFERENCE_TYPE
 #elif _LIBCPP_ABI_VERSION == 1
 #  if !defined(_LIBCPP_OBJECT_FORMAT_COFF)
 // Enable compiling copies of now inline methods into the dylib to support
 // applications compiled against older libraries. This is unnecessary with
 // COFF dllexport semantics, since dllexport forces a non-inline definition
 // of inline functions to be emitted anyway. Our own non-inline copy would
 // conflict with the dllexport-emitted copy, so we disable it.
 #    define _LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS

include/vector

     typedef allocator_traits<__storage_allocator>    __storage_traits;
     typedef typename __storage_traits::pointer       __storage_pointer;
     typedef typename __storage_traits::const_pointer __const_storage_pointer;
 
     __storage_pointer                                      __begin_;
     size_type                                              __size_;
     __compressed_pair<size_type, __storage_allocator> __cap_alloc_;
 public:
-    typedef __bit_reference<vector>                  reference;
-    typedef __bit_const_reference<vector>            const_reference;
+  typedef __bit_const_reference<vector> __const_ref;
+  typedef __bit_reference<vector> reference;
+#ifdef _LIBCPP_ABI_VECTOR_BOOL_CORRECT_CONST_REFERENCE_TYPE
+  typedef bool const_reference;
+#else
+  typedef __bit_const_reference<vector> const_reference;
+#endif
 private:
     _LIBCPP_INLINE_VISIBILITY
     size_type& __cap() _NOEXCEPT
         {return __cap_alloc_.first();}
     _LIBCPP_INLINE_VISIBILITY
     const size_type& __cap() const _NOEXCEPT
         {return __cap_alloc_.first();}
     _LIBCPP_INLINE_VISIBILITY

 #if _LIBCPP_STD_VER > 11
     template <class... _Args>
    _LIBCPP_INLINE_VISIBILITY iterator emplace(const_iterator position, _Args&&... __args)
         { return insert ( position, value_type ( _VSTD::forward<_Args>(__args)... )); }
 #endif
 
     iterator insert(const_iterator __position, const value_type& __x);
     iterator insert(const_iterator __position, size_type __n, const value_type& __x);
-    iterator insert(const_iterator __position, size_type __n, const_reference __x);
+
     template <class _InputIterator>
         typename enable_if
         <
              __is_input_iterator  <_InputIterator>::value &&
             !__is_forward_iterator<_InputIterator>::value,
             iterator
         >::type
         insert(const_iterator __position, _InputIterator __first, _InputIterator __last);

             void
         >::type
         __construct_at_end(_ForwardIterator __first, _ForwardIterator __last);
     void __append(size_type __n, const_reference __x);
     _LIBCPP_INLINE_VISIBILITY
     reference __make_ref(size_type __pos) _NOEXCEPT
         {return reference(__begin_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);}
     _LIBCPP_INLINE_VISIBILITY
-    const_reference __make_ref(size_type __pos) const _NOEXCEPT
-        {return const_reference(__begin_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);}
+    __const_ref __make_ref(size_type __pos) const _NOEXCEPT {
+      return __const_ref(__begin_ + __pos / __bits_per_word,
+                         __storage_type(1) << __pos % __bits_per_word);
+    }
     _LIBCPP_INLINE_VISIBILITY
     iterator __make_iter(size_type __pos) _NOEXCEPT
         {return iterator(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word));}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator __make_iter(size_type __pos) const _NOEXCEPT
         {return const_iterator(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word));}
     _LIBCPP_INLINE_VISIBILITY
     iterator __const_iterator_cast(const_iterator __p) _NOEXCEPT

test/std/containers/sequences/vector.bool/insert_iter_size_value.pass.cpp

int main(int, char**)
         std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (; j < 15; ++j)
             assert(v[j] == 1);
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
+    {
+      std::vector<bool> v(100);
+      const auto& cv = v;
+      std::vector<bool> v2;
+      v2.insert(v2.begin(), 3, cv[0]);
+    }
 #if TEST_STD_VER >= 11
     {
         std::vector<bool, min_allocator<bool>> v(100);
         std::vector<bool, min_allocator<bool>>::iterator i = v.insert(v.cbegin() + 10, 5, 1);
         assert(v.size() == 105);
         assert(i == v.begin() + 10);
         std::size_t j;
         for (j = 0; j < 10; ++j)

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

 //     typedef std::reverse_iterator<iterator>          reverse_iterator;
 //     typedef std::reverse_iterator<const_iterator>    const_reverse_iterator;
 // };
 
 #include <vector>
 #include <iterator>
 #include <type_traits>
 
+#include "test_macros.h"
 #include "test_allocator.h"
 #include "../../Copyable.h"
 #include "min_allocator.h"
 
 template <class Allocator>
 void
 test()
 {
     typedef std::vector<bool, Allocator> C;
 
-    static_assert((std::is_same<typename C::value_type, bool>::value), "");
-    static_assert((std::is_same<typename C::value_type, typename Allocator::value_type>::value), "");
-    static_assert((std::is_same<typename C::allocator_type, Allocator>::value), "");
-    static_assert((std::is_same<typename C::size_type, typename std::allocator_traits<Allocator>::size_type>::value), "");
-    static_assert((std::is_same<typename C::difference_type, typename std::allocator_traits<Allocator>::difference_type>::value), "");
+    ASSERT_SAME_TYPE(typename C::value_type, bool);
+    ASSERT_SAME_TYPE(typename C::value_type, typename Allocator::value_type);
+    ASSERT_SAME_TYPE(typename C::allocator_type, Allocator);
+    ASSERT_SAME_TYPE(typename C::size_type,
+                     typename std::allocator_traits<Allocator>::size_type);
+    ASSERT_SAME_TYPE(
+        typename C::difference_type,
+        typename std::allocator_traits<Allocator>::difference_type);
 
     static_assert((std::is_signed<typename C::difference_type>::value), "");
     static_assert((std::is_unsigned<typename C::size_type>::value), "");
-    static_assert((std::is_same<typename C::difference_type,
-        typename std::iterator_traits<typename C::iterator>::difference_type>::value), "");
-    static_assert((std::is_same<typename C::difference_type,
-        typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
+    ASSERT_SAME_TYPE(
+        typename C::difference_type,
+        typename std::iterator_traits<typename C::iterator>::difference_type);
+    ASSERT_SAME_TYPE(typename C::difference_type,
+                     typename std::iterator_traits<
+                         typename C::const_iterator>::difference_type);
 
-   static_assert((std::is_same<
+    ASSERT_SAME_TYPE(
         typename std::iterator_traits<typename C::iterator>::iterator_category,
-        std::random_access_iterator_tag>::value), "");
-    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), "");
+        std::random_access_iterator_tag);
+    ASSERT_SAME_TYPE(typename std::iterator_traits<
+                         typename C::const_iterator>::iterator_category,
+                     std::random_access_iterator_tag);
+    ASSERT_SAME_TYPE(typename C::reverse_iterator,
+                     std::reverse_iterator<typename C::iterator>);
+    ASSERT_SAME_TYPE(typename C::const_reverse_iterator,
+                     std::reverse_iterator<typename C::const_iterator>);
+
+#if !defined(_LIBCPP_VERSION) ||                                               \
+    defined(_LIBCPP_ABI_VECTOR_BOOL_CORRECT_CONST_REFERENCE_TYPE)
+    ASSERT_SAME_TYPE(typename C::const_reference, bool);
+#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), "");
+    ASSERT_SAME_TYPE(std::vector<bool>::allocator_type, std::allocator<bool>);
 #if TEST_STD_VER >= 11
     test<min_allocator<bool> >();
 #endif
 
   return 0;
 }