Implement deduction guides for std::function (P0433).

[• Quuxplusone]

Summary

P0433 (adopted in C++17) added two deduction guides for std::function.
This patch implements those deduction guides in libc++.

__function_ctad<_Tp> is really tedious. It could be simplified by:

• using macros to generate the 2x2x2x2 = 16 partial specializations (MSVC does this)
• using noexcept(_Np) to deduce the noexcept-specification, reducing the number of partial specializations by half (libstdc++ does this)
• completely ignoring the possibility of volatile-qualified operator() overloads, reducing the number of partial specializations by half (libstdc++ does this)
• deciding that it would be easier to ask LWG to revert this whole part of P0433, than bother to implement it

[• Quuxplusone]

Add the other deduction guide from _Rp(*)(_ArgTypes...). (Uploaded an incomplete diff the first time.)

[ldionne]

It's a shame to have duplicated work, but I already have a patch for this: https://reviews.llvm.org/D54410

[• Quuxplusone]

Superseded by D54410, which has now been landed.

include/functional

 #ifndef _LIBCPP_NO_RTTI
     // function target access:
     const std::type_info& target_type() const _NOEXCEPT;
     template <typename _Tp> _Tp* target() _NOEXCEPT;
     template <typename _Tp> const _Tp* target() const _NOEXCEPT;
 #endif  // _LIBCPP_NO_RTTI
 };
 
+#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
+template<class _Tp, class = decltype(&_Tp::operator())>
+struct __function_ctad;
+
+template<class _Tp, class _Gp, class _Rp, class... _ArgTypes>
+struct __function_ctad<_Tp, _Rp(_Gp::*)(_ArgTypes...)> {
+    using type = _Rp(_ArgTypes...);
+};
+
+template<class _Tp, class _Gp, class _Rp, class... _ArgTypes>
+struct __function_ctad<_Tp, _Rp(_Gp::*)(_ArgTypes...) noexcept> {
+    using type = _Rp(_ArgTypes...);
+};
+
+template<class _Tp, class _Gp, class _Rp, class... _ArgTypes>
+struct __function_ctad<_Tp, _Rp(_Gp::*)(_ArgTypes...) const> {
+    using type = _Rp(_ArgTypes...);
+};
+
+template<class _Tp, class _Gp, class _Rp, class... _ArgTypes>
+struct __function_ctad<_Tp, _Rp(_Gp::*)(_ArgTypes...) const noexcept> {
+    using type = _Rp(_ArgTypes...);
+};
+
+template<class _Tp, class _Gp, class _Rp, class... _ArgTypes>
+struct __function_ctad<_Tp, _Rp(_Gp::*)(_ArgTypes...) volatile> {
+    using type = _Rp(_ArgTypes...);
+};
+
+template<class _Tp, class _Gp, class _Rp, class... _ArgTypes>
+struct __function_ctad<_Tp, _Rp(_Gp::*)(_ArgTypes...) volatile noexcept> {
+    using type = _Rp(_ArgTypes...);
+};
+
+template<class _Tp, class _Gp, class _Rp, class... _ArgTypes>
+struct __function_ctad<_Tp, _Rp(_Gp::*)(_ArgTypes...) const volatile> {
+    using type = _Rp(_ArgTypes...);
+};
+
+template<class _Tp, class _Gp, class _Rp, class... _ArgTypes>
+struct __function_ctad<_Tp, _Rp(_Gp::*)(_ArgTypes...) const volatile noexcept> {
+    using type = _Rp(_ArgTypes...);
+};
+
+template<class _Tp, class _Gp, class _Rp, class... _ArgTypes>
+struct __function_ctad<_Tp, _Rp(_Gp::*)(_ArgTypes...) &> {
+    using type = _Rp(_ArgTypes...);
+};
+
+template<class _Tp, class _Gp, class _Rp, class... _ArgTypes>
+struct __function_ctad<_Tp, _Rp(_Gp::*)(_ArgTypes...) & noexcept> {
+    using type = _Rp(_ArgTypes...);
+};
+
+template<class _Tp, class _Gp, class _Rp, class... _ArgTypes>
+struct __function_ctad<_Tp, _Rp(_Gp::*)(_ArgTypes...) const &> {
+    using type = _Rp(_ArgTypes...);
+};
+
+template<class _Tp, class _Gp, class _Rp, class... _ArgTypes>
+struct __function_ctad<_Tp, _Rp(_Gp::*)(_ArgTypes...) const & noexcept> {
+    using type = _Rp(_ArgTypes...);
+};
+
+template<class _Tp, class _Gp, class _Rp, class... _ArgTypes>
+struct __function_ctad<_Tp, _Rp(_Gp::*)(_ArgTypes...) volatile &> {
+    using type = _Rp(_ArgTypes...);
+};
+
+template<class _Tp, class _Gp, class _Rp, class... _ArgTypes>
+struct __function_ctad<_Tp, _Rp(_Gp::*)(_ArgTypes...) volatile & noexcept> {
+    using type = _Rp(_ArgTypes...);
+};
+
+template<class _Tp, class _Gp, class _Rp, class... _ArgTypes>
+struct __function_ctad<_Tp, _Rp(_Gp::*)(_ArgTypes...) const volatile &> {
+    using type = _Rp(_ArgTypes...);
+};
+
+template<class _Tp, class _Gp, class _Rp, class... _ArgTypes>
+struct __function_ctad<_Tp, _Rp(_Gp::*)(_ArgTypes...) const volatile & noexcept> {
+    using type = _Rp(_ArgTypes...);
+};
+
+template<class _Rp, class... _ArgTypes>
+function(_Rp(*)(_ArgTypes...)) -> function<_Rp(_ArgTypes...)>;
+
+template<class _Tp, class _Sig = typename __function_ctad<_Tp>::type>
+function(_Tp) -> function<_Sig>;
+#endif
+
 template<class _Rp, class ..._ArgTypes>
 function<_Rp(_ArgTypes...)>::function(const function& __f) : __f_(__f.__f_) {}
 
 #if _LIBCPP_STD_VER <= 14
 template<class _Rp, class ..._ArgTypes>
 template <class _Alloc>
 function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
                                      const function& __f) : __f_(__f.__f_) {}

