[libc++] [LWG2993] reference_wrapper<T> conversion from U&&

[• Quuxplusone]

Summary

Implement the resolution of LWG2993. Replace a deleted constructor with a constructor that SFINAEs away in appropriate circumstances.
Also, now that the constructor is templated, we must have an explicit deduction guide to make CTAD work.

Some tests have been merged in from D40259. I discovered the existence of D40259 only after finishing the <__functional_base> patch itself, though; my impression is that my approach looks simpler than what @K-ballo did in that PR.

These two new tests fail before this patch, in C++11-through-C++20 modes:
std/utilities/function.objects/refwrap/refwrap.const/type_conv_ctor.pass.cpp
std/utilities/function.objects/refwrap/refwrap.const/type_conv_ctor2.pass.cpp

The diffs in type_ctor.pass.cpp and copy_assign.pass.cpp are due to D40259, but have always been green (this patch doesn't affect their validity). I have no objection to removing those diffs, if requested, but I assumed they were in D40259 for some reason.

[• Quuxplusone]

Update Cxx2aStatusIssuesStatus.csv

[Mordante]

libcxx/docs/Cxx2aStatusIssuesStatus.csv

38

Can you add the version number in the last column?

libcxx/test/std/utilities/function.objects/refwrap/refwrap.const/deduct.pass.cpp

27

Since the test requires C++17 you could use std::is_same_v and remove the empty strings from the static_assert.

[• Quuxplusone]

libcxx/docs/Cxx2aStatusIssuesStatus.csv

38

A priori I'm not sure what the convention is here.

• I've seen people adding "Clang 12.0" in some other files
• but this file uses just "" consistently, e.g. on lines 43 and 44
• as a code-hygiene thing, clearly the best thing to do is have the person who cuts the 12.0 release update all the empty strings to "12.0" in one single commit (or to "12" if that's the convention, or to "2020.17" if we move to a different numbering scheme, etc.) — this avoids forcing individual contributors to guess at the next release number before it's announced

So I'll happily and quickly do whatever, but I'd like @ldionne to tell me.

libcxx/test/std/utilities/function.objects/refwrap/refwrap.const/deduct.pass.cpp

27

Will do!

[• Quuxplusone]

Use C++17 is_same_v in one test.

[Mordante]

libcxx/docs/Cxx2aStatusIssuesStatus.csv

38

The column for the issues has been added last Friday. The papers had this column for a longer time (guess from day one) so I think we should use the same convention for the issues and papers:

"2993 <https://wg21.link/LWG2993>__","reference_wrapper<T> conversion from T&&","Albuquerque","|Complete|","12.0"

I agree the other empty columns aren't great and maybe we should all put a version number there.

[• Quuxplusone]

@ldionne ping!

[curdeius]

Just to understand, how is your approach simpler than the one in D40259?

libcxx/include/__functional_base

396

Is there a difference between your approach, i.e. putting this in the ctor's body, and putting it into the initializer list?

[• Quuxplusone]

libcxx/include/__functional_base

396

This is how it's formally specified in LWG2993 — "Creates a variable r as if by T& r = std::forward<U>(u), then constructs a reference_wrapper object that stores a reference to r."
I'm not aware of any specific difference between what I wrote here and a D40259-style

    : __f_(_VSTD::addressof(__bind(static_cast<_Up&&>(__u))))
{ }

but then I haven't thought hard about it. Basically I don't see any advantage to diverging from the exact "as-if-by" wording. Going our own way here can potentially make us wrong, but it can't make us any more right. :)

Just to understand, how is your approach simpler than the one in D40259?

One fewer template parameter; exploit some recently added libc++ helpers like __is_same_uncvref; static_cast<_Up&&> versus std::forward<_Up>... I guess that's all. The implementation technique is basically the same. The lengthy comment threads on D40259 made me think the implementation was longer than it really was. :) There's some obsolete stuff in those comments too, like references to __void_t when the patch no longer uses __void_t.

[• Quuxplusone]

Rebase on main; @ldionne ping!

[• Quuxplusone]

@ldionne ping?

[ldionne]

Hmm, yeah, it looks like D40259 was never committed back in 2017. The work duplication is unfortunate, but let's move forward with this since this LGTM and CI is passing.

libcxx/docs/Cxx2aStatusIssuesStatus.csv

38

I hadn't thought about that, but it seems like we could:

1. Fill all missing version numbers (in the worse case, if doing archeology is too hard/time consuming, just put "13.0" there).

2. Once we have all the versions, we can have a policy that when you implement something, you just mark it as "Complete", and then the LLVM release is filled in when we cut a release. I agree with @Quuxplusone that this would simplify the life for contributors and also remove the need for people to rebase just to change a version number when something is committed around a release branch (like right now, where I'm often requesting that people change versions from 12.0 to 13.0 since those patches won't make it into 12.0).

libcxx/docs/Cxx2aStatusIssuesStatus.csv

 "`2976 <https://wg21.link/LWG2976>`__","Dangling uses_allocator specialization for packaged_task","Albuquerque","|Complete|",""
 "`2977 <https://wg21.link/LWG2977>`__","unordered_meow::merge() has incorrect Throws: clause","Albuquerque","|Nothing To Do|",""
 "`2978 <https://wg21.link/LWG2978>`__","Hash support for pmr::string and friends","Albuquerque","",""
 "`2979 <https://wg21.link/LWG2979>`__","aligned_union should require complete object types","Albuquerque","|Complete|",""
 "`2980 <https://wg21.link/LWG2980>`__","Cannot compare_exchange empty pointers","Albuquerque","",""
 "`2981 <https://wg21.link/LWG2981>`__","Remove redundant deduction guides from standard library","Albuquerque","",""
 "`2982 <https://wg21.link/LWG2982>`__","Making size_type consistent in associative container deduction guides","Albuquerque","",""
 "`2988 <https://wg21.link/LWG2988>`__","Clause 32 cleanup missed one typename","Albuquerque","",""
-"`2993 <https://wg21.link/LWG2993>`__","reference_wrapper<T> conversion from T&&","Albuquerque","",""
+"`2993 <https://wg21.link/LWG2993>`__","reference_wrapper<T> conversion from T&&","Albuquerque","|Complete|",""
 "`2998 <https://wg21.link/LWG2998>`__","Requirements on function objects passed to {``forward_``,}list-specific algorithms","Albuquerque","|Nothing To Do|",""
 "`3001 <https://wg21.link/LWG3001>`__","weak_ptr::element_type needs remove_extent_t","Albuquerque","",""
 "`3024 <https://wg21.link/LWG3024>`__","variant's copies must be deleted instead of disabled via SFINAE","Albuquerque","|Complete|",""
 "","","","",""
 "`2164 <https://wg21.link/LWG2164>`__","What are the semantics of ``vector.emplace(vector.begin(), vector.back())``\ ?","Jacksonville","|Complete|",""
 "`2243 <https://wg21.link/LWG2243>`__","``istream::putback``\  problem","Jacksonville","|Complete|",""
 "`2816 <https://wg21.link/LWG2816>`__","``resize_file``\  has impossible postcondition","Jacksonville","|Nothing To Do|",""
 "`2843 <https://wg21.link/LWG2843>`__","Unclear behavior of ``std::pmr::memory_resource::do_allocate()``\ ","Jacksonville","|Complete|",""

libcxx/include/__functional_base

class _LIBCPP_TEMPLATE_VIS reference_wrapper
     : public __weak_result_type<_Tp>
 {
 public:
     // types
     typedef _Tp type;
 private:
     type* __f_;
 
+#ifndef _LIBCPP_CXX03_LANG
+    static void __fun(_Tp&) _NOEXCEPT;
+    static void __fun(_Tp&&) = delete;
+#endif
+
 public:
     // construct/copy/destroy
+#ifdef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY reference_wrapper(type& __f) _NOEXCEPT
         : __f_(_VSTD::addressof(__f)) {}
-#ifndef _LIBCPP_CXX03_LANG
-    private: reference_wrapper(type&&); public: // = delete; // do not bind to temps
+#else
+    template <class _Up, class = _EnableIf<!__is_same_uncvref<_Up, reference_wrapper>::value, decltype(__fun(_VSTD::declval<_Up>())) >>
+    _LIBCPP_INLINE_VISIBILITY reference_wrapper(_Up&& __u) _NOEXCEPT_(noexcept(__fun(_VSTD::declval<_Up>()))) {
+        type& __f = static_cast<_Up&&>(__u);
+        __f_ = _VSTD::addressof(__f);
+    }
 #endif
 
     // access
     _LIBCPP_INLINE_VISIBILITY operator type&    () const _NOEXCEPT {return *__f_;}
     _LIBCPP_INLINE_VISIBILITY          type& get() const _NOEXCEPT {return *__f_;}
 
 #ifndef _LIBCPP_CXX03_LANG
     // invoke
#else
     _LIBCPP_INLINE_VISIBILITY
     typename __invoke_return2<type, _A0 const, _A1 const, _A2 const>::type
     operator() (_A0 const& __a0, _A1 const& __a1, _A2 const& __a2) const {
         return __invoke(get(), __a0, __a1, __a2);
     }
 #endif // _LIBCPP_CXX03_LANG
 };
 
+#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
+template <class _Tp>
+reference_wrapper(_Tp&) -> reference_wrapper<_Tp>;
+#endif
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 reference_wrapper<_Tp>
 ref(_Tp& __t) _NOEXCEPT
 {
     return reference_wrapper<_Tp>(__t);
 }

libcxx/include/functional

class reference_wrapper
     : public binary_function<T1, T2, R> // if wraping a binary functor
 {
 public:
     // types
     typedef T type;
     typedef see below result_type; // Not always defined
 
     // construct/copy/destroy
-    reference_wrapper(T&) noexcept;
-    reference_wrapper(T&&) = delete; // do not bind to temps
+    template<class U>
+      reference_wrapper(U&&);
     reference_wrapper(const reference_wrapper<T>& x) noexcept;
 
     // assignment
     reference_wrapper& operator=(const reference_wrapper<T>& x) noexcept;
 
     // access
     operator T& () const noexcept;
     T& get() const noexcept;
 
     // invoke
     template <class... ArgTypes>
       typename result_of<T&(ArgTypes&&...)>::type
           operator() (ArgTypes&&...) const;
 };
 
+template <class T>
+  reference_wrapper(T&) -> reference_wrapper<T>;
+
 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;
 

libcxx/test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 
 class functor1
 {
 };
 
+struct convertible_to_int_ref {
+    int val = 0;
+    operator int&() { return val; }
+    operator int const&() const { return val; }
+};
+
 template <class T>
 void
 test(T& t)
 {
     std::reference_wrapper<T> r(t);
     T t2 = t;
     std::reference_wrapper<T> r2(t2);
     r2 = r;
int main(int, char**)
     test_function();
     functor1 f1;
     test(f1);
     int i = 0;
     test(i);
     const int j = 0;
     test(j);
 
+#if TEST_STD_VER >= 11
+    convertible_to_int_ref convi;
+    test(convi);
+    convertible_to_int_ref const convic;
+    test(convic);
+
+    {
+    using Ref = std::reference_wrapper<int>;
+    static_assert((std::is_assignable<Ref&, int&>::value), "");
+    static_assert((!std::is_assignable<Ref&, int>::value), "");
+    static_assert((!std::is_assignable<Ref&, int&&>::value), "");
+    }
+#endif
+
   return 0;
 }

libcxx/test/std/utilities/function.objects/refwrap/refwrap.const/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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: libcpp-no-deduction-guides
+
+// <functional>
+
+// template <class T>
+//   reference_wrapper(T&) -> reference_wrapper<T>;
+
+#include <functional>
+
+int main()
+{
+    int i = 0;
+    std::reference_wrapper ri(i);
+    static_assert(std::is_same_v<decltype(ri), std::reference_wrapper<int>>);
+    std::reference_wrapper ri2(ri);
+    static_assert(std::is_same_v<decltype(ri2), std::reference_wrapper<int>>);
+    const int j = 0;
+    std::reference_wrapper rj(j);
+    static_assert(std::is_same_v<decltype(rj), std::reference_wrapper<const int>>);
+    std::reference_wrapper rj2(rj);
+    static_assert(std::is_same_v<decltype(rj2), std::reference_wrapper<const int>>);
+}

libcxx/test/std/utilities/function.objects/refwrap/refwrap.const/type_conv_ctor.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <functional>
+//
+// reference_wrapper
+//
+// template <class U>
+//   reference_wrapper(U&&) noexcept(see below);
+
+#include <functional>
+#include <cassert>
+
+struct convertible_to_int_ref {
+    int val = 0;
+    operator int&() { return val; }
+    operator int const&() const { return val; }
+};
+
+template <bool IsNothrow>
+struct nothrow_convertible {
+    int val = 0;
+    operator int&() noexcept(IsNothrow) { return val; }
+};
+
+struct convertible_from_int {
+    convertible_from_int(int) {}
+};
+
+void meow(std::reference_wrapper<int>) {}
+void meow(convertible_from_int) {}
+
+int gi;
+std::reference_wrapper<int> purr() { return gi; };
+
+template <class T>
+void
+test(T& t)
+{
+    std::reference_wrapper<T> r(t);
+    assert(&r.get() == &t);
+}
+
+void f() {}
+
+int main()
+{
+    convertible_to_int_ref convi;
+    test(convi);
+    convertible_to_int_ref const convic;
+    test(convic);
+
+    {
+    using Ref = std::reference_wrapper<int>;
+    static_assert((std::is_nothrow_constructible<Ref, nothrow_convertible<true>>::value), "");
+    static_assert((!std::is_nothrow_constructible<Ref, nothrow_convertible<false>>::value), "");
+    }
+
+    {
+    meow(0);
+    (true) ? purr() : 0;
+    }
+
+#ifdef __cpp_deduction_guides
+    {
+    int i = 0;
+    std::reference_wrapper ri(i);
+    static_assert((std::is_same<decltype(ri), std::reference_wrapper<int>>::value), "" );
+    const int j = 0;
+    std::reference_wrapper rj(j);
+    static_assert((std::is_same<decltype(rj), std::reference_wrapper<const int>>::value), "" );
+    }
+#endif
+}

libcxx/test/std/utilities/function.objects/refwrap/refwrap.const/type_conv_ctor2.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <functional>
+//
+// reference_wrapper
+//
+// template <class U>
+//   reference_wrapper(U&&);
+
+#include <functional>
+#include <cassert>
+
+struct B {} b;
+
+struct A1 {
+    operator B& () const { return b; }
+};
+struct A2 {
+    operator B& () const noexcept { return b; }
+};
+
+int main()
+{
+    {
+    std::reference_wrapper<B> b1 = A1();
+    assert(&b1.get() == &b);
+    b1 = A1();
+    assert(&b1.get() == &b);
+
+    static_assert(std::is_convertible<A1, std::reference_wrapper<B>>::value, "");
+    static_assert(!std::is_nothrow_constructible<std::reference_wrapper<B>, A1>::value, "");
+#if TEST_STD_VER >= 20
+    static_assert(!std::is_nothrow_convertible_v<A1, std::reference_wrapper<B>>);
+#endif
+    static_assert(std::is_assignable<std::reference_wrapper<B>, A1>::value, "");
+    static_assert(!std::is_nothrow_assignable<std::reference_wrapper<B>, A1>::value, "");
+    }
+
+    {
+    std::reference_wrapper<B> b2 = A2();
+    assert(&b2.get() == &b);
+    b2 = A2();
+    assert(&b2.get() == &b);
+
+    static_assert(std::is_convertible<A2, std::reference_wrapper<B>>::value, "");
+    static_assert(std::is_nothrow_constructible<std::reference_wrapper<B>, A2>::value, "");
+#if TEST_STD_VER >= 20
+    static_assert(std::is_nothrow_convertible_v<A2, std::reference_wrapper<B>>);
+#endif
+    static_assert(std::is_assignable<std::reference_wrapper<B>, A2>::value, "");
+    static_assert(std::is_nothrow_assignable<std::reference_wrapper<B>, A2>::value, "");
+    }
+}

libcxx/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // reference_wrapper
 
 // reference_wrapper(T& t);
 
 #include <functional>
 #include <cassert>
+#include <type_traits>
 
 #include "test_macros.h"
 
 class functor1
 {
 };
 
 template <class T>
int main(int, char**)
     test(f);
     functor1 f1;
     test(f1);
     int i = 0;
     test(i);
     const int j = 0;
     test(j);
 
+    {
+    using Ref = std::reference_wrapper<int>;
+    static_assert((std::is_constructible<Ref, int&>::value), "");
+    static_assert((!std::is_constructible<Ref, int>::value), "");
+    static_assert((!std::is_constructible<Ref, int&&>::value), "");
+    }
+
+#if TEST_STD_VER >= 11
+    {
+    using Ref = std::reference_wrapper<int>;
+    static_assert((std::is_nothrow_constructible<Ref, int&>::value), "");
+    static_assert((!std::is_nothrow_constructible<Ref, int>::value), "");
+    static_assert((!std::is_nothrow_constructible<Ref, int&&>::value), "");
+    }
+#endif
+
   return 0;
 }