Implement P0433: deduction guides for <unordered_map>

[• Quuxplusone]

Summary

(P0433 was adopted into C++17 at Kona 2017.)
This patch incorporates the resolution of LWG 3025.

[• Quuxplusone]

Add <algorithm> header to the tests, for the benefit of libstdc++.

[• Quuxplusone]

Use ASSERT_SAME_TYPE. Add comments to deduct.fail.cpp. Rebase.

[• Quuxplusone]

Mark LWG3025 status "Complete". (Thanks @STL_MSFT for pointing me at that issue!)

[• Quuxplusone]

Rebased on master (well, on D58587).
Add tests for the resolution of LWG 3025.

[• Quuxplusone]

Review comments; remove unnecessary _VSTD:: before remove_const; consistent use of typedefs P and PC to match the corresponding unordered_map tests from D58587.

@mclow.lists: I think this one is ready to land, as well as D58617, although they probably deserve some close scrutiny to make sure the tests are testing the things they should be testing.

I wonder if I should switch from using typename remove_const<T>::type to remove_const_t<T>, since all the deduction guides are compiled only in C++17 mode anyway. If we want to do that, I propose to do it as a separate patch, or at least shortly thereafter to submit a separate patch to consistently use remove_const_t in the <set> and <map> deduction guides.

[ldionne]

Can you test this against Clang trunk and confirm that it works?

[• Quuxplusone]

Use _EnableIf and remove_const_t instead of enable_if and remove_const.
Whitespace diffs.
Preemptively add XFAILs on apple-clang, matching the XFAILs that were needed for unordered_set.

@ldionne ping! I believe this is ready to land.

This completes my patch-series on the topic of "CTAD for associative and unordered containers."

Btw, I've verified that the container adaptors are all done (by Marshall, a while ago). The one place libc++ is known to be still missing deduction guides is std::function ( https://bugs.llvm.org/show_bug.cgi?id=39606 ).

include/unordered_map

 
 private:
 
 #ifdef _LIBCPP_CXX03_LANG
     __node_holder __construct_node_with_key(const key_type& __k);
 #endif
 };
 
