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 ).

libcxx/trunk/include/unordered_map

 template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>,
           class _Alloc = allocator<pair<const _Key, _Tp> > >
 class _LIBCPP_TEMPLATE_VIS unordered_map
 {
 public:
     // types
     typedef _Key                                           key_type;
     typedef _Tp                                            mapped_type;
-    typedef _Hash                                          hasher;
-    typedef _Pred                                          key_equal;
-    typedef _Alloc                                         allocator_type;
+    typedef typename __identity<_Hash>::type               hasher;
+    typedef typename __identity<_Pred>::type               key_equal;
+    typedef typename __identity<_Alloc>::type              allocator_type;
     typedef pair<const key_type, mapped_type>              value_type;
     typedef value_type&                                    reference;
     typedef const value_type&                              const_reference;
     static_assert((is_same<value_type, typename allocator_type::value_type>::value),
                   "Invalid allocator::value_type");
 
 private:
     typedef __hash_value_type<key_type, mapped_type>                 __value_type;

 
 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 = _EnableIf<!__is_allocator<_Hash>::value>,
+         class = _EnableIf<!is_integral<_Hash>::value>,
+         class = _EnableIf<!__is_allocator<_Pred>::value>,
+         class = _EnableIf<__is_allocator<_Allocator>::value>>
+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<remove_const_t<_Key>>,
+         class _Pred = equal_to<remove_const_t<_Key>>,
+         class _Allocator = allocator<pair<const _Key, _Tp>>,
+         class = _EnableIf<!__is_allocator<_Hash>::value>,
+         class = _EnableIf<!is_integral<_Hash>::value>,
+         class = _EnableIf<!__is_allocator<_Pred>::value>,
+         class = _EnableIf<__is_allocator<_Allocator>::value>>
+unordered_map(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type = 0,
+              _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+  -> unordered_map<remove_const_t<_Key>, _Tp, _Hash, _Pred, _Allocator>;
+
+template<class _InputIterator, class _Allocator,
+         class = _EnableIf<__is_allocator<_Allocator>::value>>
+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 = _EnableIf<__is_allocator<_Allocator>::value>>
+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 = _EnableIf<!__is_allocator<_Hash>::value>,
+         class = _EnableIf<!is_integral<_Hash>::value>,
+         class = _EnableIf<__is_allocator<_Allocator>::value>>
+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 = _EnableIf<__is_allocator<_Allocator>::value>>
+unordered_map(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type, _Allocator)
+  -> unordered_map<remove_const_t<_Key>, _Tp,
+                   hash<remove_const_t<_Key>>,
+                   equal_to<remove_const_t<_Key>>, _Allocator>;
+
+template<class _Key, class _Tp, class _Allocator,
+         class = _EnableIf<__is_allocator<_Allocator>::value>>
+unordered_map(initializer_list<pair<_Key, _Tp>>, _Allocator)
+  -> unordered_map<remove_const_t<_Key>, _Tp,
+                   hash<remove_const_t<_Key>>,
+                   equal_to<remove_const_t<_Key>>, _Allocator>;
+
+template<class _Key, class _Tp, class _Hash, class _Allocator,
+         class = _EnableIf<!__is_allocator<_Hash>::value>,
+         class = _EnableIf<!is_integral<_Hash>::value>,
+         class = _EnableIf<__is_allocator<_Allocator>::value>>
+unordered_map(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
+  -> unordered_map<remove_const_t<_Key>, _Tp, _Hash,
+                   equal_to<remove_const_t<_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

 template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>,
           class _Alloc = allocator<pair<const _Key, _Tp> > >
 class _LIBCPP_TEMPLATE_VIS unordered_multimap
 {
 public:
     // types
     typedef _Key                                           key_type;
     typedef _Tp                                            mapped_type;
-    typedef _Hash                                          hasher;
-    typedef _Pred                                          key_equal;
-    typedef _Alloc                                         allocator_type;
+    typedef typename __identity<_Hash>::type               hasher;
+    typedef typename __identity<_Pred>::type               key_equal;
+    typedef typename __identity<_Alloc>::type              allocator_type;
     typedef pair<const key_type, mapped_type>              value_type;
     typedef value_type&                                    reference;
     typedef const value_type&                              const_reference;
     static_assert((is_same<value_type, typename allocator_type::value_type>::value),
                   "Invalid allocator::value_type");
 
 private:
     typedef __hash_value_type<key_type, mapped_type>                 __value_type;
#if _LIBCPP_DEBUG_LEVEL >= 2
     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 = _EnableIf<!__is_allocator<_Hash>::value>,
+         class = _EnableIf<!is_integral<_Hash>::value>,
+         class = _EnableIf<!__is_allocator<_Pred>::value>,
+         class = _EnableIf<__is_allocator<_Allocator>::value>>
+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<remove_const_t<_Key>>,
+         class _Pred = equal_to<remove_const_t<_Key>>,
+         class _Allocator = allocator<pair<const _Key, _Tp>>,
+         class = _EnableIf<!__is_allocator<_Hash>::value>,
+         class = _EnableIf<!is_integral<_Hash>::value>,
+         class = _EnableIf<!__is_allocator<_Pred>::value>,
+         class = _EnableIf<__is_allocator<_Allocator>::value>>
+unordered_multimap(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type = 0,
+                   _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+  -> unordered_multimap<remove_const_t<_Key>, _Tp, _Hash, _Pred, _Allocator>;
+
+template<class _InputIterator, class _Allocator,
+         class = _EnableIf<__is_allocator<_Allocator>::value>>
+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 = _EnableIf<__is_allocator<_Allocator>::value>>
+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 = _EnableIf<!__is_allocator<_Hash>::value>,
+         class = _EnableIf<!is_integral<_Hash>::value>,
+         class = _EnableIf<__is_allocator<_Allocator>::value>>
+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 = _EnableIf<__is_allocator<_Allocator>::value>>
+unordered_multimap(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type, _Allocator)
+  -> unordered_multimap<remove_const_t<_Key>, _Tp,
+                        hash<remove_const_t<_Key>>,
+                        equal_to<remove_const_t<_Key>>, _Allocator>;
+
+template<class _Key, class _Tp, class _Allocator,
+         class = _EnableIf<__is_allocator<_Allocator>::value>>
+unordered_multimap(initializer_list<pair<_Key, _Tp>>, _Allocator)
+  -> unordered_multimap<remove_const_t<_Key>, _Tp,
+                        hash<remove_const_t<_Key>>,
+                        equal_to<remove_const_t<_Key>>, _Allocator>;
+
+template<class _Key, class _Tp, class _Hash, class _Allocator,
+         class = _EnableIf<!__is_allocator<_Hash>::value>,
+         class = _EnableIf<!is_integral<_Hash>::value>,
+         class = _EnableIf<__is_allocator<_Allocator>::value>>
+unordered_multimap(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
+  -> unordered_multimap<remove_const_t<_Key>, _Tp, _Hash,
+                        equal_to<remove_const_t<_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

libcxx/trunk/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
+// XFAIL: clang-6, apple-clang-9.0, apple-clang-9.1, apple-clang-10.0
+
+// 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 <functional>
+#include <unordered_map>
+
+int main(int, char**)
+{
+    using P = std::pair<const int, int>;
+    {
+        // cannot deduce Key from nothing
+        std::unordered_map m; // expected-error{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_map'}}
+    }
+    {
+        // cannot deduce Key from just (Size)
+        std::unordered_map m(42); // expected-error{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_map'}}
+    }
+    {
+        // cannot deduce Key from just (Size, Hash)
+        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'}}
+    }
+    {
+        // cannot deduce Key from just (Size, Hash, Pred)
+        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'}}
+    }
+    {
+        // cannot deduce Key from just (Size, Hash, Pred, Allocator)
+        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'}}
+    }
+    {
+        // cannot deduce Key from just (Allocator)
+        std::unordered_map m(std::allocator<P>{});
+            // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_map'}}
+    }
+    {
+        // cannot deduce Key from just (Size, Allocator)
+        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'}}
+    }
+    {
+        // cannot deduce Key from just (Size, Hash, Allocator)
+        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;
+}

libcxx/trunk/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 <algorithm> // is_permutation
+#include <cassert>
+#include <climits> // INT_MAX
+#include <type_traits>
+#include <unordered_map>
+
+#include "test_allocator.h"
+
+using P = std::pair<int, long>;
+using PC = std::pair<const int, long>;
+
+int main(int, char**)
+{
+    const PC expected_m[] = { {1,1}, {2,2}, {3,1}, {INT_MAX,1} };
+
+    {
+    const P arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
+    std::unordered_map m(std::begin(arr), std::end(arr));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long>);
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    }
+
+    {
+    const P arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
+    std::unordered_map m(std::begin(arr), std::end(arr), 42);
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long>);
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    }
+
+    {
+    const P 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>());
+    ASSERT_SAME_TYPE(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 P 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<>());
+    ASSERT_SAME_TYPE(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 P 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<PC>(0, 41));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<>, test_allocator<PC>>);
+    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);
+    ASSERT_SAME_TYPE(decltype(m), decltype(source));
+    assert(m.size() == 0);
+    }
+
+    {
+    std::unordered_map<int, long> source;
+    std::unordered_map m{source};  // braces instead of parens
+    ASSERT_SAME_TYPE(decltype(m), decltype(source));
+    assert(m.size() == 0);
+    }
+
+    {
+    std::unordered_map<int, long, std::hash<short>, std::equal_to<>, test_allocator<PC>> source;
+    test_allocator<PC> a(0, 42);
+    std::unordered_map m(source, a);
+    ASSERT_SAME_TYPE(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<PC>> source;
+    test_allocator<PC> a(0, 43);
+    std::unordered_map m{source, a};  // braces instead of parens
+    ASSERT_SAME_TYPE(decltype(m), decltype(source));
+    assert(m.get_allocator().get_id() == 43);
+    assert(m.size() == 0);
+    }
+
+    {
+    std::unordered_map m { P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} };
+    ASSERT_SAME_TYPE(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({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42);
+    ASSERT_SAME_TYPE(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({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, std::hash<short>());
+    ASSERT_SAME_TYPE(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({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, std::hash<short>(), std::equal_to<>());
+    ASSERT_SAME_TYPE(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({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, std::hash<short>(), std::equal_to<>(), test_allocator<PC>(0, 44));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<>, test_allocator<PC>>);
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    assert(m.get_allocator().get_id() == 44);
+    }
+
+    {
+    const P 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<PC>(0, 45));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<int>, std::equal_to<int>, test_allocator<PC>>);
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    assert(m.get_allocator().get_id() == 45);
+    }
+
+    {
+    const P 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<PC>(0, 46));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<int>, test_allocator<PC>>);
+    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({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, test_allocator<PC>(0, 47));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<int>, std::equal_to<int>, test_allocator<PC>>);
+    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({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, std::hash<short>(), test_allocator<PC>(0, 48));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<int>, test_allocator<PC>>);
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    assert(m.get_allocator().get_id() == 48);
+    }
+
+    return 0;
+}

libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/deduct_const.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 <algorithm> // std::is_permutation
+#include <cassert>
+#include <climits> // INT_MAX
+#include <type_traits>
+#include <unordered_map>
+
+#include "test_allocator.h"
+
+using P = std::pair<int, long>;
+using PC = std::pair<const int, long>;
+
+int main(int, char**)
+{
+    const PC expected_m[] = { {1,1L}, {2,2L}, {3,1L}, {INT_MAX,1L} };
+
+    {
+    const PC arr[] = { {1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} };
+    std::unordered_map m(std::begin(arr), std::end(arr));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long>);
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    }
+
+    {
+    const PC arr[] = { {1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} };
+    std::unordered_map m(std::begin(arr), std::end(arr), 42);
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long>);
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    }
+
+    {
+    const PC arr[] = { {1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} };
+    std::unordered_map m(std::begin(arr), std::end(arr), 42, std::hash<short>());
+    ASSERT_SAME_TYPE(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 PC arr[] = { {1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} };
+    std::unordered_map m(std::begin(arr), std::end(arr), 42, std::hash<short>(), std::equal_to<>());
+    ASSERT_SAME_TYPE(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 PC arr[] = { {1,1L}, {2,2L}, {1,1L}, {INT_MAX,1L}, {3,1L} };
+    std::unordered_map m(std::begin(arr), std::end(arr), 42, std::hash<short>(), std::equal_to<>(), test_allocator<PC>(0, 41));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<>, test_allocator<PC>>);
+    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 m { PC{1,1L}, PC{2,2L}, PC{1,1L}, PC{INT_MAX,1L}, PC{3,1L} };
+    ASSERT_SAME_TYPE(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({ PC{1,1L}, PC{2,2L}, PC{1,1L}, PC{INT_MAX,1L}, PC{3,1L} }, 42);
+    ASSERT_SAME_TYPE(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({ PC{1,1L}, PC{2,2L}, PC{1,1L}, PC{INT_MAX,1L}, PC{3,1L} }, 42, std::hash<short>());
+    ASSERT_SAME_TYPE(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({ PC{1,1L}, PC{2,2L}, PC{1,1L}, PC{INT_MAX,1L}, PC{3,1L} }, 42, std::hash<short>(), std::equal_to<>());
+    ASSERT_SAME_TYPE(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({ PC{1,1L}, PC{2,2L}, PC{1,1L}, PC{INT_MAX,1L}, PC{3,1L} }, 42, std::hash<short>(), std::equal_to<>(), test_allocator<PC>(0, 44));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<>, test_allocator<PC>>);
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    assert(m.get_allocator().get_id() == 44);
+    }
+
+    {
+    const PC 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<PC>(0, 45));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<int>, std::equal_to<int>, test_allocator<PC>>);
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    assert(m.get_allocator().get_id() == 45);
+    }
+
+    {
+    const PC 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<PC>(0, 46));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<int>, test_allocator<PC>>);
+    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({ PC{1,1L}, PC{2,2L}, PC{1,1L}, PC{INT_MAX,1L}, PC{3,1L} }, 42, test_allocator<PC>(0, 47));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<int>, std::equal_to<int>, test_allocator<PC>>);
+    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({ PC{1,1L}, PC{2,2L}, PC{1,1L}, PC{INT_MAX,1L}, PC{3,1L} }, 42, std::hash<short>(), test_allocator<PC>(0, 48));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<int>, test_allocator<PC>>);
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    assert(m.get_allocator().get_id() == 48);
+    }
+
+    return 0;
+}

libcxx/trunk/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
+// XFAIL: clang-6, apple-clang-9.0, apple-clang-9.1, apple-clang-10.0
+
+// 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 <functional>
+#include <unordered_map>
+
+int main(int, char**)
+{
+    using P = std::pair<const int, int>;
+    {
+        // cannot deduce Key from nothing
+        std::unordered_multimap m; // expected-error{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multimap'}}
+    }
+    {
+        // cannot deduce Key from just (Size)
+        std::unordered_multimap m(42); // expected-error{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multimap'}}
+    }
+    {
+        // cannot deduce Key from just (Size, Hash)
+        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'}}
+    }
+    {
+        // cannot deduce Key from just (Size, Hash, Pred)
+        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'}}
+    }
+    {
+        // cannot deduce Key from just (Size, Hash, Pred, Allocator)
+        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'}}
+    }
+    {
+        // cannot deduce Key from just (Allocator)
+        std::unordered_multimap m(std::allocator<P>{});
+            // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'unordered_multimap'}}
+    }
+    {
+        // cannot deduce Key from just (Size, Allocator)
+        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'}}
+    }
+    {
+        // cannot deduce Key from just (Size, Hash, Allocator)
+        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;
+}

libcxx/trunk/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 <algorithm> // is_permutation
+#include <cassert>
+#include <climits> // INT_MAX
+#include <type_traits>
+#include <unordered_map>
+
+#include "test_allocator.h"
+
+using P = std::pair<int, long>;
+using PC = std::pair<const int, long>;
+
+int main(int, char**)
+{
+    const PC expected_m[] = { {1,1}, {1,1}, {2,2}, {3,1}, {INT_MAX,1} };
+
+    {
+    const P arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
+    std::unordered_multimap m(std::begin(arr), std::end(arr));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_multimap<int, long>);
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    }
+
+    {
+    const P arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
+    std::unordered_multimap m(std::begin(arr), std::end(arr), 42);
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_multimap<int, long>);
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    }
+
+    {
+    const P 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>());
+    ASSERT_SAME_TYPE(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 P 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<>());
+    ASSERT_SAME_TYPE(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 P 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<PC>(0, 41));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_multimap<int, long, std::hash<short>, std::equal_to<>, test_allocator<PC>>);
+    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);
+    ASSERT_SAME_TYPE(decltype(m), decltype(source));
+    assert(m.size() == 0);
+    }
+
+    {
+    std::unordered_multimap<int, long> source;
+    std::unordered_multimap m{source};  // braces instead of parens
+    ASSERT_SAME_TYPE(decltype(m), decltype(source));
+    assert(m.size() == 0);
+    }
+
+    {
+    std::unordered_multimap<int, long, std::hash<short>, std::equal_to<>, test_allocator<PC>> source;
+    test_allocator<PC> a(0, 42);
+    std::unordered_multimap m(source, a);
+    ASSERT_SAME_TYPE(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<PC>> source;
+    test_allocator<PC> a(0, 43);
+    std::unordered_multimap m{source, a};  // braces instead of parens
+    ASSERT_SAME_TYPE(decltype(m), decltype(source));
+    assert(m.get_allocator().get_id() == 43);
+    assert(m.size() == 0);
+    }
+
+    {
+    std::unordered_multimap m { P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} };
+    ASSERT_SAME_TYPE(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({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42);
+    ASSERT_SAME_TYPE(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({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, std::hash<short>());
+    ASSERT_SAME_TYPE(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({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, std::hash<short>(), std::equal_to<>());
+    ASSERT_SAME_TYPE(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({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, std::hash<short>(), std::equal_to<>(), test_allocator<PC>(0, 44));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_multimap<int, long, std::hash<short>, std::equal_to<>, test_allocator<PC>>);
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    assert(m.get_allocator().get_id() == 44);
+    }
+
+    {
+    const P 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<PC>(0, 45));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_multimap<int, long, std::hash<int>, std::equal_to<int>, test_allocator<PC>>);
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    assert(m.get_allocator().get_id() == 45);
+    }
+
+    {
+    const P 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<PC>(0, 46));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_multimap<int, long, std::hash<short>, std::equal_to<int>, test_allocator<PC>>);
+    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({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, test_allocator<PC>(0, 47));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_multimap<int, long, std::hash<int>, std::equal_to<int>, test_allocator<PC>>);
+    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({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, std::hash<short>(), test_allocator<PC>(0, 48));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_multimap<int, long, std::hash<short>, std::equal_to<int>, test_allocator<PC>>);
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    assert(m.get_allocator().get_id() == 48);
+    }
+
+    return 0;
+}

libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/deduct_const.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 <algorithm> // is_permutation
+#include <cassert>
+#include <climits> // INT_MAX
+#include <functional>
+#include <type_traits>
+#include <unordered_map>
+
+#include "test_allocator.h"
+
+using P = std::pair<int, long>;
+using PC = std::pair<const int, long>;
+
+int main(int, char**)
+{
+    const PC expected_m[] = { {1,1}, {1,1}, {2,2}, {3,1}, {INT_MAX,1} };
+
+    {
+    const PC arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
+    std::unordered_multimap m(std::begin(arr), std::end(arr));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_multimap<int, long>);
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    }
+
+    {
+    const PC arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
+    std::unordered_multimap m(std::begin(arr), std::end(arr), 42);
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_multimap<int, long>);
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    }
+
+    {
+    const PC 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>());
+    ASSERT_SAME_TYPE(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 PC 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<>());
+    ASSERT_SAME_TYPE(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 PC 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<PC>(0, 41));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_multimap<int, long, std::hash<short>, std::equal_to<>, test_allocator<PC>>);
+    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 m { PC{1,1L}, PC{2,2L}, PC{1,1L}, PC{INT_MAX,1L}, PC{3,1L} };
+    ASSERT_SAME_TYPE(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({ PC{1,1L}, PC{2,2L}, PC{1,1L}, PC{INT_MAX,1L}, PC{3,1L} }, 42);
+    ASSERT_SAME_TYPE(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({ PC{1,1L}, PC{2,2L}, PC{1,1L}, PC{INT_MAX,1L}, PC{3,1L} }, 42, std::hash<short>());
+    ASSERT_SAME_TYPE(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({ PC{1,1L}, PC{2,2L}, PC{1,1L}, PC{INT_MAX,1L}, PC{3,1L} }, 42, std::hash<short>(), std::equal_to<>());
+    ASSERT_SAME_TYPE(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({ PC{1,1L}, PC{2,2L}, PC{1,1L}, PC{INT_MAX,1L}, PC{3,1L} }, 42, std::hash<short>(), std::equal_to<>(), test_allocator<PC>(0, 44));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_multimap<int, long, std::hash<short>, std::equal_to<>, test_allocator<PC>>);
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    assert(m.get_allocator().get_id() == 44);
+    }
+
+    {
+    const PC 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<PC>(0, 45));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_multimap<int, long, std::hash<int>, std::equal_to<int>, test_allocator<PC>>);
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    assert(m.get_allocator().get_id() == 45);
+    }
+
+    {
+    const PC 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<PC>(0, 46));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_multimap<int, long, std::hash<short>, std::equal_to<int>, test_allocator<PC>>);
+    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({ PC{1,1L}, PC{2,2L}, PC{1,1L}, PC{INT_MAX,1L}, PC{3,1L} }, 42, test_allocator<PC>(0, 47));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_multimap<int, long, std::hash<int>, std::equal_to<int>, test_allocator<PC>>);
+    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({ PC{1,1L}, PC{2,2L}, PC{1,1L}, PC{INT_MAX,1L}, PC{3,1L} }, 42, std::hash<short>(), test_allocator<PC>(0, 48));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_multimap<int, long, std::hash<short>, std::equal_to<int>, test_allocator<PC>>);
+    assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
+    assert(m.get_allocator().get_id() == 48);
+    }
+
+    return 0;
+}

