[libcxx] Support allocators with explicit c-tors in vector<bool>

[miyuki]

Summary

std::vector<bool> rebinds the supplied allocator to construct objects
of type '__storage_type' rather than 'bool'. Allocators are allowed to
use explicit conversion constructors, so care must be taken when
performing conversions.

libcxx/include/vector

vector<bool, _Allocator>::assign(size_type __n, const value_type& __x)
     __size_ = 0;
     if (__n > 0)
     {
         size_type __c = capacity();
         if (__n <= __c)
             __size_ = __n;
         else
         {
-            vector __v(__alloc());
+            vector __v(get_allocator());
             __v.reserve(__recommend(__n));
             __v.__size_ = __n;
             swap(__v);
         }
         _VSTD::fill_n(begin(), __n, __x);
     }
   __invalidate_all_iterators();
 }

 }
 
 template <class _Allocator>
 void
 vector<bool, _Allocator>::reserve(size_type __n)
 {
     if (__n > capacity())
     {
-        vector __v(this->__alloc());
+        vector __v(this->get_allocator());
         __v.__vallocate(__n);
         __v.__construct_at_end(this->begin(), this->end());
         swap(__v);
         __invalidate_all_iterators();
     }
 }
 
 template <class _Allocator>
vector<bool, _Allocator>::insert(const_iterator __position, const value_type& __x)
     {
         const_iterator __old_end = end();
         ++__size_;
         _VSTD::copy_backward(__position, __old_end, end());
         __r = __const_iterator_cast(__position);
     }
     else
     {
-        vector __v(__alloc());
+        vector __v(get_allocator());
         __v.reserve(__recommend(__size_ + 1));
         __v.__size_ = __size_ + 1;
         __r = _VSTD::copy(cbegin(), __position, __v.begin());
         _VSTD::copy_backward(__position, cend(), __v.end());
         swap(__v);
     }
     *__r = __x;
     return __r;
vector<bool, _Allocator>::insert(const_iterator __position, size_type __n, const value_type& __x)
     {
         const_iterator __old_end = end();
         __size_ += __n;
         _VSTD::copy_backward(__position, __old_end, end());
         __r = __const_iterator_cast(__position);
     }
     else
     {
-        vector __v(__alloc());
+        vector __v(get_allocator());
         __v.reserve(__recommend(__size_ + __n));
         __v.__size_ = __size_ + __n;
         __r = _VSTD::copy(cbegin(), __position, __v.begin());
         _VSTD::copy_backward(__position, cend(), __v.end());
         swap(__v);
     }
     _VSTD::fill_n(__r, __n, __x);
     return __r;
vector<bool, _Allocator>::insert(const_iterator __position, _InputIterator __first, _InputIterator __last)
     difference_type __off = __position - begin();
     iterator __p = __const_iterator_cast(__position);
     iterator __old_end = end();
     for (; size() != capacity() && __first != __last; ++__first)
     {
         ++this->__size_;
         back() = *__first;
     }
-    vector __v(__alloc());
+    vector __v(get_allocator());
     if (__first != __last)
     {
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif // _LIBCPP_NO_EXCEPTIONS
             __v.assign(__first, __last);
             difference_type __old_size = static_cast<difference_type>(__old_end - begin());
vector<bool, _Allocator>::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last)
     {
         const_iterator __old_end = end();
         __size_ += __n;
         _VSTD::copy_backward(__position, __old_end, end());
         __r = __const_iterator_cast(__position);
     }
     else
     {
-        vector __v(__alloc());
+        vector __v(get_allocator());
         __v.reserve(__recommend(__size_ + __n));
         __v.__size_ = __size_ + __n;
         __r = _VSTD::copy(cbegin(), __position, __v.begin());
         _VSTD::copy_backward(__position, cend(), __v.end());
         swap(__v);
     }
     _VSTD::copy(__first, __last, __r);
     return __r;
if (__cs < __sz)
         size_type __n = __sz - __cs;
         if (__n <= __c && __cs <= __c - __n)
         {
             __r = end();
             __size_ += __n;
         }
         else
         {
-            vector __v(__alloc());
+            vector __v(get_allocator());
             __v.reserve(__recommend(__size_ + __n));
             __v.__size_ = __size_ + __n;
             __r = _VSTD::copy(cbegin(), cend(), __v.begin());
             swap(__v);
         }
         _VSTD::fill_n(__r, __n, __x);
     }
     else

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