+#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
+template<class _InputIterator,
+         class _Hash = hash<__iter_key_type<_InputIterator>>,
+         class _Pred = equal_to<__iter_key_type<_InputIterator>>,
+         class _Allocator = allocator<__iter_to_alloc_type<_InputIterator>>,
+         class = typename enable_if<!__is_allocator<_Hash>::value, void>::type,
+         class = typename enable_if<!is_integral<_Hash>::value, void>::type,
+         class = typename enable_if<!__is_allocator<_Pred>::value, void>::type,
+         class = typename enable_if<__is_allocator<_Allocator>::value, void>::type>
+unordered_map(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type = 0,
+              _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+  -> unordered_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Hash, _Pred, _Allocator>;
+
+template<class _Key, class _Tp, class _Hash = hash<_Key>,
+         class _Pred = equal_to<_Key>, class _Allocator = allocator<pair<const _Key, _Tp>>,
+         class = typename enable_if<!__is_allocator<_Hash>::value, void>::type,
+         class = typename enable_if<!is_integral<_Hash>::value, void>::type,
+         class = typename enable_if<!__is_allocator<_Pred>::value, void>::type,
+         class = typename enable_if<__is_allocator<_Allocator>::value, void>::type>
+unordered_map(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type = 0,
+              _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+  -> unordered_map<_Key, _Tp, _Hash, _Pred, _Allocator>;
+
+template<class _InputIterator, class _Allocator,
+         class = typename enable_if<__is_allocator<_Allocator>::value, void>::type>
+unordered_map(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Allocator)
+  -> unordered_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
+                   hash<__iter_key_type<_InputIterator>>, equal_to<__iter_key_type<_InputIterator>>, _Allocator>;
+
+template<class _InputIterator, class _Allocator,
+         class = typename enable_if<__is_allocator<_Allocator>::value, void>::type>
+unordered_map(_InputIterator, _InputIterator, _Allocator)
+  -> unordered_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
+                   hash<__iter_key_type<_InputIterator>>, equal_to<__iter_key_type<_InputIterator>>, _Allocator>;
+
+template<class _InputIterator, class _Hash, class _Allocator,
+         class = typename enable_if<!__is_allocator<_Hash>::value, void>::type,
+         class = typename enable_if<!is_integral<_Hash>::value, void>::type,
+         class = typename enable_if<__is_allocator<_Allocator>::value, void>::type>
+unordered_map(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
+  -> unordered_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
+                   _Hash, equal_to<__iter_key_type<_InputIterator>>, _Allocator>;
+
+template<class _Key, class _Tp, class _Allocator,
+         class = typename enable_if<__is_allocator<_Allocator>::value, void>::type>
+unordered_map(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type, _Allocator)
+  -> unordered_map<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;
+
+template<class _Key, class _Tp, class _Allocator,
+         class = typename enable_if<__is_allocator<_Allocator>::value, void>::type>
+unordered_map(initializer_list<pair<_Key, _Tp>>, _Allocator)
+  -> unordered_map<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;
+
+template<class _Key, class _Tp, class _Hash, class _Allocator,
+         class = typename enable_if<!__is_allocator<_Hash>::value, void>::type,
+         class = typename enable_if<!is_integral<_Hash>::value, void>::type,
+         class = typename enable_if<__is_allocator<_Allocator>::value, void>::type>
+unordered_map(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
+  -> unordered_map<_Key, _Tp, _Hash, equal_to<_Key>, _Allocator>;
+#endif
+
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
         size_type __n, const hasher& __hf, const key_equal& __eql)
     : __table_(__hf, __eql)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif

     bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const
         {return __table_.__addable(&__i->__i_, __n);}
 
 #endif  // _LIBCPP_DEBUG_LEVEL >= 2
 
 
 };
 
+#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
+template<class _InputIterator,
+         class _Hash = hash<__iter_key_type<_InputIterator>>,
+         class _Pred = equal_to<__iter_key_type<_InputIterator>>,
+         class _Allocator = allocator<__iter_to_alloc_type<_InputIterator>>,
+         class = typename enable_if<!__is_allocator<_Hash>::value, void>::type,
+         class = typename enable_if<!is_integral<_Hash>::value, void>::type,
+         class = typename enable_if<!__is_allocator<_Pred>::value, void>::type,
+         class = typename enable_if<__is_allocator<_Allocator>::value, void>::type>
+unordered_multimap(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type = 0,
+              _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+  -> unordered_multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Hash, _Pred, _Allocator>;
+
+template<class _Key, class _Tp, class _Hash = hash<_Key>,
+         class _Pred = equal_to<_Key>, class _Allocator = allocator<pair<const _Key, _Tp>>,
+         class = typename enable_if<!__is_allocator<_Hash>::value, void>::type,
+         class = typename enable_if<!is_integral<_Hash>::value, void>::type,
+         class = typename enable_if<!__is_allocator<_Pred>::value, void>::type,
+         class = typename enable_if<__is_allocator<_Allocator>::value, void>::type>
+unordered_multimap(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type = 0,
+              _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+  -> unordered_multimap<_Key, _Tp, _Hash, _Pred, _Allocator>;
+
+template<class _InputIterator, class _Allocator,
+         class = typename enable_if<__is_allocator<_Allocator>::value, void>::type>
+unordered_multimap(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Allocator)
+  -> unordered_multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
+                   hash<__iter_key_type<_InputIterator>>, equal_to<__iter_key_type<_InputIterator>>, _Allocator>;
+
+template<class _InputIterator, class _Allocator,
+         class = typename enable_if<__is_allocator<_Allocator>::value, void>::type>
+unordered_multimap(_InputIterator, _InputIterator, _Allocator)
+  -> unordered_multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
+                   hash<__iter_key_type<_InputIterator>>, equal_to<__iter_key_type<_InputIterator>>, _Allocator>;
+
+template<class _InputIterator, class _Hash, class _Allocator,
+         class = typename enable_if<!__is_allocator<_Hash>::value, void>::type,
+         class = typename enable_if<!is_integral<_Hash>::value, void>::type,
+         class = typename enable_if<__is_allocator<_Allocator>::value, void>::type>
+unordered_multimap(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
+  -> unordered_multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
+                   _Hash, equal_to<__iter_key_type<_InputIterator>>, _Allocator>;
+
+template<class _Key, class _Tp, class _Allocator,
+         class = typename enable_if<__is_allocator<_Allocator>::value, void>::type>
+unordered_multimap(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type, _Allocator)
+  -> unordered_multimap<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;
+
+template<class _Key, class _Tp, class _Allocator,
+         class = typename enable_if<__is_allocator<_Allocator>::value, void>::type>
+unordered_multimap(initializer_list<pair<_Key, _Tp>>, _Allocator)
+  -> unordered_multimap<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;
+
+template<class _Key, class _Tp, class _Hash, class _Allocator,
+         class = typename enable_if<!__is_allocator<_Hash>::value, void>::type,
+         class = typename enable_if<!is_integral<_Hash>::value, void>::type,
+         class = typename enable_if<__is_allocator<_Allocator>::value, void>::type>
+unordered_multimap(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
+  -> unordered_multimap<_Key, _Tp, _Hash, equal_to<_Key>, _Allocator>;
+#endif
+
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
         size_type __n, const hasher& __hf, const key_equal& __eql)
     : __table_(__hf, __eql)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif

test/std/containers/unord/unord.map/unord.map.cnstr/deduct.fail.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+// UNSUPPORTED: libcpp-no-deduction-guides
+
+//  template<class InputIterator,
+//           class Hash = hash<iter-key-type<InputIterator>>,
+//           class Pred = equal_to<iter-key-type<InputIterator>>,
+//           class Allocator = allocator<iter-to-alloc-type<InputIterator>>>
+//    unordered_map(InputIterator, InputIterator, typename see below::size_type = see below,
+//                  Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+//      -> unordered_map<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, Hash, Pred,
+//                       Allocator>;
+//
+//  template<class Key, class T, class Hash = hash<Key>,
+//           class Pred = equal_to<Key>, class Allocator = allocator<pair<const Key, T>>>
+//    unordered_map(initializer_list<pair<Key, T>>,
+//                  typename see below::size_type = see below, Hash = Hash(),
+//                  Pred = Pred(), Allocator = Allocator())
+//      -> unordered_map<Key, T, Hash, Pred, Allocator>;
+//
+//  template<class InputIterator, class Allocator>
+//    unordered_map(InputIterator, InputIterator, typename see below::size_type, Allocator)
+//      -> unordered_map<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>,
+//                       hash<iter-key-type<InputIterator>>,
+//                       equal_to<iter-key-type<InputIterator>>, Allocator>;
+//
+//  template<class InputIterator, class Allocator>
+//    unordered_map(InputIterator, InputIterator, Allocator)
+//      -> unordered_map<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>,
+//                       hash<iter-key-type<InputIterator>>,
+//                       equal_to<iter-key-type<InputIterator>>, Allocator>;
+//
+//  template<class InputIterator, class Hash, class Allocator>
+//    unordered_map(InputIterator, InputIterator, typename see below::size_type, Hash, Allocator)
+//      -> unordered_map<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, Hash,
+//                       equal_to<iter-key-type<InputIterator>>, Allocator>;
+//
+//  template<class Key, class T, class Allocator>
+//    unordered_map(initializer_list<pair<Key, T>>, typename see below::size_type,
+//                  Allocator)
+//      -> unordered_map<Key, T, hash<Key>, equal_to<Key>, Allocator>;
+//
+//  template<class Key, class T, class Allocator>
+//    unordered_map(initializer_list<pair<Key, T>>, Allocator)
+//      -> unordered_map<Key, T, hash<Key>, equal_to<Key>, Allocator>;
+//
+//  template<class Key, class T, class Hash, class Allocator>
+//    unordered_map(initializer_list<pair<Key, T>>, typename see below::size_type, Hash,
+//                  Allocator)
+//      -> unordered_map<Key, T, Hash, equal_to<Key>, Allocator>;
+
+#include <climits> // INT_MAX
+#include <type_traits>
+#include <unordered_map>
+
+struct A {};
+
+int main(int, char**)
+{
+    using P = std::pair<const int, int>;
+    {
+        std::unordered_map m; // expected-error{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_map'}}
+    }
+    {
+        std::unordered_map m(42); // expected-error{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_map'}}
+    }
+    {
+        std::unordered_map m(42, std::hash<int>());
+            // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_map'}}
+    }
+    {
+        std::unordered_map m(42, std::hash<int>(), std::equal_to<int>());
+            // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_map'}}
+    }
+    {
+        std::unordered_map m(42, std::hash<int>(), std::equal_to<int>(), std::allocator<P>());
+            // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_map'}}
+    }
+    {
+        std::unordered_map m(std::allocator<P>{});
+            // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_map'}}
+    }
+    {
+        std::unordered_map m(42, std::allocator<P>());
+            // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_map'}}
+    }
+    {
+        std::unordered_map m(42, std::hash<int>(), std::allocator<P>());
+            // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_map'}}
+    }
+
+  return 0;
+}

test/std/containers/unord/unord.map/unord.map.cnstr/deduct.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+// UNSUPPORTED: libcpp-no-deduction-guides
+
+//  template<class InputIterator,
+//           class Hash = hash<iter-key-type<InputIterator>>,
+//           class Pred = equal_to<iter-key-type<InputIterator>>,
+//           class Allocator = allocator<iter-to-alloc-type<InputIterator>>>
+//    unordered_map(InputIterator, InputIterator, typename see below::size_type = see below,
+//                  Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+//      -> unordered_map<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, Hash, Pred,
+//                       Allocator>;
+//
+//  template<class Key, class T, class Hash = hash<Key>,
+//           class Pred = equal_to<Key>, class Allocator = allocator<pair<const Key, T>>>
+//    unordered_map(initializer_list<pair<Key, T>>,
+//                  typename see below::size_type = see below, Hash = Hash(),
+//                  Pred = Pred(), Allocator = Allocator())
+//      -> unordered_map<Key, T, Hash, Pred, Allocator>;
+//
+//  template<class InputIterator, class Allocator>
+//    unordered_map(InputIterator, InputIterator, typename see below::size_type, Allocator)
+//      -> unordered_map<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>,
+//                       hash<iter-key-type<InputIterator>>,
+//                       equal_to<iter-key-type<InputIterator>>, Allocator>;
+//
+//  template<class InputIterator, class Allocator>
+//    unordered_map(InputIterator, InputIterator, Allocator)
+//      -> unordered_map<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>,
+//                       hash<iter-key-type<InputIterator>>,
+//                       equal_to<iter-key-type<InputIterator>>, Allocator>;
+//
+//  template<class InputIterator, class Hash, class Allocator>
+//    unordered_map(InputIterator, InputIterator, typename see below::size_type, Hash, Allocator)
+//      -> unordered_map<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, Hash,
+//                       equal_to<iter-key-type<InputIterator>>, Allocator>;
+//
+//  template<class Key, class T, class Allocator>
+//    unordered_map(initializer_list<pair<Key, T>>, typename see below::size_type,
+//                  Allocator)
+//      -> unordered_map<Key, T, hash<Key>, equal_to<Key>, Allocator>;
+//
+//  template<class Key, class T, class Allocator>
+//    unordered_map(initializer_list<pair<Key, T>>, Allocator)
+//      -> unordered_map<Key, T, hash<Key>, equal_to<Key>, Allocator>;
+//
+//  template<class Key, class T, class Hash, class Allocator>
+//    unordered_map(initializer_list<pair<Key, T>>, typename see below::size_type, Hash,
+//                  Allocator)
+//      -> unordered_map<Key, T, Hash, equal_to<Key>, Allocator>;
+
+#include <cassert>
+#include <climits> // INT_MAX
+#include <type_traits>
+#include <unordered_map>
+
+#include "test_allocator.h"
+
+struct A {
+    friend bool operator<(A, A) { return false; }
+};
+
+int main(int, char**)
+{
+    using P = std::pair<const int, long>;
+    std::pair<const int, long> expected_m[] = { {1,1}, {2,2}, {3,1}, {INT_MAX,1} };
+
+    {
+    const std::pair<int, long> arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
+    std::unordered_map m(std::begin(arr), std::end(arr));
+    static_assert(std::is_same_v<decltype(m), std::unordered_map<int, long>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    }
+
+    {
+    const std::pair<int, long> arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
+    std::unordered_map m(std::begin(arr), std::end(arr), 42);
+    static_assert(std::is_same_v<decltype(m), std::unordered_map<int, long>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    }
+
+    {
+    const std::pair<int, long> arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
+    std::unordered_map m(std::begin(arr), std::end(arr), 42, std::hash<short>());
+    static_assert(std::is_same_v<decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<int>>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    }
+
+    {
+    const std::pair<int, long> arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
+    std::unordered_map m(std::begin(arr), std::end(arr), 42, std::hash<short>(), std::equal_to<>());
+    static_assert(std::is_same_v<decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<>>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    }
+
+    {
+    const std::pair<int, long> arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
+    std::unordered_map m(std::begin(arr), std::end(arr), 42, std::hash<short>(), std::equal_to<>(), test_allocator<P>(0, 41));
+    static_assert(std::is_same_v<decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<>, test_allocator<P>>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    assert(m.get_allocator().get_id() == 41);
+    }
+
+    {
+    std::unordered_map<int, long> source;
+    std::unordered_map m(source); // unordered_map(unordered_map &)
+    static_assert(std::is_same_v<decltype(m), decltype(source)>, "");
+    assert(m.size() == 0);
+    }
+
+    {
+    std::unordered_map<int, long> source;
+    std::unordered_map m{source}; // unordered_map(unordered_map &)
+    static_assert(std::is_same_v<decltype(m), decltype(source)>, "");
+    assert(m.size() == 0);
+    }
+
+    {
+    std::unordered_map<int, long, std::hash<short>, std::equal_to<>, test_allocator<P>> source;
+    test_allocator<P> a(0, 42);
+    std::unordered_map m(source, a); // unordered_map(unordered_map &)
+    static_assert(std::is_same_v<decltype(m), decltype(source)>, "");
+    assert(m.get_allocator().get_id() == 42);
+    assert(m.size() == 0);
+    }
+
+    {
+    std::unordered_map<int, long, std::hash<short>, std::equal_to<>, test_allocator<P>> source;
+    test_allocator<P> a(0, 43);
+    std::unordered_map m{source, a}; // unordered_map(unordered_map &)
+    static_assert(std::is_same_v<decltype(m), decltype(source)>, "");
+    assert(m.get_allocator().get_id() == 43);
+    assert(m.size() == 0);
+    }
+
+    {
+    std::unordered_map m { std::pair{1,1L}, std::pair{2,2L}, std::pair{1,1L}, std::pair{INT_MAX,1L}, std::pair{3,1L} };
+    static_assert(std::is_same_v<decltype(m), std::unordered_map<int, long>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    }
+
+    {
+    std::unordered_map m({ std::pair{1,1L}, std::pair{2,2L}, std::pair{1,1L}, std::pair{INT_MAX,1L}, std::pair{3,1L} }, 42);
+    static_assert(std::is_same_v<decltype(m), std::unordered_map<int, long>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    }
+
+    {
+    std::unordered_map m({ std::pair{1,1L}, std::pair{2,2L}, std::pair{1,1L}, std::pair{INT_MAX,1L}, std::pair{3,1L} }, 42, std::hash<short>());
+    static_assert(std::is_same_v<decltype(m), std::unordered_map<int, long, std::hash<short>>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    }
+
+    {
+    std::unordered_map m({ std::pair{1,1L}, std::pair{2,2L}, std::pair{1,1L}, std::pair{INT_MAX,1L}, std::pair{3,1L} }, 42, std::hash<short>(), std::equal_to<>());
+    static_assert(std::is_same_v<decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<>>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    }
+
+    {
+    std::unordered_map m({ std::pair{1,1L}, std::pair{2,2L}, std::pair{1,1L}, std::pair{INT_MAX,1L}, std::pair{3,1L} }, 42, std::hash<short>(), std::equal_to<>(), test_allocator<P>(0, 44));
+    static_assert(std::is_same_v<decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<>, test_allocator<P>>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    assert(m.get_allocator().get_id() == 44);
+    }
+
+    {
+    const std::pair<int, long> arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
+    std::unordered_map m(std::begin(arr), std::end(arr), 42, test_allocator<P>(0, 45));
+    static_assert(std::is_same_v<decltype(m), std::unordered_map<int, long, std::hash<int>, std::equal_to<int>, test_allocator<P>>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    assert(m.get_allocator().get_id() == 45);
+    }
+
+    {
+    const std::pair<int, long> arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
+    std::unordered_map m(std::begin(arr), std::end(arr), 42, std::hash<short>(), test_allocator<P>(0, 46));
+    static_assert(std::is_same_v<decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<int>, test_allocator<P>>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    assert(m.get_allocator().get_id() == 46);
+    }
+
+    {
+    std::unordered_map m({ std::pair{1,1L}, std::pair{2,2L}, std::pair{1,1L}, std::pair{INT_MAX,1L}, std::pair{3,1L} }, 42, test_allocator<P>(0, 47));
+    static_assert(std::is_same_v<decltype(m), std::unordered_map<int, long, std::hash<int>, std::equal_to<int>, test_allocator<P>>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    assert(m.get_allocator().get_id() == 47);
+    }
+
+    {
+    std::unordered_map m({ std::pair{1,1L}, std::pair{2,2L}, std::pair{1,1L}, std::pair{INT_MAX,1L}, std::pair{3,1L} }, 42, std::hash<short>(), test_allocator<P>(0, 47));
+    static_assert(std::is_same_v<decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<int>, test_allocator<P>>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    assert(m.get_allocator().get_id() == 47);
+    }
+
+  return 0;
+}

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/deduct.fail.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+// UNSUPPORTED: libcpp-no-deduction-guides
+
+//  template<class InputIterator,
+//           class Hash = hash<iter-key-type<InputIterator>>,
+//           class Pred = equal_to<iter-key-type<InputIterator>>,
+//           class Allocator = allocator<iter-to-alloc-type<InputIterator>>>
+//    unordered_multimap(InputIterator, InputIterator, typename see below::size_type = see below,
+//                  Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+//      -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, Hash, Pred,
+//                       Allocator>;
+//
+//  template<class Key, class T, class Hash = hash<Key>,
+//           class Pred = equal_to<Key>, class Allocator = allocator<pair<const Key, T>>>
+//    unordered_multimap(initializer_list<pair<Key, T>>,
+//                  typename see below::size_type = see below, Hash = Hash(),
+//                  Pred = Pred(), Allocator = Allocator())
+//      -> unordered_multimap<Key, T, Hash, Pred, Allocator>;
+//
+//  template<class InputIterator, class Allocator>
+//    unordered_multimap(InputIterator, InputIterator, typename see below::size_type, Allocator)
+//      -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>,
+//                       hash<iter-key-type<InputIterator>>,
+//                       equal_to<iter-key-type<InputIterator>>, Allocator>;
+//
+//  template<class InputIterator, class Allocator>
+//    unordered_multimap(InputIterator, InputIterator, Allocator)
+//      -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>,
+//                       hash<iter-key-type<InputIterator>>,
+//                       equal_to<iter-key-type<InputIterator>>, Allocator>;
+//
+//  template<class InputIterator, class Hash, class Allocator>
+//    unordered_multimap(InputIterator, InputIterator, typename see below::size_type, Hash, Allocator)
+//      -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, Hash,
+//                       equal_to<iter-key-type<InputIterator>>, Allocator>;
+//
+//  template<class Key, class T, class Allocator>
+//    unordered_multimap(initializer_list<pair<Key, T>>, typename see below::size_type,
+//                  Allocator)
+//      -> unordered_multimap<Key, T, hash<Key>, equal_to<Key>, Allocator>;
+//
+//  template<class Key, class T, class Allocator>
+//    unordered_multimap(initializer_list<pair<Key, T>>, Allocator)
+//      -> unordered_multimap<Key, T, hash<Key>, equal_to<Key>, Allocator>;
+//
+//  template<class Key, class T, class Hash, class Allocator>
+//    unordered_multimap(initializer_list<pair<Key, T>>, typename see below::size_type, Hash,
+//                  Allocator)
+//      -> unordered_multimap<Key, T, Hash, equal_to<Key>, Allocator>;
+
+#include <climits> // INT_MAX
+#include <type_traits>
+#include <unordered_map>
+
+struct A {};
+
+int main(int, char**)
+{
+    using P = std::pair<const int, int>;
+    {
+        std::unordered_multimap m; // expected-error{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multimap'}}
+    }
+    {
+        std::unordered_multimap m(42); // expected-error{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multimap'}}
+    }
+    {
+        std::unordered_multimap m(42, std::hash<int>());
+            // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multimap'}}
+    }
+    {
+        std::unordered_multimap m(42, std::hash<int>(), std::equal_to<int>());
+            // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multimap'}}
+    }
+    {
+        std::unordered_multimap m(42, std::hash<int>(), std::equal_to<int>(), std::allocator<P>());
+            // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multimap'}}
+    }
+    {
+        std::unordered_multimap m(std::allocator<P>{});
+            // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multimap'}}
+    }
+    {
+        std::unordered_multimap m(42, std::allocator<P>());
+            // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multimap'}}
+    }
+    {
+        std::unordered_multimap m(42, std::hash<int>(), std::allocator<P>());
+            // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multimap'}}
+    }
+
+  return 0;
+}

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/deduct.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+// UNSUPPORTED: libcpp-no-deduction-guides
+
+//  template<class InputIterator,
+//           class Hash = hash<iter-key-type<InputIterator>>,
+//           class Pred = equal_to<iter-key-type<InputIterator>>,
+//           class Allocator = allocator<iter-to-alloc-type<InputIterator>>>
+//    unordered_multimap(InputIterator, InputIterator, typename see below::size_type = see below,
+//                  Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+//      -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, Hash, Pred,
+//                       Allocator>;
+//
+//  template<class Key, class T, class Hash = hash<Key>,
+//           class Pred = equal_to<Key>, class Allocator = allocator<pair<const Key, T>>>
+//    unordered_multimap(initializer_list<pair<Key, T>>,
+//                  typename see below::size_type = see below, Hash = Hash(),
+//                  Pred = Pred(), Allocator = Allocator())
+//      -> unordered_multimap<Key, T, Hash, Pred, Allocator>;
+//
+//  template<class InputIterator, class Allocator>
+//    unordered_multimap(InputIterator, InputIterator, typename see below::size_type, Allocator)
+//      -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>,
+//                       hash<iter-key-type<InputIterator>>,
+//                       equal_to<iter-key-type<InputIterator>>, Allocator>;
+//
+//  template<class InputIterator, class Allocator>
+//    unordered_multimap(InputIterator, InputIterator, Allocator)
+//      -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>,
+//                       hash<iter-key-type<InputIterator>>,
+//                       equal_to<iter-key-type<InputIterator>>, Allocator>;
+//
+//  template<class InputIterator, class Hash, class Allocator>
+//    unordered_multimap(InputIterator, InputIterator, typename see below::size_type, Hash, Allocator)
+//      -> unordered_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, Hash,
+//                       equal_to<iter-key-type<InputIterator>>, Allocator>;
+//
+//  template<class Key, class T, class Allocator>
+//    unordered_multimap(initializer_list<pair<Key, T>>, typename see below::size_type,
+//                  Allocator)
+//      -> unordered_multimap<Key, T, hash<Key>, equal_to<Key>, Allocator>;
+//
+//  template<class Key, class T, class Allocator>
+//    unordered_multimap(initializer_list<pair<Key, T>>, Allocator)
+//      -> unordered_multimap<Key, T, hash<Key>, equal_to<Key>, Allocator>;
+//
+//  template<class Key, class T, class Hash, class Allocator>
+//    unordered_multimap(initializer_list<pair<Key, T>>, typename see below::size_type, Hash,
+//                  Allocator)
+//      -> unordered_multimap<Key, T, Hash, equal_to<Key>, Allocator>;
+
+#include <cassert>
+#include <climits> // INT_MAX
+#include <type_traits>
+#include <unordered_map>
+
+#include "test_allocator.h"
+
+struct A {
+    friend bool operator<(A, A) { return false; }
+};
+
+int main(int, char**)
+{
+    using P = std::pair<const int, long>;
+    std::pair<const int, long> expected_m[] = { {1,1}, {1,1}, {2,2}, {3,1}, {INT_MAX,1} };
+
+    {
+    const std::pair<int, long> arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
+    std::unordered_multimap m(std::begin(arr), std::end(arr));
+    static_assert(std::is_same_v<decltype(m), std::unordered_multimap<int, long>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    }
+
+    {
+    const std::pair<int, long> arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
+    std::unordered_multimap m(std::begin(arr), std::end(arr), 42);
+    static_assert(std::is_same_v<decltype(m), std::unordered_multimap<int, long>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    }
+
+    {
+    const std::pair<int, long> arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
+    std::unordered_multimap m(std::begin(arr), std::end(arr), 42, std::hash<short>());
+    static_assert(std::is_same_v<decltype(m), std::unordered_multimap<int, long, std::hash<short>, std::equal_to<int>>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    }
+
+    {
+    const std::pair<int, long> arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
+    std::unordered_multimap m(std::begin(arr), std::end(arr), 42, std::hash<short>(), std::equal_to<>());
+    static_assert(std::is_same_v<decltype(m), std::unordered_multimap<int, long, std::hash<short>, std::equal_to<>>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    }
+
+    {
+    const std::pair<int, long> arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
+    std::unordered_multimap m(std::begin(arr), std::end(arr), 42, std::hash<short>(), std::equal_to<>(), test_allocator<P>(0, 41));
+    static_assert(std::is_same_v<decltype(m), std::unordered_multimap<int, long, std::hash<short>, std::equal_to<>, test_allocator<P>>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    assert(m.get_allocator().get_id() == 41);
+    }
+
+    {
+    std::unordered_multimap<int, long> source;
+    std::unordered_multimap m(source); // unordered_multimap(unordered_multimap &)
+    static_assert(std::is_same_v<decltype(m), decltype(source)>, "");
+    assert(m.size() == 0);
+    }
+
+    {
+    std::unordered_multimap<int, long> source;
+    std::unordered_multimap m{source}; // unordered_multimap(unordered_multimap &)
+    static_assert(std::is_same_v<decltype(m), decltype(source)>, "");
+    assert(m.size() == 0);
+    }
+
+    {
+    std::unordered_multimap<int, long, std::hash<short>, std::equal_to<>, test_allocator<P>> source;
+    test_allocator<P> a(0, 42);
+    std::unordered_multimap m(source, a); // unordered_multimap(unordered_multimap &)
+    static_assert(std::is_same_v<decltype(m), decltype(source)>, "");
+    assert(m.get_allocator().get_id() == 42);
+    assert(m.size() == 0);
+    }
+
+    {
+    std::unordered_multimap<int, long, std::hash<short>, std::equal_to<>, test_allocator<P>> source;
+    test_allocator<P> a(0, 43);
+    std::unordered_multimap m{source, a}; // unordered_multimap(unordered_multimap &)
+    static_assert(std::is_same_v<decltype(m), decltype(source)>, "");
+    assert(m.get_allocator().get_id() == 43);
+    assert(m.size() == 0);
+    }
+
+    {
+    std::unordered_multimap m { std::pair{1,1L}, std::pair{2,2L}, std::pair{1,1L}, std::pair{INT_MAX,1L}, std::pair{3,1L} };
+    static_assert(std::is_same_v<decltype(m), std::unordered_multimap<int, long>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    }
+
+    {
+    std::unordered_multimap m({ std::pair{1,1L}, std::pair{2,2L}, std::pair{1,1L}, std::pair{INT_MAX,1L}, std::pair{3,1L} }, 42);
+    static_assert(std::is_same_v<decltype(m), std::unordered_multimap<int, long>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    }
+
+    {
+    std::unordered_multimap m({ std::pair{1,1L}, std::pair{2,2L}, std::pair{1,1L}, std::pair{INT_MAX,1L}, std::pair{3,1L} }, 42, std::hash<short>());
+    static_assert(std::is_same_v<decltype(m), std::unordered_multimap<int, long, std::hash<short>>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    }
+
+    {
+    std::unordered_multimap m({ std::pair{1,1L}, std::pair{2,2L}, std::pair{1,1L}, std::pair{INT_MAX,1L}, std::pair{3,1L} }, 42, std::hash<short>(), std::equal_to<>());
+    static_assert(std::is_same_v<decltype(m), std::unordered_multimap<int, long, std::hash<short>, std::equal_to<>>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    }
+
+    {
+    std::unordered_multimap m({ std::pair{1,1L}, std::pair{2,2L}, std::pair{1,1L}, std::pair{INT_MAX,1L}, std::pair{3,1L} }, 42, std::hash<short>(), std::equal_to<>(), test_allocator<P>(0, 44));
+    static_assert(std::is_same_v<decltype(m), std::unordered_multimap<int, long, std::hash<short>, std::equal_to<>, test_allocator<P>>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    assert(m.get_allocator().get_id() == 44);
+    }
+
+    {
+    const std::pair<int, long> arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
+    std::unordered_multimap m(std::begin(arr), std::end(arr), 42, test_allocator<P>(0, 45));
+    static_assert(std::is_same_v<decltype(m), std::unordered_multimap<int, long, std::hash<int>, std::equal_to<int>, test_allocator<P>>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    assert(m.get_allocator().get_id() == 45);
+    }
+
+    {
+    const std::pair<int, long> arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
+    std::unordered_multimap m(std::begin(arr), std::end(arr), 42, std::hash<short>(), test_allocator<P>(0, 46));
+    static_assert(std::is_same_v<decltype(m), std::unordered_multimap<int, long, std::hash<short>, std::equal_to<int>, test_allocator<P>>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    assert(m.get_allocator().get_id() == 46);
+    }
+
+    {
+    std::unordered_multimap m({ std::pair{1,1L}, std::pair{2,2L}, std::pair{1,1L}, std::pair{INT_MAX,1L}, std::pair{3,1L} }, 42, test_allocator<P>(0, 47));
+    static_assert(std::is_same_v<decltype(m), std::unordered_multimap<int, long, std::hash<int>, std::equal_to<int>, test_allocator<P>>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    assert(m.get_allocator().get_id() == 47);
+    }
+
+    {
+    std::unordered_multimap m({ std::pair{1,1L}, std::pair{2,2L}, std::pair{1,1L}, std::pair{INT_MAX,1L}, std::pair{3,1L} }, 42, std::hash<short>(), test_allocator<P>(0, 47));
+    static_assert(std::is_same_v<decltype(m), std::unordered_multimap<int, long, std::hash<short>, std::equal_to<int>, test_allocator<P>>>, "");
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    assert(m.get_allocator().get_id() == 47);
+    }
+
+  return 0;
+}