[libcxx] LWG2420 bits for bind<void>

[K-ballo]

Summary

Implemented LWG2420 bits for bind<void>

[EricWF]

LGTM. I don't think we need any changes in __functional_03 because we don't provide bind in 03 :)

include/__functional_03

2095

Small nit about the existing code: base is not a reserved identify and I don't know if it is safe to use.

include/functional

2188

We could probably save a bunch of SFINAE here by using __lazy_or and putting the is_void check first. However I'm not sure that could hide errors caused by not evaluating __bind_return. Thoughts?

[K-ballo]

In D10997#200672, @EricWF wrote:

I don't think we need any changes in __functional_03 because we don't provide bind in 03 :)

The changes in __functional_03 apply to commented out code. I added those just for the sake of completeness, although I doubt there will ever be an '03 bind. There'd be no harm in dropping them.

include/functional

2188

IIUC, __bind_return is SFINAE-ing out on a resulting ill-formed INVOKE expression. Strictly speaking I don't think it is required, but since it's already there I'd rather be consistent.

[EricWF]

In D10997#200760, @K-ballo wrote:

I doubt there will ever be an '03 bind.

Only over my dead body. I've been meaning to remove that code for a while now. I'll probably tear it out tonight.

Can I commit this for you?

[K-ballo]

In D10997#200911, @EricWF wrote:

Can I commit this for you?

Sure, thanks.

[EricWF]

Committed in r241967.

include/__functional_03

template <class _Gp, class ..._BA>
       explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args)
         : base(_VSTD::forward<_Gp>(__f),
                _VSTD::forward<_BA>(__bound_args)...) {}
 
     template <class ..._Args>
         result_type
         operator()(_Args&& ...__args)
         {
-            return base::operator()(_VSTD::forward<_Args>(__args)...);
+            typedef __invoke_void_return_wrapper<_Rp> _Invoker;
+            return _Invoker::__call(static_cast<base&>(*this), _VSTD::forward<_Args>(__args)...);
         }
 
     template <class ..._Args>
         result_type
         operator()(_Args&& ...__args) const
         {
-            return base::operator()(_VSTD::forward<_Args>(__args)...);
+            typedef __invoke_void_return_wrapper<_Rp> _Invoker;
+            return _Invoker::__call(static_cast<base const&>(*this), _VSTD::forward<_Args>(__args)...);
         }
 };
 
 template<class _Rp, class _Fp, class ..._BoundArgs>
 struct __is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {};
 
 template<class _Fp, class ..._BoundArgs>
 inline _LIBCPP_INLINE_VISIBILITY

include/functional

template <class _Gp, class ..._BA,
       explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args)
         : base(_VSTD::forward<_Gp>(__f),
                _VSTD::forward<_BA>(__bound_args)...) {}
 
     template <class ..._Args>
         _LIBCPP_INLINE_VISIBILITY
         typename enable_if
         <
             is_convertible<typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type,
-                           result_type>::value,
+                           result_type>::value || is_void<_Rp>::value,
             result_type
         >::type
         operator()(_Args&& ...__args)
         {
-            return base::operator()(_VSTD::forward<_Args>(__args)...);
+            typedef __invoke_void_return_wrapper<_Rp> _Invoker;
+            return _Invoker::__call(static_cast<base&>(*this), _VSTD::forward<_Args>(__args)...);
         }
 
     template <class ..._Args>
         _LIBCPP_INLINE_VISIBILITY
         typename enable_if
         <
             is_convertible<typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type,
-                           result_type>::value,
+                           result_type>::value || is_void<_Rp>::value,
             result_type
         >::type
         operator()(_Args&& ...__args) const
         {
-            return base::operator()(_VSTD::forward<_Args>(__args)...);
+            typedef __invoke_void_return_wrapper<_Rp> _Invoker;
+            return _Invoker::__call(static_cast<base const&>(*this), _VSTD::forward<_Args>(__args)...);
         }
 };
 
 template<class _Rp, class _Fp, class ..._BoundArgs>
 struct __is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {};
 
 template<class _Fp, class ..._BoundArgs>
 inline _LIBCPP_INLINE_VISIBILITY

test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_void_0.pass.cpp

 {
     int save_count = count;
     f();
     assert(count == save_count + 2);
 }
 
 void f() {++count;}
 
-struct A_int_0
+int g() {++count; return 0;}
+
+struct A_void_0
 {
     void operator()() {++count;}
     void operator()() const {count += 2;}
 };
 
+struct A_int_0
+{
+    int operator()() {++count; return 4;}
+    int operator()() const {count += 2; return 5;}
+};
+
 int main()
 {
     test(std::bind(f));
     test(std::bind(&f));
-    test(std::bind(A_int_0()));
-    test_const(std::bind(A_int_0()));
+    test(std::bind(A_void_0()));
+    test_const(std::bind(A_void_0()));
 
     test(std::bind<void>(f));
     test(std::bind<void>(&f));
+    test(std::bind<void>(A_void_0()));
+    test_const(std::bind<void>(A_void_0()));
+
+    test(std::bind<void>(g));
+    test(std::bind<void>(&g));
     test(std::bind<void>(A_int_0()));
     test_const(std::bind<void>(A_int_0()));
 }