int main(int, char**)
             assert(v[j] == 0);
         for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < v.size(); ++j)
             assert(v[j] == 0);
     }
 #if TEST_STD_VER >= 11
     {
+        std::vector<bool, explicit_allocator<bool>> v(100);
+        bool a[] = {1, 0, 0, 1, 1};
+        const unsigned N = sizeof(a)/sizeof(a[0]);
+        std::vector<bool, explicit_allocator<bool>>::iterator i = v.insert(v.cbegin() + 10, cpp17_input_iterator<const bool*>(a),
+                                        cpp17_input_iterator<const bool*>(a+N));
+        assert(v.size() == 100 + N);
+        assert(i == v.begin() + 10);
+        std::size_t j;
+        for (j = 0; j < 10; ++j)
+            assert(v[j] == 0);
+        for (std::size_t k = 0; k < N; ++j, ++k)
+            assert(v[j] == a[k]);
+        for (; j < v.size(); ++j)
+            assert(v[j] == 0);
+    }
+    {
         std::vector<bool, min_allocator<bool>> v(100);
         bool a[] = {1, 0, 0, 1, 1};
         const unsigned N = sizeof(a)/sizeof(a[0]);
         std::vector<bool, min_allocator<bool>>::iterator i = v.insert(v.cbegin() + 10, cpp17_input_iterator<const bool*>(a),
                                         cpp17_input_iterator<const bool*>(a+N));
         assert(v.size() == 100 + N);
         assert(i == v.begin() + 10);
         std::size_t j;

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

int main(int, char**)
             assert(v[j] == 0);
         for (; j < 15; ++j)
             assert(v[j] == 1);
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
 #if TEST_STD_VER >= 11
     {
+        std::vector<bool, explicit_allocator<bool>> v(10);
+        std::vector<bool, explicit_allocator<bool>>::iterator i
+            = v.insert(v.cbegin() + 10, 5, 1);
+        assert(v.size() == 15);
+        assert(i == v.begin() + 10);
+    }
+    {
         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)
             assert(v[j] == 0);
         for (; j < 15; ++j)
             assert(v[j] == 1);
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
 #endif
 
   return 0;
 }

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

int main(int, char**)
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         assert(v[j] == 1);
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
 #if TEST_STD_VER >= 11
     {
+        std::vector<bool, explicit_allocator<bool>> v(10);
+        std::vector<bool, explicit_allocator<bool>>::iterator i
+            = v.insert(v.cbegin() + 10, 1);
+        assert(v.size() == 11);
+        assert(i == v.begin() + 10);
+        assert(*i == 1);
+    }
+    {
         std::vector<bool, min_allocator<bool>> v(100);
         std::vector<bool, min_allocator<bool>>::iterator i = v.insert(v.cbegin() + 10, 1);
         assert(v.size() == 101);
         assert(i == v.begin() + 10);
         std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         assert(v[j] == 1);
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
 #endif
 
   return 0;
 }

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

int main(int, char**)
     }
 #if TEST_STD_VER >= 11
     {
         std::vector<bool, min_allocator<bool>> v;
         v.reserve(10);
         assert(v.capacity() >= 10);
     }
     {
+        std::vector<bool, explicit_allocator<bool>> v;
+        v.reserve(10);
+        assert(v.capacity() >= 10);
+    }
+    {
         std::vector<bool, min_allocator<bool>> v(100);
         assert(v.capacity() >= 100);
         v.reserve(50);
         assert(v.size() == 100);
         assert(v.capacity() >= 100);
         v.reserve(150);
         assert(v.size() == 100);
         assert(v.capacity() >= 150);
     }
 #endif
 
   return 0;
 }

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

int main(int, char**)
         assert(v.capacity() >= 200);
         v.reserve(400);
         v.resize(300);  // check the case when resizing and we already have room
         assert(v.size() == 300);
         assert(v.capacity() >= 400);
     }
 #if TEST_STD_VER >= 11
     {
+        std::vector<bool, explicit_allocator<bool>> v;
+        v.resize(10);
+        assert(v.size() == 10);
+        assert(v.capacity() >= 10);
+    }
+    {
         std::vector<bool, min_allocator<bool>> v(100);
         v.resize(50);
         assert(v.size() == 50);
         assert(v.capacity() >= 100);
         v.resize(200);
         assert(v.size() == 200);
         assert(v.capacity() >= 200);
         v.reserve(400);
         v.resize(300);  // check the case when resizing and we already have room
         assert(v.size() == 300);
         assert(v.capacity() >= 400);
     }
 #endif
 
   return 0;
 }