Implement LWG-4312 Const and value category mismatch for allocator_arg_t/allocator_arg in the description of uses-allocator construction (#5904)

Author: frederick-vs-ja

stl/inc/tuple

@@ -142,7 +142,7 @@ struct _Tuple_val { // stores each value in a tuple
                         _STD is_constructible<_Ty, _STD allocator_arg_t, const _Alloc&, _Other...>>,
             int> = 0>
     constexpr _Tuple_val(const _Alloc& _Al, allocator_arg_t, _Other&&... _Arg)
-        : _Val(allocator_arg, _Al, _STD forward<_Other>(_Arg)...) {}
+        : _Val(allocator_arg_t{}, _Al, _STD forward<_Other>(_Arg)...) {}
 
     template <class _Alloc, class... _Other,
         enable_if_t<conjunction_v<_STD uses_allocator<_Dty, _Alloc>,

stl/inc/xpolymorphic_allocator.h

@@ -28,7 +28,7 @@ void _Uses_alloc_construct_non_pair(_Ty* const _Ptr, _Outer_alloc& _Outer, _Inne
     if constexpr (uses_allocator_v<remove_cv_t<_Ty>, _Inner_alloc>) {
         if constexpr (is_constructible_v<_Ty, allocator_arg_t, _Inner_alloc&, _Types...>) {
             allocator_traits<_Outer_alloc>::construct(
-                _Outer, _Ptr, allocator_arg, _Inner, _STD forward<_Types>(_Args)...);
+                _Outer, _Ptr, allocator_arg_t{}, _Inner, _STD forward<_Types>(_Args)...);
         } else {
             static_assert(is_constructible_v<_Ty, _Types..., _Inner_alloc&>,
                 "N4950 [allocator.uses.trait]/1 requires "

tests/std/tests/Dev11_0343056_pair_tuple_ctor_sfinae/test.cpp

@@ -165,6 +165,60 @@ void test_lwg3677_volatile() {
     assert(get<0>(t6).get_payload() == 252);
 }
 
+// LWG-4312 "Const and value category mismatch for allocator_arg_t/allocator_arg in the description of uses-allocator
+// construction"
+
+struct allocator_arg_mutable_rvalue_only {
+    allocator_arg_mutable_rvalue_only() = default;
+
+    template <class A>
+    constexpr allocator_arg_mutable_rvalue_only(allocator_arg_t&&, const A&) {}
+    template <class A>
+    constexpr allocator_arg_mutable_rvalue_only(allocator_arg_t&&, const A&, const allocator_arg_mutable_rvalue_only&) {
+    }
+    template <class A>
+    constexpr allocator_arg_mutable_rvalue_only(allocator_arg_t&&, const A&, allocator_arg_mutable_rvalue_only&&) {}
+
+    template <class A>
+    allocator_arg_mutable_rvalue_only(allocator_arg_t&, const A&) = delete;
+    template <class A>
+    allocator_arg_mutable_rvalue_only(allocator_arg_t&, const A&, const allocator_arg_mutable_rvalue_only&) = delete;
+    template <class A>
+    allocator_arg_mutable_rvalue_only(allocator_arg_t&, const A&, allocator_arg_mutable_rvalue_only&&) = delete;
+
+    template <class A>
+    allocator_arg_mutable_rvalue_only(const allocator_arg_t&, const A&) = delete;
+    template <class A>
+    allocator_arg_mutable_rvalue_only(
+        const allocator_arg_t&, const A&, const allocator_arg_mutable_rvalue_only&) = delete;
+    template <class A>
+    allocator_arg_mutable_rvalue_only(const allocator_arg_t&, const A&, allocator_arg_mutable_rvalue_only&&) = delete;
+};
+
+template <class A>
+struct std::uses_allocator<allocator_arg_mutable_rvalue_only, A> : true_type {};
+
+CONSTEXPR20 bool test_lwg4312() {
+    tuple<allocator_arg_mutable_rvalue_only> t1{allocator_arg, allocator<int>{}};
+    tuple<allocator_arg_mutable_rvalue_only> t2{allocator_arg, allocator<int>{}, get<0>(t1)};
+    tuple<allocator_arg_mutable_rvalue_only> t3{allocator_arg, allocator<int>{}, allocator_arg_mutable_rvalue_only{}};
+
+    (void) t1;
+    (void) t2;
+    (void) t3;
+
+    tuple<allocator_arg_mutable_rvalue_only> t4{allocator_arg, payloaded_allocator<int>{42}};
+    tuple<allocator_arg_mutable_rvalue_only> t5{allocator_arg, payloaded_allocator<int>{84}, get<0>(t1)};
+    tuple<allocator_arg_mutable_rvalue_only> t6{
+        allocator_arg, payloaded_allocator<int>{168}, allocator_arg_mutable_rvalue_only{}};
+
+    (void) t4;
+    (void) t5;
+    (void) t6;
+
+    return true;
+}
+
 int main() {
     B* b = nullptr;
     Y* y = nullptr;
@@ -250,6 +304,11 @@ int main() {
     static_assert(test_lwg3677());
 #endif // _HAS_CXX20
     test_lwg3677_volatile();
+
+    test_lwg4312();
+#if _HAS_CXX20
+    static_assert(test_lwg4312());
+#endif // _HAS_CXX20
 }
 
 struct Meow {

tests/std/tests/P0220R1_polymorphic_memory_resources/test.cpp

@@ -137,7 +137,11 @@ namespace {
 
         int i_ = 0;
 
-        uses_allocator_thing(std::allocator_arg_t, Alloc const& a, int i = 0) : Alloc(a), i_{i} {}
+        // Such overload set is used for testing LWG-4312.
+        uses_allocator_thing(std::allocator_arg_t&&, Alloc const& a, int i = 0) : Alloc(a), i_{i} {}
+        uses_allocator_thing(std::allocator_arg_t&, Alloc const&, int = 0)       = delete;
+        uses_allocator_thing(const std::allocator_arg_t&, Alloc const&, int = 0) = delete;
+
         Alloc get_allocator() const {
             return *this;
         }
@@ -151,8 +155,8 @@ namespace {
     };
     template <class Alloc>
     struct uses_allocator_thing<Alloc, false> : uses_allocator_thing<Alloc, true> {
-        uses_allocator_thing(int i, Alloc const& a) : uses_allocator_thing<Alloc, true>{std::allocator_arg, a, i} {}
-        uses_allocator_thing(Alloc const& a) : uses_allocator_thing<Alloc, true>{std::allocator_arg, a} {}
+        uses_allocator_thing(int i, Alloc const& a) : uses_allocator_thing<Alloc, true>{std::allocator_arg_t{}, a, i} {}
+        uses_allocator_thing(Alloc const& a) : uses_allocator_thing<Alloc, true>{std::allocator_arg_t{}, a} {}
     };
 
     struct malloc_resource final : std::pmr::memory_resource {
@@ -691,6 +695,25 @@ namespace {
                 }
             } // namespace construct
 
+
+            // Also test LWG-4312 "Const and value category mismatch for allocator_arg_t/allocator_arg in the
+            // description of uses-allocator construction"
+            namespace uses_allocator_construct {
+                void test() {
+                    malloc_resource mr;
+                    std::pmr::polymorphic_allocator<not_constructible> alloc = &mr;
+
+                    using T = uses_allocator_thing<std::pmr::polymorphic_allocator<int>, true>;
+
+                    alignas(T) unsigned char space[sizeof(T)];
+                    const auto rawptr = reinterpret_cast<T*>(space);
+                    alloc.construct(rawptr);
+                    placement_ptr<T> ptr{rawptr};
+
+                    CHECK(ptr->get_allocator().resource() == &mr);
+                }
+            } // namespace uses_allocator_construct
+
             namespace piecewise_construct {
                 void test() {
                     malloc_resource mr;
@@ -1573,6 +1596,7 @@ int main() {
     polymorphic_allocator::ctor::rebind::test();
     polymorphic_allocator::mem::allocate_deallocate::test();
     polymorphic_allocator::mem::construct::test();
+    polymorphic_allocator::mem::uses_allocator_construct::test();
     polymorphic_allocator::mem::piecewise_construct::test();
     polymorphic_allocator::mem::construct_pair::test();
     polymorphic_allocator::mem::construct_pair_U_V::test();

tests/std/tests/VSO_0224478_scoped_allocator/test.cpp

@@ -119,6 +119,23 @@ void test_case_LWG_2586() {
     sa.deallocate(ptr, 1);
 }
 
+struct lwg_4312 {
+    using allocator_type = allocator<lwg_4312>;
+    lwg_4312(allocator_arg_t&&, const allocator_type&) {}
+    lwg_4312(allocator_arg_t&, const allocator_type&)       = delete;
+    lwg_4312(const allocator_arg_t&, const allocator_type&) = delete;
+};
+
+void test_case_LWG_4312() {
+    // LWG-4312 "Const and value category mismatch for allocator_arg_t/allocator_arg in the description of
+    // uses-allocator construction"
+    scoped_allocator_adaptor<allocator<lwg_4312>> sa;
+    const auto ptr = sa.allocate(1);
+    sa.construct(ptr);
+    sa.destroy(ptr);
+    sa.deallocate(ptr, 1);
+}
+
 void test_case_move_rebind_one_alloc() {
     scoped_allocator_adaptor<allocator<int>> sa;
     scoped_allocator_adaptor<allocator<double>> target(move(sa));
@@ -159,5 +176,6 @@ int main() {
     test_case_VSO_224478_allow_stacking();
     test_case_VSO_224478_piecewise_construct_calls_allocator_construct();
     test_case_LWG_2586();
+    test_case_LWG_4312();
     test_case_move_rebind_one_alloc();
 }