[libcxx] Implement P0318R1: unwrap_ref_decay and unwrap_reference

[ldionne]

Summary

This was voted into C++20 in San Diego.

[ldionne]

Include unwrap_reference_t

[EricWF]

LGTM.

[ldionne]

libcxx/include/functional

2535

Is this a viable implementation strategy? The nice part is that this allows us to reuse these metafunctions to implement make_tuple and make_pair before C++20, but IDK whether the standard allows us to bring these names into namespace std with a using declaration?

Is that observable (e.g. through ADL associated namespaces)?

libcxx/include/utility

619–621

This is hardly the "right" place to implement this, however this is the only way I could find not to create another header.

[EricWF]

libcxx/include/functional

2535

After more thought: No, this is not viable.

I believe these are technically customization points for users, so it needs to have the same declaration as in the standard, not just the same spelling.

Bummer.

I guess the best route is to have __foo for use pre-C++20, and the we can implement foo in terms of __foo?

[EricWF]

libcxx/include/utility

619–621

Meh. Just put it where it fits best.

[ldionne]

libcxx/include/functional

2535

I believe these are technically customization points for users, so it needs to have the same declaration as in the standard, not just the same spelling.

We need to fix that.. Only things that are specifically designed to be customization points should be customizable by users. We need a way to tag things in the standard as being a customization point.

[ldionne]

Implement as written in the spec

[mclow.lists]

I agree with your concerns about this living in <utility>, but as long as people can get it by including <type_traits>, then we're good.

libcxx/include/functional

2535

I guess the best route is to have __foo for use pre-C++20, and the we can implement foo in terms of __foo?

We use this approach in lots of other places.

libcxx/include/utility

631

You've still got a C++20 here :-)

[ldionne]

Address Marshall's comment.

[EricWF]

LGTM.

libcxx/include/functional

 template <class T> reference_wrapper<T> ref(T& t) noexcept;
 template <class T> void ref(const T&& t) = delete;
 template <class T> reference_wrapper<T> ref(reference_wrapper<T>t) noexcept;
 
 template <class T> reference_wrapper<const T> cref(const T& t) noexcept;
 template <class T> void cref(const T&& t) = delete;
 template <class T> reference_wrapper<const T> cref(reference_wrapper<T> t) noexcept;
 
+template <class T> struct unwrap_reference;                                       // since C++20
+template <class T> struct unwrap_ref_decay : unwrap_reference<decay_t<T>> { };    // since C++20
+template <class T> using unwrap_ref_decay_t = typename unwrap_ref_decay<T>::type; // since C++20
+
 template <class T> // <class T=void> in C++14
 struct plus : binary_function<T, T, T>
 {
     T operator()(const T& x, const T& y) const;
 };
 
 template <class T> // <class T=void> in C++14
 struct minus : binary_function<T, T, T>

 private:
     _ForwardIterator __first_;
     _ForwardIterator __last_;
     _BinaryPredicate __pred_;
     };
 
 #endif // _LIBCPP_STD_VER > 14
 
+#if _LIBCPP_STD_VER > 17
+using __detail::unwrap_reference;
+using __detail::unwrap_ref_decay;
+
+template <class _Tp>
+using unwrap_ref_decay_t = typename unwrap_ref_decay<_Tp>::type;
+#endif // >= C++20
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_FUNCTIONAL

libcxx/include/tuple

struct __ignore_t
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     const __ignore_t& operator=(_Tp&&) const {return *this;}
 };
 
 namespace {
   _LIBCPP_INLINE_VAR constexpr __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>();
 }
 
-template <class _Tp>
-struct __make_tuple_return_impl
-{
-    typedef _Tp type;
-};
-
-template <class _Tp>
-struct __make_tuple_return_impl<reference_wrapper<_Tp> >
-{
-    typedef _Tp& type;
-};
-
-template <class _Tp>
-struct __make_tuple_return
-{
-    typedef typename __make_tuple_return_impl<typename decay<_Tp>::type>::type type;
-};
-
 template <class... _Tp>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
