[libcxx] Fix PR 22468 - std::function<void()> does not accept non-void-returning functions

[EricWF]

Summary

The bug can be found here: http://llvm.org/bugs/show_bug.cgi?id=22468

__invoke_void_return_wrapper is needed to properly handle calling a function that returns a value but where the std::function return type is void. Without this '-Wsystem-headers' will cause function::operator()(...) to not compile.

[K-ballo]

The current functionality is correct as LWG2420 has not yet been accepted (note I'm the submitter). I'm sitting on a patch to implement the currently intended resolution (apply change to INVOKE, not just function) in a considerably simpler way, waiting for that direction to be confirmed.

[EricWF]

Could you email me the patch?

[EricWF]

I'm going to move forward with this patch because K-ballo's patch had an issue with types that overloaded operator comma as a free function.

[K-ballo]

After we found some corner cases where my simpler approach does the wrong thing, I think Eric's patch is the way to go.

[mclow.lists]

I tried applying this change and running the tests under C++03, and there's a lot of failures due to the file support/count_new.hpp using C++11 features.

test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp

87

While you're here, can you wrap this test in an #if __cplusplus >= 201103L so that this test will pass on C++03?

No std::bind in '03

[EricWF]

I upstreamed the C++03 fixes for the tests and then regenerated the diff against ToT.

[mclow.lists]

LGTM

include/__functional_03

 _Rp
 __func<_Fp, _Alloc, _Rp()>::operator()()
 {
-    return __invoke(__f_.first());
+    typedef __invoke_void_return_wrapper<_Rp> _Invoker;
+    return _Invoker::__call(__f_.first());
 }
 
 #ifndef _LIBCPP_NO_RTTI

 _Rp
 __func<_Fp, _Alloc, _Rp(_A0)>::operator()(_A0 __a0)
 {
-    return __invoke(__f_.first(), __a0);
+    typedef __invoke_void_return_wrapper<_Rp> _Invoker;
+    return _Invoker::__call(__f_.first(), __a0);
 }
 
 #ifndef _LIBCPP_NO_RTTI

 _Rp
 __func<_Fp, _Alloc, _Rp(_A0, _A1)>::operator()(_A0 __a0, _A1 __a1)
 {
-    return __invoke(__f_.first(), __a0, __a1);
+    typedef __invoke_void_return_wrapper<_Rp> _Invoker;
+    return _Invoker::__call(__f_.first(), __a0, __a1);
 }
 
 #ifndef _LIBCPP_NO_RTTI

 _Rp
 __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::operator()(_A0 __a0, _A1 __a1, _A2 __a2)
 {
-    return __invoke(__f_.first(), __a0, __a1, __a2);
+    typedef __invoke_void_return_wrapper<_Rp> _Invoker;
+    return _Invoker::__call(__f_.first(), __a0, __a1, __a2);
 }
 
 #ifndef _LIBCPP_NO_RTTI

include/__functional_base

     typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_Args>()...)) type;
 };
 
+template <class _Ret>
+struct __invoke_void_return_wrapper
+{
+    template <class ..._Args>
+    static _Ret __call(_Args&&... __args)
+    {
+        return __invoke(_VSTD::forward<_Args>(__args)...);
+    }
+};
+
+template <>
+struct __invoke_void_return_wrapper<void>
+{
+    template <class ..._Args>
+    static void __call(_Args&&... __args)
+    {
+        __invoke(_VSTD::forward<_Args>(__args)...);
+    }
+};
+
 template <class _Tp>
 class _LIBCPP_TYPE_VIS_ONLY reference_wrapper
     : public __weak_result_type<_Tp>

include/__functional_base_03

                                                     _VSTD::declval<_A2>())) type;
 };
 
