[libc++] Add C++17 deduction guides for std::function

[ldionne]

Summary

http://llvm.org/PR39606

[ldionne]

libcxx/include/functional

2352–2386

Do we have something similar elsewhere I could reuse? This is ugly :(

[mclow.lists]

libcxx/include/functional

2345

In the rest of the library we just check for _LIBCPP_HAS_NO_DEDUCTION_GUIDES, trusting that it is set correctly.

#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES

2352–2386

Can you use __member_pointer_traits_imp (in type_traits)?

[ldionne]

libcxx/include/functional

2345

The reason I'm checking whether C++ > 14 here is that in the future it's possible for new deduction guides to be added after C++17, and we'd only want to enable those in C++ > XX. For example, if we added new deduction guides in C++20, we'd want to say:

#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_DEDUCTION_GUIDES

I wrote it that way for consistency with this pattern. WDYT?

2352–2386

__member_pointer_traits_imp does not handle noexcept, and it handles C-style variadics (it's not clear to me whether this is supported by the deduction guides, see http://eel.is/c++draft/func.wrap#func.con-12).

If it's OK to

• add noexcept support to __member_pointer_traits_imp (which means that result_of would work with noexcept-qualified functions, and
• support C-style variadics in the deduction guide for std::function

then we could add support for noexcept to __member_pointer_traits_imp and use the following instead:

template<class _Fp, class _Stripped = typename __member_pointer_traits<decltype(&_Fp::operator())>::_FnType>
function(_Fp) -> function<_Stripped>;

[ldionne]

Gentle ping

[ldionne]

Ping. We should decide whether we go forward with this patch or https://reviews.llvm.org/D64752

[• Quuxplusone]

This patch looks like it's got much more complete unit tests than my D64752. I'd be happy to abandon that one. :)

libcxx/include/functional

2345

BTW and FWIW, I agree with @EricWF's original comment. In the future it's possible for new deduction guides to be added anywhere; std::function is not special. Even if it has special cover-your-ass wording that pretends it's special. :)

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/deduct_F.fail.cpp

26

You might want to additionally test (also UB):

struct f1 { R operator()(int, ...) { return {}; } };

29

FWIW, this line has undefined behavior (or is IFNDR) — the standard doesn't define the behavior when the deduction guide participates in overload resolution but decltype(&T::operator()) is not of the expected form.

Maybe that means this test ought to go into test/libcxx/ instead of test/std/. Maybe we don't care. I think all of the Big 3 implementations do the same thing in this case.

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

50

These macros are either awesome or awful, depending on your point of view. ;)
It might be interesting to add virtual as another dimension.

57

This should use ASSERT_SAME_TYPE(decltype(a), std::function<R()>) for clarity.

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

30

I recommend adding a test case for R f4(A1 = {}) and making sure it deduces R(A1) not R().

[ldionne]

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/deduct_F.fail.cpp

29

I'm not sure I understand what you mean. You mean that because there's no deduction guide handling the rvalue-ref-qualified-call-operator case, it's ill-formed NDR? What I could find is http://eel.is/c++draft/function.objects#func.wrap.func.con-12:

template<class F> function(F) -> function<see below>;

*Remarks*: This deduction guide participates in overload resolution only if &F::operator() is well-formed when treated as an unevaluated operand. In that case, if decltype(&F::operator()) is of the form R(G::*)(A...) cv_opt & noexcept_opt for a class type G, then the deduced type is function<R(A...)>.

So what you're saying is that since we don't say what happens when decltype(&F::operator()) is *not* of the form R(G::*)(A...) cv_opt & noexcept_opt (in this case it's of the form R(G::*)(A...) cv_opt && noexcept_opt), the behaviour's undefined? I think I agree with that, however I think that's a LWG issue right here -- it should instead say something like:

template<class F> function(F) -> function<see below>;

*Remarks*: This deduction guide participates in overload resolution only if &F::operator() is well-formed when treated as an unevaluated operand, and is of the form R(G::*)(A...) cv_opt & noexcept_opt for a class type G. In that case, the deduced type is function<R(A...)>.

This would make the deduction guide NOT participate in overload resolution if it doesn't have the right form, which is effectively how it's implemented right now. And that mandates a compiler error. Do you agree with me?

[ldionne]

Address comments by Arthur.

[• Quuxplusone]

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/deduct_F.fail.cpp

29

Yes, I agree with your analysis. It's currently UB; it probably merits an LWG issue to make it not-UB; and almost certainly the right resolution (to the paper issue, and for vendors to use in practice until then) is to make the deduction guide not-participate-in-overload-resolution in the offending cases.

To verify the implementation of that resolution, you'd add a test case like this:

struct A : std::function<int(double)> {
    int operator()() &&;
};
auto x = &A::operator();  // OK
std::function f = A();  // OK, guide doesn't participate in overload resolution, so we deduce from the move-constructor instead
static_assert(std::is_same_v<decltype(f), std::function<int(double)>>);

Which, it occurs to me, also exercises the part of the compiler that generates implicit candidates for copy- and move-constructors in the absence of any definition for the primary template. Isn't CTAD fun? 😛

[ldionne]

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/deduct_F.fail.cpp

29

I filed a LWG issue and CC'd you on the email.

[• Quuxplusone]

LGTM modulo these last nitpicky comments.

libcxx/include/functional

2345

Please make this just

#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
    ...
#endif

to match the other headers.

...Unless you need the extra _LIBCPP_STD_VER > 14 check, to fix some test failure, in which case please mention it in your commit message. (I do observe that __strip_signature requires a compiler with core-language support for noexcept-in-the-type-system, which was new in C++17, so I will happily be convinced by anecdotal evidence that the difference is required. But I don't want the difference between this header and other headers to be completely gratuitous. :))

2353

Whitespace nit: I'd remove the space between (_Gp::*) (_Ap...). And maybe the space between _Rp (_Gp::*) too, but I have no real preference on that one.

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/deduct_F.fail.cpp

19

Mention the LWG issue here, if it gets a number assigned in time?

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

112

I think there should additionally be unit tests for:

• std::function f = nullptr; does not compile
• std::function<int(int)> g; std::function f = g; deduces int(int)
• std::function<int(int)> g; std::function f = std::move(g); deduces int(int)
• std::function<int(int&&)> g; std::function f = g; deduces int(int&&)
• std::function<int(int&&)> g; std::function f = std::move(g); deduces int(int&&)

These could be in new test files, or shoehorned into the existing ones somehow, I don't care.

[ldionne]

Address Arthur's comments

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/deduct_F.fail.cpp

19

There's no issue yet. I'll add it when I get a number.

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

112

Good catches.

libcxx/include/functional

public:
     R operator()(ArgTypes...) const;
 
     // function target access:
     const std::type_info& target_type() const noexcept;
     template <typename T>       T* target() noexcept;
     template <typename T> const T* target() const noexcept;
 };
 
+// Deduction guides
+template<class R, class ...Args>
+function(R(*)(Args...)) -> function<R(Args...)>; // since C++17
+
+template<class F>
+function(F) -> function<see-below>; // since C++17
+
 // Null pointer comparisons:
 template <class R, class ... ArgTypes>
   bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
 
 template <class R, class ... ArgTypes>
   bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
 
 template <class R, class ... ArgTypes>

 #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 _Rp, class ..._Ap>
+function(_Rp(*)(_Ap...)) -> function<_Rp(_Ap...)>;
+
+template<class _Fp>
+struct __strip_signature;
+
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...)> { using type = _Rp(_Ap...); };
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) const> { using type = _Rp(_Ap...); };
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) volatile> { using type = _Rp(_Ap...); };
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) const volatile> { using type = _Rp(_Ap...); };
+
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) &> { using type = _Rp(_Ap...); };
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) const &> { using type = _Rp(_Ap...); };
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) volatile &> { using type = _Rp(_Ap...); };
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) const volatile &> { using type = _Rp(_Ap...); };
+
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) noexcept> { using type = _Rp(_Ap...); };
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) const noexcept> { using type = _Rp(_Ap...); };
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) volatile noexcept> { using type = _Rp(_Ap...); };
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) const volatile noexcept> { using type = _Rp(_Ap...); };
+
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) & noexcept> { using type = _Rp(_Ap...); };
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) const & noexcept> { using type = _Rp(_Ap...); };
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) volatile & noexcept> { using type = _Rp(_Ap...); };
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) const volatile & noexcept> { using type = _Rp(_Ap...); };
+
+template<class _Fp, class _Stripped = typename __strip_signature<decltype(&_Fp::operator())>::type>
+function(_Fp) -> function<_Stripped>;
+#endif // !_LIBCPP_HAS_NO_DEDUCTION_GUIDES
+
 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_) {}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/deduct_F.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>
