Tweak C++2a uses-allocator construction utilities

The 20_util/scoped_allocator/69293_neg.cc test was failing in C++2a mode
because the expected static_assert text wasn't matched. The code is
still ill-formed in C++2a, but uses the new __uses_alloc_args function
and so fails a different static_assert. This patch adds the same string
to the new static_assert, so the test passes.

Now that G++ allows concepts to be declared without 'bool' we can use
the correct C++2a syntax for the _Std_pair concept used to constrain the
uses-allocator construction utilities.

Also add a new test to verify that pmr::polymorphic_allocator correctly
performs recursive uses-allocator construction for nested pairs in
C++2a.

	* include/std/memory (__uses_alloc_args): Add string-literal to
	static_assert, to match the one in __uses_alloc.
	[__cpp_concepts] (_Std_pair): Use C++2a syntax for concept.
	* testsuite/20_util/polymorphic_allocator/construct_c++2a.cc: Check
	for recursive uses-allocator construction of nested pairs.
	* testsuite/20_util/scoped_allocator/construct_pair_c++2a.cc:: Add
	comment.

From-SVN: r270600

libstdc++-v3/ChangeLog

+2019-04-26  Jonathan Wakely  <jwakely@redhat.com>
+
+	* include/std/memory (__uses_alloc_args): Add string-literal to
+	static_assert, to match the one in __uses_alloc.
+	[__cpp_concepts] (_Std_pair): Use C++2a syntax for concept.
+	* testsuite/20_util/polymorphic_allocator/construct_c++2a.cc: Check
+	for recursive uses-allocator construction of nested pairs.
+	* testsuite/20_util/scoped_allocator/construct_pair_c++2a.cc:: Add
+	comment.
+
 2019-04-26  Jakub Jelinek  <jakub@redhat.com>
 
 	* config/abi/post/s390x-linux-gnu/32/baseline_symbols.txt: Update.

libstdc++-v3/include/std/memory

@@ -191,7 +191,9 @@ get_pointer_safety() noexcept { return pointer_safety::relaxed; }
 	    }
 	  else
 	    {
-	      static_assert(is_constructible_v<_Tp, _Args..., const _Alloc&>);
+	      static_assert(is_constructible_v<_Tp, _Args..., const _Alloc&>,
+		  "construction with an allocator must be possible"
+		  " if uses_allocator is true");
 
 	      return tuple<_Args&&..., const _Alloc&>(
 		  std::forward<_Args>(__args)..., __a);
@@ -207,7 +209,7 @@ get_pointer_safety() noexcept { return pointer_safety::relaxed; }
 
 #if __cpp_concepts
   template<typename _Tp>
-    concept bool _Std_pair = __is_pair<_Tp>::value;
+    concept _Std_pair = __is_pair<_Tp>::value;
 #endif
 
 // This is a temporary workaround until -fconcepts is implied by -std=gnu++2a

libstdc++-v3/testsuite/20_util/polymorphic_allocator/construct_c++2a.cc

@@ -21,6 +21,8 @@
 #include <memory_resource>
 #include <utility>
 #include <tuple>
+#include <testsuite_hooks.h>
+#include <testsuite_allocator.h>
 
 struct do_not_copy {
   do_not_copy() = default;
@@ -115,6 +117,54 @@ test05()
   a.deallocate(ptr, 1);
 }
 
+// P0591R4 makes uses-allocator construction apply recursively for nested pairs
+void
+test06()
+{
+  struct X
+  {
+    using allocator_type = std::pmr::polymorphic_allocator<int>;
+    X() = default;
+    X(const X&) { throw 1; }
+    X(const X&, const allocator_type& a) : mr(a.resource()) { }
+
+    std::pmr::memory_resource* mr = nullptr;
+  };
+
+  struct Y
+  {
+    using allocator_type = std::pmr::polymorphic_allocator<int>;
+    Y() = default;
+    Y(const Y&) = delete;
+    Y(std::allocator_arg_t, const allocator_type& a, const Y&)
+    : mr(a.resource()) { }
+
+    std::pmr::memory_resource* mr = nullptr;
+  };
+
+  using value_type = std::pair<std::pair<X, int>, std::pair<int, Y>>;
+  __gnu_test::memory_resource mr;
+  std::pmr::polymorphic_allocator<int> a(&mr);
+  std::pmr::vector<value_type> v(a);
+  VERIFY( v.get_allocator().resource() == &mr );
+
+  value_type val;
+  val.first.second = 2;
+  val.second.first = 3;
+  v.push_back(val);
+  X& x = v.back().first.first;
+  VERIFY( x.mr != val.first.first.mr );
+  VERIFY( x.mr == &mr );
+
+  Y& y = v.back().second.second;
+  VERIFY( y.mr != val.second.second.mr );
+  VERIFY( y.mr == &mr );
+
+  // Check other members of the pairs are correctly initialized too:
+  VERIFY( v.back().first.second == val.first.second );
+  VERIFY( v.back().second.first == val.second.first );
+}
+
 int main()
 {
   test01();
@@ -122,4 +172,5 @@ int main()
   test03();
   test04();
   test05();
+  test06();
 }

libstdc++-v3/testsuite/20_util/scoped_allocator/construct_pair_c++2a.cc

@@ -18,6 +18,8 @@
 // { dg-options "-std=gnu++2a" }
 // { dg-do run { target c++2a } }
 
+// P0591R4 makes uses-allocator construction apply recursively for nested pairs
+
 #include <scoped_allocator>
 #include <vector>
 #include <testsuite_hooks.h>