From 3d05640bfb1e9681c4e1cad0c56b3917bbaeae44 Mon Sep 17 00:00:00 2001
From: morzhovets <morzhovets@gmail.com>
Date: Sat, 9 Nov 2024 23:51:49 +0400
Subject: [PATCH] Update deduction guides

---
 include/momo/stdish/unordered_multimap.h      | 68 +++++++++++--------
 .../unord.multimap.cnstr/deduct.pass.cpp      |  6 --
 .../deduct_const.pass.cpp                     |  4 --
 3 files changed, 41 insertions(+), 37 deletions(-)

diff --git a/include/momo/stdish/unordered_multimap.h b/include/momo/stdish/unordered_multimap.h
index cb4191c9..c1a3de10 100644
--- a/include/momo/stdish/unordered_multimap.h
+++ b/include/momo/stdish/unordered_multimap.h
@@ -83,7 +83,7 @@ class unordered_multimap
 	typedef size_t size_type;
 	typedef ptrdiff_t difference_type;
 
-	typedef std::pair<const key_type, mapped_type> value_type;
+	typedef momo::internal::Identity<std::pair<const key_type, mapped_type>> value_type;
 
 	typedef momo::internal::HashDerivedIterator<typename HashMultiMap::Iterator,
 		momo::internal::MapReferenceStd> iterator;
@@ -840,78 +840,92 @@ class unordered_multimap_open : public unordered_multimap<TKey, TMapped, THashFu
 
 #define MOMO_DECLARE_DEDUCTION_GUIDES(unordered_multimap) \
 template<typename Iterator, \
-	typename Key = std::remove_const_t<typename std::iterator_traits<Iterator>::value_type::first_type>, \
-	typename Mapped = typename std::iterator_traits<Iterator>::value_type::second_type> \
+	typename Value = typename std::iterator_traits<Iterator>::value_type, \
+	typename Key = std::decay_t<typename Value::first_type>, \
+	typename Mapped = std::decay_t<typename Value::second_type>> \
 unordered_multimap(Iterator, Iterator) \
 	-> unordered_multimap<Key, Mapped>; \
 template<typename Iterator, \
-	typename Key = std::remove_const_t<typename std::iterator_traits<Iterator>::value_type::first_type>, \
-	typename Mapped = typename std::iterator_traits<Iterator>::value_type::second_type, \
+	typename Value = typename std::iterator_traits<Iterator>::value_type, \
+	typename Key = std::decay_t<typename Value::first_type>, \
+	typename Mapped = std::decay_t<typename Value::second_type>, \
 	typename Allocator = std::allocator<std::pair<const Key, Mapped>>, \
 	typename = decltype(std::declval<Allocator&>().allocate(size_t{}))> \
 unordered_multimap(Iterator, Iterator, size_t, Allocator = Allocator()) \
 	-> unordered_multimap<Key, Mapped, HashCoder<Key>, std::equal_to<Key>, Allocator>; \
 template<typename Iterator, typename HashFunc, \
-	typename Key = std::remove_const_t<typename std::iterator_traits<Iterator>::value_type::first_type>, \
-	typename Mapped = typename std::iterator_traits<Iterator>::value_type::second_type, \
+	typename Value = typename std::iterator_traits<Iterator>::value_type, \
+	typename Key = std::decay_t<typename Value::first_type>, \
+	typename Mapped = std::decay_t<typename Value::second_type>, \
 	typename Allocator = std::allocator<std::pair<const Key, Mapped>>, \
 	typename = decltype(std::declval<HashFunc&>()(std::declval<const Key&>())), \
 	typename = decltype(std::declval<Allocator&>().allocate(size_t{}))> \
 unordered_multimap(Iterator, Iterator, size_t, HashFunc, Allocator = Allocator()) \
 	-> unordered_multimap<Key, Mapped, HashFunc, std::equal_to<Key>, Allocator>; \
 template<typename Iterator, typename HashFunc, typename EqualFunc, \
-	typename Key = std::remove_const_t<typename std::iterator_traits<Iterator>::value_type::first_type>, \
-	typename Mapped = typename std::iterator_traits<Iterator>::value_type::second_type, \
+	typename Value = typename std::iterator_traits<Iterator>::value_type, \
+	typename Key = std::decay_t<typename Value::first_type>, \
+	typename Mapped = std::decay_t<typename Value::second_type>, \
 	typename Allocator = std::allocator<std::pair<const Key, Mapped>>, \
 	typename = decltype(std::declval<HashFunc&>()(std::declval<const Key&>())), \
-	typename = decltype(std::declval<EqualFunc&>()(std::declval<const Key&>(), std::declval<const Key&>()))> \
+	typename = decltype(std::declval<EqualFunc&>()(std::declval<const Key&>(), std::declval<const Key&>())), \
+	typename = decltype(std::declval<Allocator&>().allocate(size_t{}))> \
 unordered_multimap(Iterator, Iterator, size_t, HashFunc, EqualFunc, Allocator = Allocator()) \
 	-> unordered_multimap<Key, Mapped, HashFunc, EqualFunc, Allocator>; \
