libstdc++: Implement missing allocator-aware constructors for unordered containers.

This patch implements remainder of LWG2713 (after r15-8293-g64f5c854597759)
by adding missing allocator aware version of unordered associative containers
constructors accepting pair of iterators or initializer_list, and corresponding
deduction guides.

libstdc++-v3/ChangeLog:

	* include/bits/unordered_map.h (unordered_map):
	Define constructors accepting:
	(_InputIterator, _InputIterator, const allocator_type&),
	(initializer_list<value_type>, const allocator_type&),
	(unordered_multimap): Likewise.
	* include/debug/unordered_map (unordered_map): Likewise.
	(unordered_multimap): Likewise.
	* include/bits/unordered_set.h (unordered_set):
	Define constructors and deduction guide accepting:
	(_InputIterator, _InputIterator, const allocator_type&),
	(initializer_list<value_type>, const allocator_type&),
	(unordered_multiset): Likewise.
	* include/debug/unordered_set (unordered_set): Likewise.
	(unordered_multiset): Likewise.
	* testsuite/23_containers/unordered_map/cons/66055.cc: New tests.
	* testsuite/23_containers/unordered_map/cons/deduction.cc: New tests.
	* testsuite/23_containers/unordered_multimap/cons/66055.cc: New tests.
	* testsuite/23_containers/unordered_multimap/cons/deduction.cc:	New
	tests.
	* testsuite/23_containers/unordered_multiset/cons/66055.cc: New tests.
	* testsuite/23_containers/unordered_multiset/cons/deduction.cc:	New
	tests.
	* testsuite/23_containers/unordered_set/cons/66055.cc: New tests.
	* testsuite/23_containers/unordered_set/cons/deduction.cc: New tests.

Reviewed-by: Jonathan Wakely <jwakely@redhat.com>
Signed-off-by: Tomasz Kamiński <tkaminsk@redhat.com>