-tuple<typename __make_tuple_return<_Tp>::type...>
+tuple<typename __detail::unwrap_ref_decay<_Tp>::type...>
 make_tuple(_Tp&&... __t)
 {
-    return tuple<typename __make_tuple_return<_Tp>::type...>(_VSTD::forward<_Tp>(__t)...);
+    return tuple<typename __detail::unwrap_ref_decay<_Tp>::type...>(_VSTD::forward<_Tp>(__t)...);
 }
 
 template <class... _Tp>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 tuple<_Tp&&...>
 forward_as_tuple(_Tp&&... __t) _NOEXCEPT
 {
     return tuple<_Tp&&...>(_VSTD::forward<_Tp>(__t)...);

libcxx/include/utility

 >::type
 swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
                      _NOEXCEPT_((__is_nothrow_swappable<_T1>::value &&
                                  __is_nothrow_swappable<_T2>::value))
 {
     __x.swap(__y);
 }
 
-#ifndef _LIBCPP_CXX03_LANG
-
+namespace __detail {
     template <class _Tp>
-struct __make_pair_return_impl
-{
-    typedef _Tp type;
-};
+    struct unwrap_reference { typedef _Tp type; };
 
     template <class _Tp>
-struct __make_pair_return_impl<reference_wrapper<_Tp>>
-{
-    typedef _Tp& type;
-};
+    struct unwrap_reference<reference_wrapper<_Tp> > { typedef _Tp& type; };
 
     template <class _Tp>
-struct __make_pair_return
-{
-    typedef typename __make_pair_return_impl<typename decay<_Tp>::type>::type type;
-};
+    struct unwrap_ref_decay : unwrap_reference<typename decay<_Tp>::type> { };
+} // end namespace __detail
+
+#ifndef _LIBCPP_CXX03_LANG
 
 template <class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
-pair<typename __make_pair_return<_T1>::type, typename __make_pair_return<_T2>::type>
+pair<typename __detail::unwrap_ref_decay<_T1>::type, typename __detail::unwrap_ref_decay<_T2>::type>
 make_pair(_T1&& __t1, _T2&& __t2)
 {
-    return pair<typename __make_pair_return<_T1>::type, typename __make_pair_return<_T2>::type>
+    return pair<typename __detail::unwrap_ref_decay<_T1>::type, typename __detail::unwrap_ref_decay<_T2>::type>
                (_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2));
 }
 
 #else  // _LIBCPP_CXX03_LANG
 
 template <class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY
 pair<_T1,_T2>

libcxx/test/std/utilities/function.objects/refwrap/unwrap_ref_decay.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// template <class T>
+// struct unwrap_ref_decay;
+//
+// template <class T>
+// using unwrap_ref_decay_t = typename unwrap_ref_decay<T>::type;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+#include <functional>
+#include <type_traits>
+
+
+template <typename T, typename Result>
+void check() {
+  static_assert(std::is_same_v<typename std::unwrap_ref_decay<T>::type, Result>);
+  static_assert(std::is_same_v<typename std::unwrap_ref_decay<T>::type, std::unwrap_ref_decay_t<T>>);
+}
+
+struct T { };
+
+int main() {
+  check<T,             T>();
+  check<T&,            T>();
+  check<T const,       T>();
+  check<T const&,      T>();
+  check<T*,            T*>();
+  check<T const*,      T const*>();
+  check<T[3],          T*>();
+  check<T const [3],   T const*>();
+  check<T (),          T (*)()>();
+  check<T (int) const, T (int) const>();
+  check<T (int) &,     T (int) &>();
+  check<T (int) &&,    T (int) &&>();
+
+  check<std::reference_wrapper<T>,         T&>();
+  check<std::reference_wrapper<T>&,        T&>();
+  check<std::reference_wrapper<T const>,   T const&>();
+  check<std::reference_wrapper<T const>&,  T const&>();
+  check<std::reference_wrapper<T*>,        T*&>();
+  check<std::reference_wrapper<T*>&,       T*&>();
+  check<std::reference_wrapper<T const*>,  T const*&>();
+  check<std::reference_wrapper<T const*>&, T const*&>();
+  check<std::reference_wrapper<T[3]>,      T (&)[3]>();
+  check<std::reference_wrapper<T[3]>&,     T (&)[3]>();
+  check<std::reference_wrapper<T ()>,      T (&)()>();
+  check<std::reference_wrapper<T ()>&,     T (&)()>();
+}

