[libc++][format] Fixes formatting vector<bool>

[Mordante]

Summary

Formatting a const qualified vector<bool> fails to work on libc++. This
is due to our non-conforming type for vector<bool>::const_reference. The
type is a __bit_const_reference<vector> instead of a bool. (This is
fixed in ABI v2.)

This fixes this formatter and enables the test written for it.

[philnik]

libcxx/include/__bit_reference

158

Why not just _Cp?

[Mordante]

libcxx/include/__bit_reference

158

To make sure this is used with a std::vector, similar to the friend at line 155.

[philnik]

libcxx/include/__bit_reference

158

How would it not be used with a std::vector or std::bitset? If a user tries to instantiate it with another class it's not exactly hard to add the alias.

[ldionne]

LGTM

libcxx/include/__bit_reference

158

FWIW I think the __self thing is really weird, but I would support changing that in its own patch if we want to do something about it.

[Mordante]

Thanks for the reviews!

libcxx/include/__bit_reference

158

How would it not be used with a std::vector or std::bitset? If a user tries to instantiate it with another class it's not exactly hard to add the alias.

Of course you can, but you're not allowed to since it uses the ugly name.

FWIW I think the __self thing is really weird, but I would support changing that in its own patch if we want to do something about it.

I don't feel to strongly about it, so I will not pursue it. (I've more things to do, which I deem important.)

158

FWIW I think the __self thing is really weird, but I would support changing that in its own patch if we want to do something about it.

libcxx/include/__bit_reference

class __bit_const_reference
     typedef typename _Cp::__const_storage_pointer __storage_pointer;
 
     __storage_pointer        __seg_;
     __storage_type __mask_;
 
     friend typename _Cp::__self;
     friend class __bit_iterator<_Cp, true>;
 public:
+    using __container = typename _Cp::__self;
+
     _LIBCPP_INLINE_VISIBILITY
     __bit_const_reference(const __bit_const_reference&) = default;
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
     __bit_const_reference(const __bit_reference<_Cp>& __x) _NOEXCEPT
         : __seg_(__x.__seg_), __mask_(__x.__mask_) {}
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR operator bool() const _NOEXCEPT

libcxx/test/std/containers/container.adaptors/container.adaptors.format/format.functions.tests.h

void test_bool(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check_exception("Argument index out of bounds", SV("{:^^{}::>5}"), input);
   check_exception("Argument index out of bounds", SV("{:^^{}::>{}}"), input, 32);
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_bool(TestFunction check, ExceptionTest check_exception) {
   std::array input{true, true, false};
   test_bool<CharT>(check, check_exception, std::queue{input.begin(), input.end()});
-  // TODO FMT Use std::vector<bool> after it has been implemented.
-  test_bool<CharT>(check, check_exception, std::priority_queue<bool, std::deque<bool>>{input.begin(), input.end()});
+  test_bool<CharT>(check, check_exception, std::priority_queue{input.begin(), input.end()});
   test_bool<CharT>(check, check_exception, std::stack{input.begin(), input.end()});
 }
 
 //
 // Integral
 //
 
 template <class CharT, class TestFunction, class ExceptionTest>

libcxx/test/std/containers/sequences/vector.bool/vector.bool.fmt/format.functions.tests.h

 //===----------------------------------------------------------------------===//
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TEST_STD_CONTAINERS_SEQUENCES_VECTOR_BOOL_VECTOR_BOOL_FMT_FORMAT_FUNCTIONS_TESTS_H
 #define TEST_STD_CONTAINERS_SEQUENCES_VECTOR_BOOL_VECTOR_BOOL_FMT_FORMAT_FUNCTIONS_TESTS_H
 
 #include <vector>
 
 #include "format.functions.common.h"
 #include "test_macros.h"
 
 template <class CharT, class TestFunction, class ExceptionTest>
-void format_tests(TestFunction check, ExceptionTest check_exception) {
-  std::vector input{true, true, false};
-
+void format_test_vector_bool(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV("[true, true, false]"), SV("{}"), input);
 
   // ***** underlying has no format-spec
 
   // *** align-fill & width ***
   check(SV("[true, true, false]     "), SV("{:24}"), input);
   check(SV("[true, true, false]*****"), SV("{:*<24}"), input);
   check(SV("__[true, true, false]___"), SV("{:_^24}"), input);
void format_test_vector_bool(TestFunction check, ExceptionTest check_exception, auto&& input) {
   check(SV("^^[:::true, :::true, ::false]^^^"), SV("{:^^32::>7}"), input);
   check(SV("^^[:::true, :::true, ::false]^^^"), SV("{:^^{}::>7}"), input, 32);
   check(SV("^^[:::true, :::true, ::false]^^^"), SV("{:^^{}::>{}}"), input, 32, 7);
 
   check_exception("Argument index out of bounds", SV("{:^^{}::>5}"), input);
   check_exception("Argument index out of bounds", SV("{:^^{}::>{}}"), input, 32);
 }
 
+template <class CharT, class TestFunction, class ExceptionTest>
+void format_tests(TestFunction check, ExceptionTest check_exception) {
+  format_test_vector_bool<CharT>(check, check_exception, std::vector{true, true, false});
+
+  // The const_reference shall be a bool.
+  // However libc++ uses a __bit_const_reference<vector> when
+  // _LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL is defined.
+  const std::vector input{true, true, false};
+  format_test_vector_bool<CharT>(check, check_exception, input);
+}
+
 #endif // TEST_STD_CONTAINERS_SEQUENCES_VECTOR_BOOL_VECTOR_BOOL_FMT_FORMAT_FUNCTIONS_TESTS_H

libcxx/test/std/utilities/format/format.formattable/concept.formattable.compile.pass.cpp

 #endif
   assert_is_not_formattable<std::unique_ptr<int>, CharT>();
 }
 
 template <class CharT, class Vector>
 void test_P2286_vector_bool() {
   assert_is_formattable<Vector, CharT>();
   assert_is_formattable<typename Vector::reference, CharT>();
+
+  // The const_reference shall be a bool.
+  // However libc++ uses a __bit_const_reference<vector> when
+  // _LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL is defined.
+  assert_is_formattable<const Vector&, CharT>();
+  assert_is_formattable<typename Vector::const_reference, CharT>();
 }
 
 // Tests for P2286 Formatting ranges
 template <class CharT>
 void test_P2286() {
   assert_is_formattable<std::array<int, 42>, CharT>();
   assert_is_formattable<std::vector<int>, CharT>();
   assert_is_formattable<std::deque<int>, CharT>();