test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/deduct.fail.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++98, c++03, c++11, c++14
+
+// <functional>
+
+// class function<R(ArgTypes...)>
+
+// function(F);
+
+#include <functional>
+
+#include "test_macros.h"
+
+struct A {
+    int operator()(int) const { return 2; }
+    int foo(int) const { return 1; }
+};
+
+struct Callable {
+    template<class... Args>
+    void operator()(Args...) const {}
+};
+
+int g(int) { return 0; }
+
+int main(int, char**)
+{
+    {
+        std::function f = nullptr;
+        //expected-error@-1{{no viable constructor or deduction guide}}
+    }
+    {
+        std::function f = &A::foo;
+        //expected-error@-1{{no viable constructor or deduction guide}}
+    }
+    {
+        std::function f = Callable();
+        //expected-error@-1{{no viable constructor or deduction guide}}
+    }
+    {
+        A a;
+        std::function f = std::ref(a);
+        //expected-error@-1{{no viable constructor or deduction guide}}
+    }
+
+    return 0;
+}

test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/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++98, c++03, c++11, c++14
+
+// <functional>
+
+// class function<R(ArgTypes...)>
+
+// function(F);
+
+#include <functional>
+
+#include "test_macros.h"
+
+struct A {
+    static void foo() {}
+    int operator()(int i) const {
+        return i;
+    }
+};
+
+union B {
+    int data;
+    int operator()(int i) const {
+        return i;
+    }
+};
+
+struct LValueCallable {
+    void operator()() & {}
+};
+
+int gfunc(int) { return 0; }
+
+int gfunc_default(int i = 42) { return i; }
+
+int gfunc_noexcept(int) noexcept { return 0; }
+
+int main(int, char**)
+{
+    {
+    // [func.wrap.func.con]/13
+    int i = 5;
+    std::function g = [&](double) { return i; };
+    ASSERT_SAME_TYPE(decltype(g), std::function<int(double)>);
+    }
+    {
+    std::function f = gfunc;
+    ASSERT_SAME_TYPE(decltype(f), std::function<int(int)>);
+    }
+    {
+    std::function f = gfunc_default;
+    ASSERT_SAME_TYPE(decltype(f), std::function<int(int)>);
+    }
+    {
+    std::function f = gfunc_noexcept;
+    ASSERT_SAME_TYPE(decltype(f), std::function<int(int)>);
+    }
+    {
+    std::function f = &A::foo;
+    ASSERT_SAME_TYPE(decltype(f), std::function<void()>);
+    }
+    {
+    std::function f = (int (*)(int))0;
+    ASSERT_SAME_TYPE(decltype(f), std::function<int(int)>);
+    }
+    {
+    std::function f(&gfunc);
+    ASSERT_SAME_TYPE(decltype(f), std::function<int(int)>);
+    }
+    {
+    std::function f = A();
+    ASSERT_SAME_TYPE(decltype(f), std::function<int(int)>);
+    }
+    {
+    std::function f = B();
+    ASSERT_SAME_TYPE(decltype(f), std::function<int(int)>);
+    }
+    {
+    std::function f = LValueCallable();
+    ASSERT_SAME_TYPE(decltype(f), std::function<void()>);
+    }
+    {
+    std::function<int(int)> a;
+    std::function b(a);
+    ASSERT_SAME_TYPE(decltype(b), std::function<int(int)>);
+    }
+    {
+    const std::function<int(int&)> a;
+    std::function b(a);
+    ASSERT_SAME_TYPE(decltype(b), std::function<int(int&)>);
+    }
+    {
+    std::function<void()> a;
+    std::function b = a;
+    ASSERT_SAME_TYPE(decltype(b), std::function<void()>);
+    }
+
+    {
+    std::function<int(int)> a;
+    std::function b = a;
+    ASSERT_SAME_TYPE(decltype(b), std::function<int(int)>);
+    }
+
+    {
+    std::function<int(int)> a;
+    std::function b(std::move(a));
+    ASSERT_SAME_TYPE(decltype(b), std::function<int(int)>);
+    }
+
+    {
+    const std::function<int(int&)> a;
+    std::function b(std::move(a));
+    ASSERT_SAME_TYPE(decltype(b), std::function<int(int&)>);
+    }
+
+    {
+    std::function<void()> a;
+    std::function b(std::move(a));
+    ASSERT_SAME_TYPE(decltype(b), std::function<void()>);
+    }
+
+    {
+    std::function<int(int)> a;
+    std::function b = std::move(a);
+    ASSERT_SAME_TYPE(decltype(b), std::function<int(int)>);
+    }
+
+    return 0;
+}