[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

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

static void __call(_Fn __f, _A0& __a0, _A1& __a1, _A2& __a2) {
         __invoke(__f, __a0, __a1, __a2);
     }
 #endif
 };
 
 template <class _Tp>
 class _LIBCPP_TEMPLATE_VIS reference_wrapper
     : public __weak_result_type<_Tp>
 {
 public:
     // types
     typedef _Tp type;
 private:
     type* __f_;
 
+    static _LIBCPP_INLINE_VISIBILITY
+    _Tp& __bind(_Tp& r) _NOEXCEPT { return r; }
+
+#ifndef _LIBCPP_CXX03_LANG
+    static _Tp& __bind(_Tp&& r) = delete;
+#endif
+
 public:
     // construct/copy/destroy
+#ifndef _LIBCPP_CXX03_LANG
+    template <class _Up, class = typename enable_if<
+        !is_same<__uncvref_t<_Up>, reference_wrapper>::value
+    >::type, class = decltype(__bind(_VSTD::declval<_Up>()))>
+    _LIBCPP_INLINE_VISIBILITY reference_wrapper(_Up&& __u)
+    _NOEXCEPT_(noexcept(__bind(_VSTD::forward<_Up>(__u))))
+        : __f_(_VSTD::addressof(__bind(_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
 
     // 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);
 }

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&&) noexcept(see below);
     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;
 

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

 // <functional>
 
 // reference_wrapper
 
 // reference_wrapper& operator=(const reference_wrapper<T>& x);
 
 #include <functional>
 #include <cassert>
+#include <type_traits>
 
 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()
     test(fp);
     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
 }

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 <class U>
+//   reference_wrapper(U&&) noexcept(see below);
+
+// UNSUPPORTED: c++98, c++03
+
+#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
+}

test/std/utilities/function.objects/refwrap/refwrap.const/type_conv_ctor2.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 <class U>
+//   reference_wrapper(U&&) noexcept(see below);
+
+// UNSUPPORTED: c++98, c++03
+// XFAIL: clang-3.7, clang-3.8, clang-3.9, clang-4.0, clang-5.0, clang-6.0
+
+#include <functional>
+#include <cassert>
+
+struct convertible_to_float_ref {
+    float val = 0;
+    operator float const&() { return val; }
+    operator float const&() const { return val; }
+};
+
+int main()
+{
+    using Ref = std::reference_wrapper<int const>;
+    static_assert((!std::is_constructible<Ref, convertible_to_float_ref>::value), "");
+    static_assert((!std::is_constructible<Ref, convertible_to_float_ref const>::value), "");
+}

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

 // <functional>
 
 // reference_wrapper
 
 // reference_wrapper(T& t);
 
 #include <functional>
 #include <cassert>
+#include <type_traits>
 
 class functor1
 {
 };
 
 template <class T>
 void
 test(T& t)
int main()
     test(fp);
     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), "");
+    }
+#endif
 }