libcxx/trunk/www/cxx2a_status.html

-->
   <tr><td><a href="https://wg21.link/LWG2797">2797</a></td><td>Trait precondition violations</td><td>San Diego</td><td>Resolved by 1285R0</td></tr>
   <tr><td><a href="https://wg21.link/LWG2936">2936</a></td><td>Path comparison is defined in terms of the generic format</td><td>San Diego</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG2943">2943</a></td><td>Problematic specification of the wide version of <tt>basic_filebuf::open</tt></td><td>San Diego</td><td>Nothing to do</td></tr>
   <tr><td><a href="https://wg21.link/LWG2960">2960</a></td><td>[fund.ts.v3] <tt>nonesuch</tt> is insufficiently useless</td><td>San Diego</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG2995">2995</a></td><td><tt>basic_stringbuf</tt> default constructor forbids it from using SSO capacity</td><td>San Diego</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG2996">2996</a></td><td>Missing rvalue overloads for <tt>shared_ptr</tt> operations</td><td>San Diego</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3008">3008</a></td><td><tt>make_shared</tt> (sub)object destruction semantics are not specified</td><td>San Diego</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3022">3022</a></td><td><tt>is_convertible&lt;derived*, base*&gt;</tt> may lead to ODR</td><td>San Diego</td><td>Resolved by 1285R0</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3025">3025</a></td><td>Map-like container deduction guides should use <tt>pair&lt;Key, T&gt;</tt>, not <tt>pair&lt;const Key, T&gt;</tt></td><td>San Diego</td><td></td></tr>