-template<typename Key, typename Mapped> \
-unordered_multimap(std::initializer_list<std::pair<Key, Mapped>>) \
+template<typename CKey, typename Mapped, \
+	typename Key = std::remove_const_t<CKey>> \
+unordered_multimap(std::initializer_list<std::pair<CKey, Mapped>>) \
 	-> unordered_multimap<Key, Mapped>; \
-template<typename Key, typename Mapped, \
+template<typename CKey, typename Mapped, \
+	typename Key = std::remove_const_t<CKey>, \
 	typename Allocator = std::allocator<std::pair<const Key, Mapped>>, \
 	typename = decltype(std::declval<Allocator&>().allocate(size_t{}))> \
-unordered_multimap(std::initializer_list<std::pair<Key, Mapped>>, size_t, Allocator = Allocator()) \
+unordered_multimap(std::initializer_list<std::pair<CKey, Mapped>>, size_t, Allocator = Allocator()) \
 	-> unordered_multimap<Key, Mapped, HashCoder<Key>, std::equal_to<Key>, Allocator>; \
-template<typename Key, typename Mapped, typename HashFunc, \
+template<typename CKey, typename Mapped, typename HashFunc, \
+	typename Key = std::remove_const_t<CKey>, \
 	typename Allocator = std::allocator<std::pair<const Key, Mapped>>, \
 	typename = decltype(std::declval<HashFunc&>()(std::declval<const Key&>())), \
 	typename = decltype(std::declval<Allocator&>().allocate(size_t{}))> \
-unordered_multimap(std::initializer_list<std::pair<Key, Mapped>>, size_t, HashFunc, Allocator = Allocator()) \
+unordered_multimap(std::initializer_list<std::pair<CKey, Mapped>>, size_t, HashFunc, Allocator = Allocator()) \
 	-> unordered_multimap<Key, Mapped, HashFunc, std::equal_to<Key>, Allocator>; \
-template<typename Key, typename Mapped, typename HashFunc, typename EqualFunc, \
+template<typename CKey, typename Mapped, typename HashFunc, typename EqualFunc, \
+	typename Key = std::remove_const_t<CKey>, \
 	typename Allocator = std::allocator<std::pair<const Key, Mapped>>, \
 	typename = decltype(std::declval<HashFunc&>()(std::declval<const Key&>())), \
-	typename = decltype(std::declval<EqualFunc&>()(std::declval<const Key&>(), std::declval<const Key&>()))> \
-unordered_multimap(std::initializer_list<std::pair<Key, Mapped>>, size_t, HashFunc, EqualFunc, Allocator = Allocator()) \
+	typename = decltype(std::declval<EqualFunc&>()(std::declval<const Key&>(), std::declval<const Key&>())), \
+	typename = decltype(std::declval<Allocator&>().allocate(size_t{}))> \
+unordered_multimap(std::initializer_list<std::pair<CKey, Mapped>>, size_t, HashFunc, EqualFunc, Allocator = Allocator()) \
 	-> unordered_multimap<Key, Mapped, HashFunc, EqualFunc, Allocator>;
 
 #define MOMO_DECLARE_DEDUCTION_GUIDES_RANGES(unordered_multimap) \
 template<std::ranges::input_range Range, \
-	typename Key = std::remove_const_t<typename std::ranges::range_value_t<Range>::first_type>, \
-	typename Mapped = typename std::ranges::range_value_t<Range>::second_type> \
+	typename Value = std::ranges::range_value_t<Range>, \
+	typename Key = std::decay_t<typename Value::first_type>, \
+	typename Mapped = std::decay_t<typename Value::second_type>> \
 unordered_multimap(std::from_range_t, Range&&) \
 	-> unordered_multimap<Key, Mapped>; \
 template<std::ranges::input_range Range, \
-	typename Key = std::remove_const_t<typename std::ranges::range_value_t<Range>::first_type>, \
-	typename Mapped = typename std::ranges::range_value_t<Range>::second_type, \
+	typename Value = std::ranges::range_value_t<Range>, \
+	typename Key = std::decay_t<typename Value::first_type>, \
+	typename Mapped = std::decay_t<typename Value::second_type>, \
 	typename Allocator = std::allocator<std::pair<const Key, Mapped>>, \
 	typename = decltype(std::declval<Allocator&>().allocate(size_t{}))> \
 unordered_multimap(std::from_range_t, Range&&, size_t, Allocator = Allocator()) \
 	-> unordered_multimap<Key, Mapped, HashCoder<Key>, std::equal_to<Key>, Allocator>; \
 template<std::ranges::input_range Range, typename HashFunc, \