+
+// template<class F>
+// function(F) -> function<see-below>;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+// UNSUPPORTED: libcpp-no-deduction-guides
+
+// The deduction guides for std::function do not handle rvalue-ref qualified
+// call operators and C-style variadics. It also doesn't deduce from nullptr_t.
+// Make sure we stick to the specification.
+
+#include <functional>
+#include <type_traits>
+
+
+struct R { };
+struct f0 { R operator()() && { return {}; } };
+struct f1 { R operator()(int, ...) { return {}; } };
+
+int main() {
+    std::function f = f0{}; // expected-error{{no viable constructor or deduction guide for deduction of template arguments of 'function'}}
+    std::function g = f1{}; // expected-error{{no viable constructor or deduction guide for deduction of template arguments of 'function'}}
+    std::function h = nullptr; // expected-error{{no viable constructor or deduction guide for deduction of template arguments of 'function'}}
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/deduct_F.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>
+
+// template<class F>
+// function(F) -> function<see-below>;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+// UNSUPPORTED: libcpp-no-deduction-guides
+
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+#include "test_macros.h"
+
+
+struct R { };
+struct A1 { };
+struct A2 { };
+struct A3 { };
+
+#define DECLARE_FUNCTIONS_WITH_QUALS(N, ...)                              \
+  struct f0_##N  { R operator()() __VA_ARGS__           { return {}; } }; \
+  struct f1_##N  { R operator()(A1) __VA_ARGS__         { return {}; } }; \
+  struct f2_##N  { R operator()(A1, A2) __VA_ARGS__     { return {}; } }; \
+  struct f3_##N  { R operator()(A1, A2, A3) __VA_ARGS__ { return {}; } }  \
+/**/
+
+DECLARE_FUNCTIONS_WITH_QUALS(0, /* nothing */);
+DECLARE_FUNCTIONS_WITH_QUALS(1, const);
+DECLARE_FUNCTIONS_WITH_QUALS(2, volatile);
+DECLARE_FUNCTIONS_WITH_QUALS(3, const volatile);
+DECLARE_FUNCTIONS_WITH_QUALS(4, &);
+DECLARE_FUNCTIONS_WITH_QUALS(5 , const &);
+DECLARE_FUNCTIONS_WITH_QUALS(6 , volatile &);
+DECLARE_FUNCTIONS_WITH_QUALS(7 , const volatile &);
+DECLARE_FUNCTIONS_WITH_QUALS(8 , noexcept);
+DECLARE_FUNCTIONS_WITH_QUALS(9 , const noexcept);
+DECLARE_FUNCTIONS_WITH_QUALS(10, volatile noexcept);
+DECLARE_FUNCTIONS_WITH_QUALS(11, const volatile noexcept);
+DECLARE_FUNCTIONS_WITH_QUALS(12, & noexcept);
+DECLARE_FUNCTIONS_WITH_QUALS(13, const & noexcept);
+DECLARE_FUNCTIONS_WITH_QUALS(14, volatile & noexcept);
+DECLARE_FUNCTIONS_WITH_QUALS(15, const volatile & noexcept);
+
+int main() {
+#define CHECK_FUNCTIONS(N)                                                    \
+  do {                                                                        \
+    /* implicit */                                                            \
+    std::function g0 = f0_##N{};                                              \
+    ASSERT_SAME_TYPE(decltype(g0), std::function<R()>);                       \
+                                                                              \
+    std::function g1 = f1_##N{};                                              \
+    ASSERT_SAME_TYPE(decltype(g1), std::function<R(A1)>);                     \
+                                                                              \
+    std::function g2 = f2_##N{};                                              \
+    ASSERT_SAME_TYPE(decltype(g2), std::function<R(A1, A2)>);                 \
+                                                                              \
+    std::function g3 = f3_##N{};                                              \
+    ASSERT_SAME_TYPE(decltype(g3), std::function<R(A1, A2, A3)>);             \
+                                                                              \
+    /* explicit */                                                            \
+    std::function g4{f0_##N{}};                                               \
+    ASSERT_SAME_TYPE(decltype(g4), std::function<R()>);                       \
+                                                                              \
+    std::function g5{f1_##N{}};                                               \
+    ASSERT_SAME_TYPE(decltype(g5), std::function<R(A1)>);                     \
+                                                                              \
+    std::function g6{f2_##N{}};                                               \
+    ASSERT_SAME_TYPE(decltype(g6), std::function<R(A1, A2)>);                 \
+                                                                              \
+    std::function g7{f3_##N{}};                                               \
+    ASSERT_SAME_TYPE(decltype(g7), std::function<R(A1, A2, A3)>);             \
+                                                                              \
+    /* from std::function */                                                  \
+    std::function<R(A1)> unary;                                               \
+    std::function g8 = unary;                                                 \
+    ASSERT_SAME_TYPE(decltype(g8), std::function<R(A1)>);                     \
+                                                                              \
+    std::function g9 = std::move(unary);                                      \
+    ASSERT_SAME_TYPE(decltype(g9), std::function<R(A1)>);                     \
+                                                                              \
+    std::function<R(A1&&)> unary_ref;                                         \
+    std::function g10 = unary_ref;                                            \
+    ASSERT_SAME_TYPE(decltype(g10), std::function<R(A1&&)>);                  \
+                                                                              \
+    std::function g11 = std::move(unary_ref);                                 \
+    ASSERT_SAME_TYPE(decltype(g11), std::function<R(A1&&)>);                  \
+  } while (false)                                                             \
+/**/
+
+  // Make sure we can deduce from function objects with valid call operators
+  CHECK_FUNCTIONS(0);
+  CHECK_FUNCTIONS(1);
+  CHECK_FUNCTIONS(2);
+  CHECK_FUNCTIONS(3);
+  CHECK_FUNCTIONS(4);
+  CHECK_FUNCTIONS(5);
+  CHECK_FUNCTIONS(6);
+  CHECK_FUNCTIONS(7);
+  CHECK_FUNCTIONS(8);
+  CHECK_FUNCTIONS(9);
+  CHECK_FUNCTIONS(10);
+  CHECK_FUNCTIONS(11);
+  CHECK_FUNCTIONS(12);
+  CHECK_FUNCTIONS(13);
+  CHECK_FUNCTIONS(14);
+  CHECK_FUNCTIONS(15);
+}
+
+// Make sure we fail in a SFINAE-friendly manner when we try to deduce
+// from a type without a valid call operator.
+template <typename F, typename = decltype(std::function{std::declval<F>()})>
+constexpr bool can_deduce() { return true; }
+template <typename F>
+constexpr bool can_deduce(...) { return false; }
+
+struct invalid1 { };
+struct invalid2 {
+  template <typename ...Args>
+  void operator()(Args ...);
+};
+struct invalid3 {
+  void operator()(int);
+  void operator()(long);
+};
+static_assert(!can_deduce<invalid1>());
+static_assert(!can_deduce<invalid2>());
+static_assert(!can_deduce<invalid3>());

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/deduct_ptr.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>
+
+// template<class R, class ...Args>
+// function(R(*)(Args...)) -> function<R(Args...)>;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+// UNSUPPORTED: libcpp-no-deduction-guides
+
+#include <functional>
+#include <type_traits>
+
+#include "test_macros.h"
+
+
+struct R { };
+struct A1 { };
+struct A2 { };
+struct A3 { };
+
+R f0() { return {}; }
+R f1(A1) { return {}; }
+R f2(A1, A2) { return {}; }
+R f3(A1, A2, A3) { return {}; }
+R f4(A1 = {}) { return {}; }
+
+int main() {
+  {
+    // implicit
+    std::function a = f0;
+    ASSERT_SAME_TYPE(decltype(a), std::function<R()>);
+
+    std::function b = &f0;
+    ASSERT_SAME_TYPE(decltype(b), std::function<R()>);
+
+    // explicit
+    std::function c{f0};
+    ASSERT_SAME_TYPE(decltype(c), std::function<R()>);
+
+    std::function d{&f0};
+    ASSERT_SAME_TYPE(decltype(d), std::function<R()>);
+  }
+  {
+    // implicit
+    std::function a = f1;
+    ASSERT_SAME_TYPE(decltype(a), std::function<R(A1)>);
+
+    std::function b = &f1;
+    ASSERT_SAME_TYPE(decltype(b), std::function<R(A1)>);
+
+    // explicit
+    std::function c{f1};
+    ASSERT_SAME_TYPE(decltype(c), std::function<R(A1)>);
+
+    std::function d{&f1};
+    ASSERT_SAME_TYPE(decltype(d), std::function<R(A1)>);
+  }
+  {
+    // implicit
+    std::function a = f2;
+    ASSERT_SAME_TYPE(decltype(a), std::function<R(A1, A2)>);
+
+    std::function b = &f2;
+    ASSERT_SAME_TYPE(decltype(b), std::function<R(A1, A2)>);
+
+    // explicit
+    std::function c{f2};
+    ASSERT_SAME_TYPE(decltype(c), std::function<R(A1, A2)>);
+
+    std::function d{&f2};
+    ASSERT_SAME_TYPE(decltype(d), std::function<R(A1, A2)>);
+  }
+  {
+    // implicit
+    std::function a = f3;
+    ASSERT_SAME_TYPE(decltype(a), std::function<R(A1, A2, A3)>);
+
+    std::function b = &f3;
+    ASSERT_SAME_TYPE(decltype(b), std::function<R(A1, A2, A3)>);
+
+    // explicit
+    std::function c{f3};
+    ASSERT_SAME_TYPE(decltype(c), std::function<R(A1, A2, A3)>);
+
+    std::function d{&f3};
+    ASSERT_SAME_TYPE(decltype(d), std::function<R(A1, A2, A3)>);
+  }
+  // Make sure defaulted arguments don't mess up the deduction
+  {
+    // implicit
+    std::function a = f4;
+    ASSERT_SAME_TYPE(decltype(a), std::function<R(A1)>);
+
+    std::function b = &f4;
+    ASSERT_SAME_TYPE(decltype(b), std::function<R(A1)>);
+
+    // explicit
+    std::function c{f4};
+    ASSERT_SAME_TYPE(decltype(c), std::function<R(A1)>);
+
+    std::function d{&f4};
+    ASSERT_SAME_TYPE(decltype(d), std::function<R(A1)>);
+  }
+}