diff --git a/libstdc++-v3/include/bits/unordered_map.h b/libstdc++-v3/include/bits/unordered_map.h
index 5bc58e849ffa5c50395a36415e9a4381ab4a84d1..fc07ffc998ca10f733c4d38a1105e82b9e21c5e9 100644 (file)
--- a/libstdc++-v3/include/bits/unordered_map.h
+++ b/libstdc++-v3/include/bits/unordered_map.h
@@ -251,6 +251,14 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
       : unordered_map(__n, __hf, key_equal(), __a)
       { }
 
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 2713. More missing allocator-extended constructors for unordered containers
+      template<typename _InputIterator>
+       unordered_map(_InputIterator __first, _InputIterator __last,
+                     const allocator_type& __a)
+       : unordered_map(__first, __last, 0, hasher(), key_equal(), __a)
+       { }
+
       template<typename _InputIterator>
        unordered_map(_InputIterator __first, _InputIterator __last,
                      size_type __n,
@@ -271,6 +279,13 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
       : unordered_map(__l, __n, hasher(), key_equal(), __a)
       { }
 
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 2713. More missing allocator-extended constructors for unordered containers
+      unordered_map(initializer_list<value_type> __l,
+                   const allocator_type& __a)
+      : unordered_map(__l, 0, hasher(), key_equal(), __a)
+      { }
+
       unordered_map(initializer_list<value_type> __l,
                    size_type __n, const hasher& __hf,
                    const allocator_type& __a)
@@ -1504,6 +1519,14 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
       : unordered_multimap(__n, __hf, key_equal(), __a)
       { }
 
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 2713. More missing allocator-extended constructors for unordered containers
+      template<typename _InputIterator>
+       unordered_multimap(_InputIterator __first, _InputIterator __last,
+                          const allocator_type& __a)
+       : unordered_multimap(__first, __last, 0, hasher(), key_equal(), __a)
+       { }
+
       template<typename _InputIterator>
        unordered_multimap(_InputIterator __first, _InputIterator __last,
                           size_type __n,
@@ -1518,6 +1541,13 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
        : unordered_multimap(__first, __last, __n, __hf, key_equal(), __a)
        { }
 
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 2713. More missing allocator-extended constructors for unordered containers
+      unordered_multimap(initializer_list<value_type> __l,
+                        const allocator_type& __a)
+      : unordered_multimap(__l, 0, hasher(), key_equal(), __a)
+      { }
+
       unordered_multimap(initializer_list<value_type> __l,
                         size_type __n,
                         const allocator_type& __a)

diff --git a/libstdc++-v3/include/bits/unordered_set.h b/libstdc++-v3/include/bits/unordered_set.h
index 091bae60e5556c552325e44f53a4f95c9da882f0..5649dd76e1fbb3f1590a9d1644e5bc02007faeb4 100644 (file)
--- a/libstdc++-v3/include/bits/unordered_set.h
+++ b/libstdc++-v3/include/bits/unordered_set.h
@@ -245,6 +245,14 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
       : unordered_set(__n, __hf, key_equal(), __a)
       { }
 
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 2713. More missing allocator-extended constructors for unordered container
+      template<typename _InputIterator>
+       unordered_set(_InputIterator __first, _InputIterator __last,
+                     const allocator_type& __a)
+       : unordered_set(__first, __last, 0, hasher(), key_equal(), __a)
+       { }
+
       template<typename _InputIterator>
        unordered_set(_InputIterator __first, _InputIterator __last,
                      size_type __n,
@@ -259,6 +267,14 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
        : unordered_set(__first, __last, __n, __hf, key_equal(), __a)
        { }
 
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 2713. More missing allocator-extended constructors for unordered container
+      unordered_set(initializer_list<value_type> __l,
+                   const allocator_type& __a)
+      : unordered_set(__l, 0, hasher(), key_equal(), __a)
+      { }
+
       unordered_set(initializer_list<value_type> __l,
                    size_type __n,
                    const allocator_type& __a)
@@ -987,6 +1003,19 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
                       typename iterator_traits<_InputIterator>::value_type>,
                     _Allocator>;
 
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // 2713. More missing allocator-extended constructors for unordered container
+  template<typename _InputIterator, typename _Allocator,
+          typename = _RequireInputIter<_InputIterator>,
+          typename = _RequireAllocator<_Allocator>>
+    unordered_set(_InputIterator, _InputIterator, _Allocator)
+    -> unordered_set<typename iterator_traits<_InputIterator>::value_type,
+                    hash<
+                      typename iterator_traits<_InputIterator>::value_type>,
+                    equal_to<
+                      typename iterator_traits<_InputIterator>::value_type>,
+                    _Allocator>;
+
   template<typename _InputIterator, typename _Hash, typename _Allocator,
           typename = _RequireInputIter<_InputIterator>,
           typename = _RequireNotAllocatorOrIntegral<_Hash>,
@@ -1006,6 +1035,13 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
                  unordered_set<int>::size_type, _Allocator)
     -> unordered_set<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
 
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // 2713. More missing allocator-extended constructors for unordered container
+  template<typename _Tp, typename _Allocator,
+          typename = _RequireAllocator<_Allocator>>
+    unordered_set(initializer_list<_Tp>, _Allocator)
+    -> unordered_set<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
+
   template<typename _Tp, typename _Hash, typename _Allocator,
           typename = _RequireNotAllocatorOrIntegral<_Hash>,
           typename = _RequireAllocator<_Allocator>>
@@ -1223,6 +1259,14 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
       : unordered_multiset(__n, __hf, key_equal(), __a)
       { }
 
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 2713. More missing allocator-extended constructors for unordered container
+      template<typename _InputIterator>
+       unordered_multiset(_InputIterator __first, _InputIterator __last,
+                          const allocator_type& __a)
+       : unordered_multiset(__first, __last, 0, hasher(), key_equal(), __a)
+       { }
+
       template<typename _InputIterator>
        unordered_multiset(_InputIterator __first, _InputIterator __last,
                           size_type __n,
@@ -1237,6 +1281,13 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
        : unordered_multiset(__first, __last, __n, __hf, key_equal(), __a)
        { }
 
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 2713. More missing allocator-extended constructors for unordered container
+      unordered_multiset(initializer_list<value_type> __l,
+                        const allocator_type& __a)
+      : unordered_multiset(__l, 0, hasher(), key_equal(), __a)
+      { }
+
       unordered_multiset(initializer_list<value_type> __l,
                         size_type __n,
                         const allocator_type& __a)
@@ -1949,6 +2000,19 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
                                   iterator_traits<_InputIterator>::value_type>,
                          _Allocator>;
 
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // 2713. More missing allocator-extended constructors for unordered container
+  template<typename _InputIterator, typename _Allocator,
+          typename = _RequireInputIter<_InputIterator>,
+          typename = _RequireAllocator<_Allocator>>
+    unordered_multiset(_InputIterator, _InputIterator, _Allocator)
+    -> unordered_multiset<typename iterator_traits<_InputIterator>::value_type,
+                         hash<typename
+                              iterator_traits<_InputIterator>::value_type>,
+                         equal_to<typename
+                                  iterator_traits<_InputIterator>::value_type>,
+                         _Allocator>;
+
   template<typename _InputIterator, typename _Hash, typename _Allocator,
           typename = _RequireInputIter<_InputIterator>,
           typename = _RequireNotAllocatorOrIntegral<_Hash>,
@@ -1970,6 +2034,13 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
                       unordered_multiset<int>::size_type, _Allocator)
     -> unordered_multiset<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
 
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // 2713. More missing allocator-extended constructors for unordered container
+  template<typename _Tp, typename _Allocator,
+          typename = _RequireAllocator<_Allocator>>
+    unordered_multiset(initializer_list<_Tp>, _Allocator)
+    -> unordered_multiset<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
+
   template<typename _Tp, typename _Hash, typename _Allocator,
           typename = _RequireNotAllocatorOrIntegral<_Hash>,
           typename = _RequireAllocator<_Allocator>>

diff --git a/libstdc++-v3/include/debug/unordered_map b/libstdc++-v3/include/debug/unordered_map
index 448f681e16b2b1a96b79eb2e545a2c3797b2d6e8..7673db10b095b02a7a7d4b9e56d4d87d699c1497 100644 (file)
--- a/libstdc++-v3/include/debug/unordered_map
+++ b/libstdc++-v3/include/debug/unordered_map
@@ -173,6 +173,12 @@ namespace __debug
       : unordered_map(__n, __hf, key_equal(), __a)
       { }
 
+      template<typename _InputIterator>
+       unordered_map(_InputIterator __first, _InputIterator __last,
+                     const allocator_type& __a)
+       : unordered_map(__first, __last, 0, hasher(), key_equal(), __a)
+       { }
+
       template<typename _InputIterator>
        unordered_map(_InputIterator __first, _InputIterator __last,
                      size_type __n,
@@ -188,6 +194,11 @@ namespace __debug
        : unordered_map(__first, __last, __n, __hf, key_equal(), __a)
        { }
 
+      unordered_map(initializer_list<value_type> __l,
+                   const allocator_type& __a)
+      : unordered_map(__l, 0, hasher(), key_equal(), __a)
+      { }
+
       unordered_map(initializer_list<value_type> __l,
                    size_type __n,
                    const allocator_type& __a)
@@ -1051,6 +1062,12 @@ namespace __debug
       : unordered_multimap(__n, __hf, key_equal(), __a)
       { }
 
+      template<typename _InputIterator>
+       unordered_multimap(_InputIterator __first, _InputIterator __last,
+                          const allocator_type& __a)
+       : unordered_multimap(__first, __last, 0, hasher(), key_equal(), __a)
+       { }
+
       template<typename _InputIterator>
        unordered_multimap(_InputIterator __first, _InputIterator __last,
                           size_type __n,
@@ -1065,6 +1082,11 @@ namespace __debug
        : unordered_multimap(__first, __last, __n, __hf, key_equal(), __a)
        { }
 
+      unordered_multimap(initializer_list<value_type> __l,
+                        const allocator_type& __a)
+      : unordered_multimap(__l, 0, hasher(), key_equal(), __a)
+      { }
+
       unordered_multimap(initializer_list<value_type> __l,
                         size_type __n,
                         const allocator_type& __a)

diff --git a/libstdc++-v3/include/debug/unordered_set b/libstdc++-v3/include/debug/unordered_set
index 4255f6ee77000c564fa9a0256b4385ff81edcab2..932600d55e30dcc377ed3a28c5260f081cdb11a1 100644 (file)
--- a/libstdc++-v3/include/debug/unordered_set
+++ b/libstdc++-v3/include/debug/unordered_set
@@ -168,6 +168,12 @@ namespace __debug
       : unordered_set(__n, __hf, key_equal(), __a)
       { }
 
+      template<typename _InputIterator>
+       unordered_set(_InputIterator __first, _InputIterator __last,
+                     const allocator_type& __a)
+       : unordered_set(__first, __last, 0, hasher(), key_equal(), __a)
+       { }
+
       template<typename _InputIterator>
        unordered_set(_InputIterator __first, _InputIterator __last,
                      size_type __n,
@@ -182,6 +188,11 @@ namespace __debug
        : unordered_set(__first, __last, __n, __hf, key_equal(), __a)
        { }
 
+      unordered_set(initializer_list<value_type> __l,
+                   const allocator_type& __a)
+      : unordered_set(__l, 0, hasher(), key_equal(), __a)
+      { }
+
       unordered_set(initializer_list<value_type> __l,
                    size_type __n,
                    const allocator_type& __a)
@@ -713,6 +724,17 @@ namespace __debug
                       typename iterator_traits<_InputIterator>::value_type>,
                     _Allocator>;
 
+  template<typename _InputIterator, typename _Allocator,
+          typename = _RequireInputIter<_InputIterator>,
+          typename = _RequireAllocator<_Allocator>>
+    unordered_set(_InputIterator, _InputIterator, _Allocator)
+    -> unordered_set<typename iterator_traits<_InputIterator>::value_type,
+                    hash<
+                      typename iterator_traits<_InputIterator>::value_type>,
+                    equal_to<
+                      typename iterator_traits<_InputIterator>::value_type>,
+                    _Allocator>;
+
   template<typename _InputIterator, typename _Hash, typename _Allocator,
           typename = _RequireInputIter<_InputIterator>,
           typename = _RequireNotAllocatorOrIntegral<_Hash>,
@@ -732,6 +754,11 @@ namespace __debug
                  unordered_set<int>::size_type, _Allocator)
     -> unordered_set<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
 
+  template<typename _Tp, typename _Allocator,
+          typename = _RequireAllocator<_Allocator>>
+    unordered_set(initializer_list<_Tp>, _Allocator)
+    -> unordered_set<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
+
   template<typename _Tp, typename _Hash, typename _Allocator,
           typename = _RequireNotAllocatorOrIntegral<_Hash>,
           typename = _RequireAllocator<_Allocator>>
@@ -876,6 +903,12 @@ namespace __debug
       : unordered_multiset(__n, __hf, key_equal(), __a)
       { }
 
+      template<typename _InputIterator>
+       unordered_multiset(_InputIterator __first, _InputIterator __last,
+                          const allocator_type& __a)
+       : unordered_multiset(__first, __last, 0, hasher(), key_equal(), __a)
+       { }
+
       template<typename _InputIterator>
        unordered_multiset(_InputIterator __first, _InputIterator __last,
                           size_type __n,
@@ -890,6 +923,11 @@ namespace __debug
        : unordered_multiset(__first, __last, __n, __hf, key_equal(), __a)
        { }
 
+      unordered_multiset(initializer_list<value_type> __l,
+                        const allocator_type& __a)
+      : unordered_multiset(__l, 0, hasher(), key_equal(), __a)
+      { }
+
       unordered_multiset(initializer_list<value_type> __l,
                         size_type __n,
                         const allocator_type& __a)
@@ -1416,6 +1454,17 @@ namespace __debug
                                   iterator_traits<_InputIterator>::value_type>,
                          _Allocator>;
 
+  template<typename _InputIterator, typename _Allocator,
+          typename = _RequireInputIter<_InputIterator>,
+          typename = _RequireAllocator<_Allocator>>
+    unordered_multiset(_InputIterator, _InputIterator, _Allocator)
+    -> unordered_multiset<typename iterator_traits<_InputIterator>::value_type,
+                         hash<typename
+                              iterator_traits<_InputIterator>::value_type>,
+                         equal_to<typename
+                                  iterator_traits<_InputIterator>::value_type>,
+                         _Allocator>;
+
   template<typename _InputIterator, typename _Hash, typename _Allocator,
           typename = _RequireInputIter<_InputIterator>,
           typename = _RequireNotAllocatorOrIntegral<_Hash>,
@@ -1437,6 +1486,11 @@ namespace __debug
                       unordered_multiset<int>::size_type, _Allocator)
     -> unordered_multiset<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
 
+  template<typename _Tp, typename _Allocator,
+          typename = _RequireAllocator<_Allocator>>
+    unordered_multiset(initializer_list<_Tp>, _Allocator)
+    -> unordered_multiset<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
+
   template<typename _Tp, typename _Hash, typename _Allocator,
           typename = _RequireNotAllocatorOrIntegral<_Hash>,
           typename = _RequireAllocator<_Allocator>>

diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/cons/66055.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/cons/66055.cc
index c7a12c14425da9191dc74664af1e1f7551ab5ced..0f95976071382e1197e25ace8121b3fda68110b2 100644 (file)
--- a/libstdc++-v3/testsuite/23_containers/unordered_map/cons/66055.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_map/cons/66055.cc
@@ -27,7 +27,10 @@ using alloc_type = test_type::allocator_type;
 
 test_type h1(10, alloc_type());
 test_type h2(10, hasher_type(), alloc_type());
-test_type h3(h1.begin(), h1.end(), 10, alloc_type());
-test_type h4(h1.begin(), h1.end(), 10, hasher_type(), alloc_type());
-test_type h5({ { 1, 1 } }, 10, alloc_type());
-test_type h6({ { 1, 1 } }, 10, hasher_type(), alloc_type());
+test_type h3(h1.begin(), h1.end(), alloc_type());
+test_type h4(h1.begin(), h1.end(), 10, alloc_type());
+test_type h5(h1.begin(), h1.end(), 10, hasher_type(), alloc_type());
+test_type h6({ { 1, 1 } }, alloc_type());
+test_type h7({ { 1, 1 } }, 10, alloc_type());
+test_type h8({ { 1, 1 } }, 10, hasher_type(), alloc_type());
+

diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/cons/deduction.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/cons/deduction.cc
index 8b69af896a25c09985ba9b1947230e31d10ef02c..fa182f5866d3fe40d3e4732eddcc6fbb22fd368d 100644 (file)
--- a/libstdc++-v3/testsuite/23_containers/unordered_map/cons/deduction.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_map/cons/deduction.cc
@@ -15,12 +15,28 @@ static_assert(std::is_same_v<
                      {2, 3.0}, {3, 4.0}}}),
              std::unordered_map<int, double>>);
 
+static_assert(std::is_same_v<
+             decltype(std::unordered_map{{std::pair{1, 2.0},
+                     {2, 3.0}, {3, 4.0}},
+                   SimpleAllocator<std::pair<const int, double>>{}}),
+             std::unordered_map<int, double, std::hash<int>,
+             std::equal_to<int>,
+             SimpleAllocator<std::pair<const int, double>>>>);
+
 static_assert(std::is_same_v<
              decltype(std::unordered_map{
                {std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
                1}),
              std::unordered_map<int, double>>);
 
+static_assert(std::is_same_v<
+             decltype(std::unordered_map{
+               {std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
+               1, SimpleAllocator<std::pair<const int, double>>{}}),
+             std::unordered_map<int, double, std::hash<int>,
+             std::equal_to<int>,
+             SimpleAllocator<std::pair<const int, double>>>>);
+
 static_assert(std::is_same_v<
              decltype(std::unordered_map{{std::pair{1, 2.0},
                      {2, 3.0}, {3, 4.0}},
@@ -96,6 +112,18 @@ void f()
                std::equal_to<int>,
                SimpleAllocator<std::pair<const int, double>>>>);
 
+  static_assert(std::is_same_v<
+               decltype(std::unordered_map{x.begin(), x.end(),
+                     std::allocator<std::pair<const int, double>>{}}),
+               std::unordered_map<int, double>>);
+
+  static_assert(std::is_same_v<
+               decltype(std::unordered_map{x.begin(), x.end(),
+                     SimpleAllocator<std::pair<const int, double>>{}}),
+               std::unordered_map<int, double, std::hash<int>,
+               std::equal_to<int>,
+               SimpleAllocator<std::pair<const int, double>>>>);
+
   static_assert(std::is_same_v<
                decltype(std::unordered_map{x.begin(), x.end(),
                      1, std::hash<int>{},

diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/66055.cc b/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/66055.cc
index dc0a65196c8b2306fcdb9e2df201795d35199841..eecc60024fe00ba5dcf62985c0506e477483682b 100644 (file)
--- a/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/66055.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/66055.cc
@@ -27,7 +27,9 @@ using alloc_type = test_type::allocator_type;
 
 test_type h1(10, alloc_type());
 test_type h2(10, hasher_type(), alloc_type());
-test_type h3(h1.begin(), h1.end(), 10, alloc_type());
-test_type h4(h1.begin(), h1.end(), 10, hasher_type(), alloc_type());
-test_type h5({ { 1, 1 } }, 10, alloc_type());
-test_type h6({ { 1, 1 } }, 10, hasher_type(), alloc_type());
+test_type h3(h1.begin(), h1.end(), alloc_type());
+test_type h4(h1.begin(), h1.end(), 10, alloc_type());
+test_type h5(h1.begin(), h1.end(), 10, hasher_type(), alloc_type());
+test_type h6({ { 1, 1 } }, alloc_type());
+test_type h7({ { 1, 1 } }, 10, alloc_type());
+test_type h8({ { 1, 1 } }, 10, hasher_type(), alloc_type());

diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/deduction.cc b/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/deduction.cc
index e7e535b527a83b41b47c969553a7a24be05d3fd4..4de23fe3e791eacb1ee0f8befe65ecf7335af425 100644 (file)
--- a/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/deduction.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/deduction.cc
@@ -15,6 +15,28 @@ static_assert(std::is_same_v<
                      {2, 3.0}, {3, 4.0}}}),
              std::unordered_multimap<int, double>>);
 
+static_assert(std::is_same_v<
+             decltype(std::unordered_multimap{
+               {std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
+               SimpleAllocator<std::pair<const int, double>>{}}),
+             std::unordered_multimap<int, double, std::hash<int>,
+             std::equal_to<int>,
+             SimpleAllocator<std::pair<const int, double>>>>);
+
+static_assert(std::is_same_v<
+             decltype(std::unordered_multimap{
+               {std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
+               1}),
+             std::unordered_multimap<int, double>>);
+
+static_assert(std::is_same_v<
+             decltype(std::unordered_multimap{
+               {std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
+               1, SimpleAllocator<std::pair<const int, double>>{}}),
+             std::unordered_multimap<int, double, std::hash<int>,
+             std::equal_to<int>,
+             SimpleAllocator<std::pair<const int, double>>>>);
+
 static_assert(std::is_same_v<
              decltype(std::unordered_multimap{{std::pair{1, 2.0},
                      {2, 3.0}, {3, 4.0}},
@@ -105,6 +127,18 @@ void f()
                std::equal_to<int>,
                SimpleAllocator<std::pair<const int, double>>>>);
 
+  static_assert(std::is_same_v<
+               decltype(std::unordered_multimap{x.begin(), x.end(),
+                     std::allocator<std::pair<const int, double>>{}}),
+               std::unordered_multimap<int, double>>);
+
+  static_assert(std::is_same_v<
+               decltype(std::unordered_multimap{x.begin(), x.end(),
+                     SimpleAllocator<std::pair<const int, double>>{}}),
+               std::unordered_multimap<int, double, std::hash<int>,
+               std::equal_to<int>,
+               SimpleAllocator<std::pair<const int, double>>>>);
+
   static_assert(std::is_same_v<
                decltype(std::unordered_multimap{x.begin(), x.end(),
                      1, std::hash<int>{},

diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/66055.cc b/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/66055.cc
index 5c34b94c00d94ba1ba919422b009e1f37a5e770b..3ba609fc4490dd66e5c3b3e0d1f7f7d3ecccf0f0 100644 (file)
--- a/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/66055.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/66055.cc
@@ -27,7 +27,9 @@ using alloc_type = test_type::allocator_type;
 
 test_type h1(10, alloc_type());
 test_type h2(10, hasher_type(), alloc_type());
-test_type h3(h1.begin(), h1.end(), 10, alloc_type());
-test_type h4(h1.begin(), h1.end(), 10, hasher_type(), alloc_type());
-test_type h5({ 1, 1 }, 10, alloc_type());
-test_type h6({ 1, 1 }, 10, hasher_type(), alloc_type());
+test_type h3(h1.begin(), h1.end(), alloc_type());
+test_type h4(h1.begin(), h1.end(), 10, alloc_type());
+test_type h5(h1.begin(), h1.end(), 10, hasher_type(), alloc_type());
+test_type h6({ 1, 1 }, alloc_type());
+test_type h7({ 1, 1 }, 10, alloc_type());
+test_type h9({ 1, 1 }, 10, hasher_type(), alloc_type());

diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/deduction.cc b/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/deduction.cc
index 22b729749e22adae7a7b1eea8d42c00f13f4b06e..46cd2105accc8b67c634494ed87a8737f2f9d502 100644 (file)
--- a/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/deduction.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/deduction.cc
@@ -19,6 +19,22 @@ static_assert(std::is_same_v<
                    0, std::hash<int>{}, std::allocator<int>{}}),
              std::unordered_multiset<int>>);
 
+static_assert(std::is_same_v<
+             decltype(std::unordered_multiset{{1, 2, 3}}),
+             std::unordered_multiset<int>>);
+
+static_assert(std::is_same_v<
+             decltype(std::unordered_multiset{{1, 2, 3},
+                   std::allocator<int>{}}),
+             std::unordered_multiset<int>>);
+
+static_assert(std::is_same_v<
+             decltype(std::unordered_multiset{{1, 2, 3},
+                   SimpleAllocator<int>{}}),
+             std::unordered_multiset<int, std::hash<int>,
+             std::equal_to<int>,
+             SimpleAllocator<int>>>);
+
 static_assert(std::is_same_v<
              decltype(std::unordered_multiset{{1, 2, 3},
                    {}}),
@@ -86,6 +102,18 @@ void f()
                      {}, std::hash<int>{}, std::equal_to<int>{}}),
                std::unordered_multiset<int>>);
 
+  static_assert(std::is_same_v<
+               decltype(std::unordered_multiset{x.begin(), x.end(),
+                     std::allocator<int>{}}),
+               std::unordered_multiset<int>>);
+
+  static_assert(std::is_same_v<
+               decltype(std::unordered_multiset{x.begin(), x.end(),
+                     SimpleAllocator<int>{}}),
+               std::unordered_multiset<int, std::hash<int>,
+               std::equal_to<int>,
+               SimpleAllocator<int>>>);
+
   static_assert(std::is_same_v<
                decltype(std::unordered_multiset{x.begin(), x.end(),
                      {}, std::hash<int>{}, std::allocator<int>{}}),

diff --git a/libstdc++-v3/testsuite/23_containers/unordered_set/cons/66055.cc b/libstdc++-v3/testsuite/23_containers/unordered_set/cons/66055.cc
index 0d318a04b2be2827a78f67d9857c745215639e8b..96c0ca3be53f570443dc3a80142637c2e163c05f 100644 (file)
--- a/libstdc++-v3/testsuite/23_containers/unordered_set/cons/66055.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_set/cons/66055.cc
@@ -27,7 +27,9 @@ using alloc_type = test_type::allocator_type;
 
 test_type h1(10, alloc_type());
 test_type h2(10, hasher_type(), alloc_type());
-test_type h3(h1.begin(), h1.end(), 10, alloc_type());
-test_type h4(h1.begin(), h1.end(), 10, hasher_type(), alloc_type());
-test_type h5({ 1, 1 }, 10, alloc_type());
-test_type h6({ 1, 1 }, 10, hasher_type(), alloc_type());
+test_type h3(h1.begin(), h1.end(), alloc_type());
+test_type h4(h1.begin(), h1.end(), 10, alloc_type());
+test_type h5(h1.begin(), h1.end(), 10, hasher_type(), alloc_type());
+test_type h6({ 1, 1 }, alloc_type());
+test_type h7({ 1, 1 }, 10, alloc_type());
+test_type h9({ 1, 1 }, 10, hasher_type(), alloc_type());

diff --git a/libstdc++-v3/testsuite/23_containers/unordered_set/cons/deduction.cc b/libstdc++-v3/testsuite/23_containers/unordered_set/cons/deduction.cc
index db5858132fce9be910d352a34b88e84339d9fc37..9558d70505f3466721ca689642ba10898416dbef 100644 (file)
--- a/libstdc++-v3/testsuite/23_containers/unordered_set/cons/deduction.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_set/cons/deduction.cc
@@ -19,6 +19,22 @@ static_assert(std::is_same_v<
                    0, std::hash<int>{}, std::allocator<int>{}}),
              std::unordered_set<int>>);
 
+static_assert(std::is_same_v<
+             decltype(std::unordered_set{{1, 2, 3}}),
+             std::unordered_set<int>>);
+
+static_assert(std::is_same_v<
+             decltype(std::unordered_set{{1, 2, 3},
+                   std::allocator<int>{}}),
+             std::unordered_set<int>>);
+
+static_assert(std::is_same_v<
+             decltype(std::unordered_set{{1, 2, 3},
+                   SimpleAllocator<int>{}}),
+             std::unordered_set<int, std::hash<int>,
+             std::equal_to<int>,
+             SimpleAllocator<int>>>);
+
 static_assert(std::is_same_v<
              decltype(std::unordered_set{{1, 2, 3},
                    {}}),
@@ -91,6 +107,18 @@ void f()
                      {})),
                std::unordered_set<int>>);
 
+  static_assert(std::is_same_v<
+               decltype(std::unordered_set{x.begin(), x.end(),
+                     std::allocator<int>{}}),
+               std::unordered_set<int>>);
+
+  static_assert(std::is_same_v<
+               decltype(std::unordered_set{x.begin(), x.end(),
+                     SimpleAllocator<int>{}}),
+               std::unordered_set<int, std::hash<int>,
+               std::equal_to<int>,
+               SimpleAllocator<int>>>);
+
   static_assert(std::is_same_v<
                decltype(std::unordered_set{x.begin(), x.end(), 1}),
                std::unordered_set<int>>);