+template <class _Ret>
+struct __invoke_void_return_wrapper
+{
+    template <class _Fn>
+    static _Ret __call(_Fn __f)
+    {
+        return __invoke(__f);
+    }
+
+    template <class _Fn, class _A0>
+    static _Ret __call(_Fn __f, _A0& __a0)
+    {
+        return __invoke(__f, __a0);
+    }
+
+    template <class _Fn, class _A0, class _A1>
+    static _Ret __call(_Fn __f, _A0& __a0, _A1& __a1)
+    {
+        return __invoke(__f, __a0, __a1);
+    }
+
+    template <class _Fn, class _A0, class _A1, class _A2>
+    static _Ret __call(_Fn __f, _A0& __a0, _A1& __a1, _A2& __a2)
+    {
+        return __invoke(__f, __a0, __a1, __a2);
+    }
+};
+
+
+template <>
+struct __invoke_void_return_wrapper<void>
+{
+    template <class _Fn>
+    static void __call(_Fn __f)
+    {
+        __invoke(__f);
+    }
+
+    template <class _Fn, class _A0>
+    static void __call(_Fn __f, _A0& __a0)
+    {
+        __invoke(__f, __a0);
+    }
+
+    template <class _Fn, class _A0, class _A1>
+    static void __call(_Fn __f, _A0& __a0, _A1& __a1)
+    {
+        __invoke(__f, __a0, __a1);
+    }
+
+    template <class _Fn, class _A0, class _A1, class _A2>
+    static void __call(_Fn __f, _A0& __a0, _A1& __a1, _A2& __a2)
+    {
+        __invoke(__f, __a0, __a1, __a2);
+    }
+};
+
 template <class _Tp>
 class _LIBCPP_TYPE_VIS_ONLY reference_wrapper
     : public __weak_result_type<_Tp>

include/functional

 _Rp
 __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
 {
-    return __invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...);
+    typedef __invoke_void_return_wrapper<_Rp> _Invoker;
+    return _Invoker::__call(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...);
 }
 
 #ifndef _LIBCPP_NO_RTTI

     template <class _Fp>
         struct __callable<_Fp, true>
         {
-            static const bool value =
+            static const bool value = is_same<void, _Rp>::value ||
                 is_convertible<typename __invoke_of<_Fp&, _ArgTypes...>::type,
                                _Rp>::value;
         };

test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp

     assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f.target<int (A::*)(int) const>() != 0);
     }
+    {
+      std::function<void(int)> f(&g);
+      assert(f);
+      assert(f.target<int(*)(int)>() != 0);
+      f(1);
+    }
 }

test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp

     assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f.target<int (A::*)(int) const>() != 0);
     }
+    {
+    std::function<void(int)> f;
+    f = &g;
+    assert(f);
+    assert(f.target<int(*)(int)>() != 0);
+    f(1);
+    }
 }

test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp

     fun(10);
     }
 #endif
+    {
+    std::function<void(int)> fun(std::allocator_arg,
+                                 test_allocator<int(*)(int)>(),
+                                 &g);
+    assert(fun);
+    assert(fun.target<int(*)(int)>() != 0);
+    fun(10);
+    }
 }

test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke_no_variadics.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>
+
+// class function<R()>
+
+// Test that we properly return both values and void for all non-variadic
+// overloads of function::operator()(...)
+
+#define _LIBCPP_HAS_NO_VARIADICS
+#include <functional>
+#include <cassert>
+
+int foo0() { return 42; }
+int foo1(int) { return 42; }
+int foo2(int, int) { return 42; }
+int foo3(int, int, int) { return 42; }
+
+int main()
+{
+    {
+        std::function<int()> f(&foo0);
+        assert(f() == 42);
+    }
+    {
+        std::function<int(int)> f(&foo1);
+        assert(f(1) == 42);
+    }
+    {
+        std::function<int(int, int)> f(&foo2);
+        assert(f(1, 1) == 42);
+    }
+    {
+        std::function<int(int, int, int)> f(&foo3);
+        assert(f(1, 1, 1) == 42);
+    }
+    {
+        std::function<void()> f(&foo0);
+        f();
+    }
+    {
+        std::function<void(int)> f(&foo1);
+        f(1);
+    }
+    {
+        std::function<void(int, int)> f(&foo2);
+        f(1, 1);
+    }
+    {
+        std::function<void(int, int, int)> f(&foo3);
+        f(1, 1, 1);
+    }
+}