libcxx/test/std/utilities/function.objects/refwrap/unwrap_reference.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// template <class T>
+// struct unwrap_reference;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+#include <functional>
+#include <type_traits>
+
+
+template <typename T>
+void check() {
+  static_assert(std::is_same_v<typename std::unwrap_reference<T>::type, T>);
+  static_assert(std::is_same_v<typename std::unwrap_reference<T&>::type, T&>);
+  static_assert(std::is_same_v<typename std::unwrap_reference<T const>::type, T const>);
+  static_assert(std::is_same_v<typename std::unwrap_reference<T const&>::type, T const&>);
+
+  static_assert(std::is_same_v<typename std::unwrap_reference<std::reference_wrapper<T>>::type, T&>);
+  static_assert(std::is_same_v<typename std::unwrap_reference<std::reference_wrapper<T const>>::type, T const&>);
+}
+
+struct T { };
+
+int main() {
+  check<T>();
+  check<int>();
+  check<float>();
+
+  check<T*>();
+  check<int*>();
+  check<float*>();
+}

libcxx/www/cxx2a_status.html

-->
   <tr><td><a href="https://wg21.link/P0898R3">P0898R3</a></td><td>LWG</td><td>Standard Library Concepts</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0935R0">P0935R0</a></td><td>LWG</td><td>Eradicating unnecessarily explicit default constructors from the standard library</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0941R2">P0941R2</a></td><td>CWG</td><td>Integrating feature-test macros into the C++ WD</td><td>Rapperswil</td><td><i>In progress</i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1023R0">P1023R0</a></td><td>LWG</td><td>constexpr comparison operators for std::array</td><td>Rapperswil</td><td>Complete</td><td>8.0</td></tr>
   <tr><td><a href="https://wg21.link/P1025R1">P1025R1</a></td><td>CWG</td><td>Update The Reference To The Unicode Standard</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1120R0">P1120R0</a></td><td>CWG</td><td>Consistency improvements for &lt;=&gt; and other comparison operators</td><td>Rapperswil</td><td></td><td></td></tr>
 
    <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0318R1">P0318R1</a></td><td>LWG</td><td>unwrap_ref_decay and unwrap_reference</td><td>San Diego</td><td><i> </i></td><td></td></tr>
+  <tr><td><a href="https://wg21.link/P0318R1">P0318R1</a></td><td>LWG</td><td>unwrap_ref_decay and unwrap_reference</td><td>San Diego</td><td>Complete</td><td>8.0</td></tr>
   <tr><td><a href="https://wg21.link/P0356R5">P0356R5</a></td><td>LWG</td><td>Simplified partial function application</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0357R3">P0357R3</a></td><td>LWG</td><td>reference_wrapper for incomplete types</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0482R6">P0482R6</a></td><td>CWG</td><td>char8_t: A type for UTF-8 characters and strings</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0487R1">P0487R1</a></td><td>LWG</td><td>Fixing operator&gt;&gt;(basic_istream&amp;, CharT*) (LWG 2499)</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0591R4">P0591R4</a></td><td>LWG</td><td>Utility functions to implement uses-allocator construction</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0595R2">P0595R2</a></td><td>CWG</td><td>P0595R2 std::is_constant_evaluated()</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0602R4">P0602R4</a></td><td>LWG</td><td>variant and optional should propagate copy/move triviality</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0608R3">P0608R3</a></td><td>LWG</td><td>A sane variant converting constructor</td><td>San Diego</td><td><i> </i></td><td></td></tr>