[libcxx] LWG2993: reference_wrapper<T> conversion from T&&

[ldionne]

Summary

Implement LWG2993, reference_wrapper<T> conversion from T&&.

The currently failing test is due to https://bugs.llvm.org/show_bug.cgi?id=35332.

[EricWF]

I would much rather take this change in all dialects except for C++03.

include/__functional_base

398

The __void_t isn't necessary here. Plus I think we can be clever and write this condition as:

bool _IsNoexcept = noexcept(<expr>)

And then we can re-use _Noexcept to make the function conditionally noexcept instead of duplicating the expression.

[EricWF]

Also, you're lacking tests for noexcept and the deduction guide.

[tcanens]

include/__functional_base

377

I'd make these member functions of a class template, to avoid having to reason about partial ordering in overload resolution.

[K-ballo]

Addressed review comments. Added tests for SFINAE, noexcept, deduction guide.

[tcanens]

include/__functional_base

396

Is it safe to do this when we are using _NOEXCEPT_ in the next line?

[EricWF]

include/__functional_base

396

It should be. The noexcept condition should only be evaluated *as needed* for functions selected by overload resolution. i.e. The noexcept condition is only considered on well-formed functions. And this function is only well-formed if _IsNothrow is well formed.

If IsNothrow is ill-formed, it will prevent the functions noexcept specifier from ever being evaluated.

[tcanens]

include/__functional_base

396

My point is that the use of macro-ized _NOEXCEPT_ suggests that we are supporting compilers that doesn't have noexcept-specifications. Given that, can we then use the noexcept operator here?

[EricWF]

include/__functional_base

396

Ah, I see!

The _NOEXCEPT_ macro is a holdover from the C++03/C++11 era. This code expects a C++11 conformant compiler, and hence expects noexcept to work as a non-buggy feature-complete C++11 construct.

Much in the same way the current (and previous) code expects C++11 template aliases, default function template arguments, decltype, ect. to work.

[K-ballo]

Full context diff.

[EricWF]

include/__functional_base

396

So I need to backpeddel about using noexcept in the SFINAE instead of decltype. I forgot that noexcept specifications are evaluated "as-needed", and using it in SFINAE could potentially cause the evaluation of "unneeded" noexcept specifications.

Could we go back to decltype please?

Sorry about that.

test/std/utilities/function.objects/refwrap/refwrap.const/type_conv_ctor.pass.cpp

18

This should probably be // UNSUPPORTED.

[K-ballo]

Back to decltype-based SFINAE.

[K-ballo]

Turn fail test into SFINAE based pass test, mark XFAIL for clang.

[EricWF]

LGTM after addressing inline comments. Do you have commit access? If not, I'll commit once updated.

test/std/utilities/function.objects/refwrap/refwrap.const/type_conv_ctor2.pass.cpp

16 ↗

(On Diff #124201)

Please change the XFAIL into simply clang since this hasn't been fixed yet, and add a link to the relevant bug in this file.

[mclow.lists]

Please be sure to update www/cxx2a_status.html to mark 2993 as "Complete".
Other than that, looks good to me! Thanks!

[mclow.lists]

Did this ever get landed? If not, was there a reason?
Note that the synopsis at the top of <functional> also needs to be updated.

[ldionne]

This is superseded by D92725, so I'm going to commandeer and abandon this to clear up the review queue. Thanks for your contribution - it seems to me that part of D92725 is actually taken from this patch.

[ldionne]

Closing as this is superseded by D92725.

include/__functional_base

 #endif
 };
 
+#if _LIBCPP_STD_VER > 17
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+_Tp& __lvref_bind(_Tp& r) _NOEXCEPT { return r; }
+
+template <class _Tp>
+_Tp& __lvref_bind(_Tp&& r) = delete;
+#endif
+
 template <class _Tp>
 class _LIBCPP_TEMPLATE_VIS reference_wrapper
     : public __weak_result_type<_Tp>

 
 public:
     // construct/copy/destroy
+#if _LIBCPP_STD_VER > 17
+    template <class _Up, class = enable_if_t<
+        !is_same<__uncvref_t<_Up>, reference_wrapper>::value
+    >, class = typename __void_t<
+        decltype(_VSTD::__lvref_bind<_Tp>(_VSTD::declval<_Up>()))
+    >::type>
+    _LIBCPP_INLINE_VISIBILITY reference_wrapper(_Up&& __u)
+    _NOEXCEPT_(noexcept(_VSTD::__lvref_bind<_Tp>(_VSTD::forward<_Up>(__u))))
+        : __f_(_VSTD::addressof(_VSTD::__lvref_bind<_Tp>(_VSTD::forward<_Up>(__u)))) {}
+#else
     _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
 #endif
+#endif
 
     // access
     _LIBCPP_INLINE_VISIBILITY operator type&    () const _NOEXCEPT {return *__f_;}

 #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

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

 {
 };
 
+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)

     test(i);
     const int j = 0;
     test(j);
+
+#if TEST_STD_VER > 17
+    convertible_to_int_ref convi;
+    test(convi);
+    convertible_to_int_ref const convic;
+    test(convic);
+#endif
 }

test/std/utilities/function.objects/refwrap/refwrap.const/type_conv_ctor.fail.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>
+
+// reference_wrapper
+
+// template <typename U> reference_wrapper(U&&);
+
+// XFAIL: c++98, c++03, c++11, c++14, c++17
+
+#include <functional>
+#include <cassert>
+
+struct convertible_to_float_ref {
+    float val = 0;
+    operator float const&() const { return val; }
+};
+
+int main()
+{
+    convertible_to_float_ref convf;
+    std::reference_wrapper<const int> r(convf);
+}

test/std/utilities/function.objects/refwrap/refwrap.const/type_conv_ctor.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>
+
+// reference_wrapper
+
+// template <typename U> reference_wrapper(U&&);
+
+// XFAIL: c++98, c++03, c++11, c++14, c++17
+
+#include <functional>
+#include <cassert>
+
+struct convertible_to_int_ref {
+    int val = 0;
+    operator int&() { return val; }
+    operator int const&() const { 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);
+
+    {
+    meow(0);
+    (true) ? purr() : 0;
+    }
+}