[PATCH] LWG 2975 ensure construct(pair*, ...) used to construct pairs

[Jonathan Wakely]

        * include/std/scoped_allocator (__not_pair): Define SFINAE helper.
        (construct(_Tp*, _Args&&...)): Remove from overload set when _Tp is
        a specialization of std::pair.
        * testsuite/20_util/scoped_allocator/construct_pair.cc: Ensure
        pair elements are constructed correctly.

Tested powerpc64le-linux, committed to trunk.



commit d0d30a98189f840f1132a2ce02bc26fe8da570d6
Author: Jonathan Wakely <jwak...@redhat.com>
Date:   Mon Jun 18 20:36:49 2018 +0100

    LWG 2975 ensure construct(pair<T,U>*, ...) used to construct pairs
    
            * include/std/scoped_allocator (__not_pair): Define SFINAE helper.
            (construct(_Tp*, _Args&&...)): Remove from overload set when _Tp is
            a specialization of std::pair.
            * testsuite/20_util/scoped_allocator/construct_pair.cc: Ensure
            pair elements are constructed correctly.

diff --git a/libstdc++-v3/include/std/scoped_allocator 
b/libstdc++-v3/include/std/scoped_allocator
index 195db397ac9..ea62f113517 100644
--- a/libstdc++-v3/include/std/scoped_allocator
+++ b/libstdc++-v3/include/std/scoped_allocator
@@ -241,6 +241,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
             is_constructible<_OuterAlloc, _Alloc>::value
           >::type;
 
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 2975. Missing case for pair construction in scoped [...] allocators
+      template<typename _Tp>
+       struct __not_pair { using type = void; };
+
+      template<typename _Tp, typename _Up>
+       struct __not_pair<pair<_Tp, _Up>> { };
+
     public:
       typedef _OuterAlloc                       outer_allocator_type;
       typedef typename __inner_type::__type     inner_allocator_type;
@@ -348,13 +356,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       { return __traits::max_size(outer_allocator()); }
 
       template<typename _Tp, typename... _Args>
-        void construct(_Tp* __p, _Args&&... __args)
-        {
-          auto& __inner = inner_allocator();
-          auto __use_tag
-            = __use_alloc<_Tp, inner_allocator_type, _Args...>(__inner);
-          _M_construct(__use_tag, __p, std::forward<_Args>(__args)...);
-        }
+       typename __not_pair<_Tp>::type
+       construct(_Tp* __p, _Args&&... __args)
+       {
+         auto& __inner = inner_allocator();
+         auto __use_tag
+           = __use_alloc<_Tp, inner_allocator_type, _Args...>(__inner);
+         _M_construct(__use_tag, __p, std::forward<_Args>(__args)...);
+       }
 
       template<typename _T1, typename _T2, typename... _Args1,
               typename... _Args2>
diff --git a/libstdc++-v3/testsuite/20_util/scoped_allocator/construct_pair.cc 
b/libstdc++-v3/testsuite/20_util/scoped_allocator/construct_pair.cc
index 341328e487f..b34efc88798 100644
--- a/libstdc++-v3/testsuite/20_util/scoped_allocator/construct_pair.cc
+++ b/libstdc++-v3/testsuite/20_util/scoped_allocator/construct_pair.cc
@@ -73,9 +73,37 @@ test03()
   a.deallocate(ptr, 1);
 }
 
+void
+test04()
+{
+  struct X
+  {
+    using allocator_type = std::allocator<int>;
+    X() = default;
+    X(const X&) { throw 1; }
+    X(const X&, const allocator_type&) { }
+  };
+
+  struct Y
+  {
+    using allocator_type = std::allocator<int>;
+    Y() = default;
+    Y(const Y&) = delete;
+    Y(std::allocator_arg_t, const allocator_type&, const Y&) { }
+  };
+
+  using pair_type = std::pair<X, Y>;
+  std::scoped_allocator_adaptor<std::allocator<pair_type>> a;
+  auto ptr = a.allocate(1);
+  /* not const */ pair_type p;
+  a.construct(ptr, p); // LWG 2975
+  a.deallocate(ptr, 1);
+}
+
 int main()
 {
   test01();
   test02();
   test03();
+  test04();
 }