-	typename Key = std::remove_const_t<typename std::ranges::range_value_t<Range>::first_type>, \
-	typename Mapped = typename std::ranges::range_value_t<Range>::second_type, \
+	typename Value = std::ranges::range_value_t<Range>, \
+	typename Key = std::decay_t<typename Value::first_type>, \
+	typename Mapped = std::decay_t<typename Value::second_type>, \
 	typename Allocator = std::allocator<std::pair<const Key, Mapped>>, \
 	typename = decltype(std::declval<HashFunc&>()(std::declval<const Key&>())), \
 	typename = decltype(std::declval<Allocator&>().allocate(size_t{}))> \
 unordered_multimap(std::from_range_t, Range&&, size_t, HashFunc, Allocator = Allocator()) \
 	-> unordered_multimap<Key, Mapped, HashFunc, std::equal_to<Key>, Allocator>; \
 template<std::ranges::input_range Range, typename HashFunc, typename EqualFunc, \
-	typename Key = std::remove_const_t<typename std::ranges::range_value_t<Range>::first_type>, \
-	typename Mapped = typename std::ranges::range_value_t<Range>::second_type, \
+	typename Value = std::ranges::range_value_t<Range>, \
+	typename Key = std::decay_t<typename Value::first_type>, \
+	typename Mapped = std::decay_t<typename Value::second_type>, \
 	typename Allocator = std::allocator<std::pair<const Key, Mapped>>, \
 	typename = decltype(std::declval<HashFunc&>()(std::declval<const Key&>())), \
 	typename = decltype(std::declval<Allocator&>().allocate(size_t{})), \
diff --git a/test/sources/libcxx/unord.multimap/unord.multimap.cnstr/deduct.pass.cpp b/test/sources/libcxx/unord.multimap/unord.multimap.cnstr/deduct.pass.cpp
index df019413..41af96fa 100644
--- a/test/sources/libcxx/unord.multimap/unord.multimap.cnstr/deduct.pass.cpp
+++ b/test/sources/libcxx/unord.multimap/unord.multimap.cnstr/deduct.pass.cpp
@@ -217,18 +217,14 @@ int main(int, char**)
     assert(m.get_allocator().get_id() == 48);
     }
 
-#if !defined(TEST_GCC)
     {
     // Examples from LWG3025
     momo::stdish::unordered_multimap m{std::pair{1, 1}, {2, 2}, {3, 3}};
     ASSERT_SAME_TYPE(decltype(m), momo::stdish::unordered_multimap<int, int>);
 
-#ifdef LIBCPP_HAS_BAD_NEWS_FOR_MOMO
     momo::stdish::unordered_multimap m2{m.begin(), m.end()};
     ASSERT_SAME_TYPE(decltype(m2), momo::stdish::unordered_multimap<int, int>);
-#endif
     }
-#endif
 
     {
     // Examples from LWG3531
@@ -292,10 +288,8 @@ int main(int, char**)
     }
 #endif
 
-#if MOMO_VERSION_MAJOR > 3
     //UnorderedContainerDeductionGuidesSfinaeAway<std::unordered_multimap, std::unordered_multimap<int, long>>();
     UnorderedContainerDeductionGuidesSfinaeAway<momo::stdish::unordered_multimap, momo::stdish::unordered_multimap<int, long>>();
-#endif
 
     return 0;
 }
diff --git a/test/sources/libcxx/unord.multimap/unord.multimap.cnstr/deduct_const.pass.cpp b/test/sources/libcxx/unord.multimap/unord.multimap.cnstr/deduct_const.pass.cpp
index 894d4b54..471aaddc 100644
--- a/test/sources/libcxx/unord.multimap/unord.multimap.cnstr/deduct_const.pass.cpp
+++ b/test/sources/libcxx/unord.multimap/unord.multimap.cnstr/deduct_const.pass.cpp
@@ -114,7 +114,6 @@ int main(int, char**)
     assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
     }
 
-#if MOMO_VERSION_MAJOR > 3
     {
     momo::stdish::unordered_multimap m({ PC{1,1L}, PC{2,2L}, PC{1,1L}, PC{INT_MAX,1L}, PC{3,1L} }, 42, std::hash<long long>());
     ASSERT_SAME_TYPE(decltype(m), momo::stdish::unordered_multimap<int, long, std::hash<long long>>);
@@ -126,7 +125,6 @@ int main(int, char**)
     ASSERT_SAME_TYPE(decltype(m), momo::stdish::unordered_multimap<int, long, std::hash<long long>, std::equal_to<>>);
     assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
     }
-#endif
 
     {
     momo::stdish::unordered_multimap m({ PC{1,1L}, PC{2,2L}, PC{1,1L}, PC{INT_MAX,1L}, PC{3,1L} }, 42, std::hash<long long>(), std::equal_to<>(), test_allocator<PC>(0, 44));
@@ -151,7 +149,6 @@ int main(int, char**)
     assert(m.get_allocator().get_id() == 46);
     }
 
-#if MOMO_VERSION_MAJOR > 3
     {
     momo::stdish::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), momo::stdish::unordered_multimap<int, long, momo::HashCoder<int>, std::equal_to<int>, test_allocator<PC>>);
@@ -165,7 +162,6 @@ int main(int, char**)
     assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
     assert(m.get_allocator().get_id() == 48);
     }
-#endif
 
     return 0;
 }