+  <tr><td><a href="https://wg21.link/LWG3025">3025</a></td><td>Map-like container deduction guides should use <tt>pair&lt;Key, T&gt;</tt>, not <tt>pair&lt;const Key, T&gt;</tt></td><td>San Diego</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG3031">3031</a></td><td>Algorithms and predicates with non-const reference arguments</td><td>San Diego</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3037">3037</a></td><td><tt>polymorphic_allocator</tt> and incomplete types</td><td>San Diego</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3038">3038</a></td><td><tt>polymorphic_allocator::allocate</tt> should not allow integer overflow to create vulnerabilities</td><td>San Diego</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3054">3054</a></td><td><tt>uninitialized_copy</tt> appears to not be able to meet its exception-safety guarantee</td><td>San Diego</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3065">3065</a></td><td>LWG 2989 missed that all <tt>path</tt>'s other operators should be hidden friends as well</td><td>San Diego</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG3096">3096</a></td><td><tt>path::lexically_relative</tt> is confused by trailing slashes</td><td>San Diego</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG3116">3116</a></td><td><tt><i>OUTERMOST_ALLOC_TRAITS</i></tt> needs <tt>remove_reference_t</tt></td><td>San Diego</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3122">3122</a></td><td><tt>__cpp_lib_chrono_udls</tt> was accidentally dropped</td><td>San Diego</td><td>Complete</td></tr>