[libc++] Use placeholder return types to avoid hard errors during overload resolution

[Arcoth]

Summary

See https://bugs.llvm.org/show_bug.cgi?id=32856. Basically, as this code was written before placeholder return types for functions were a
thing, the function call operators of bind apply decltype on the call expression to infer the return type. This can lead to hard errors when we pass
template functors. Another consequence of this is that the validity or invalidity of these call expressions influences overload resolution (via
SFINAE), hence the const version could be selected where the bind object was non-const, which is not the prescribed behaviour. This is fixed by
using placeholder return types.

[EricWF]

Please add a test for this.

[EricWF]

This change regresses other code. By changing __bind_return<...>::type into decltype(auto) you prevent the member functions from SFINAE'ing. For example:

#include <functional>

struct Func {
  template <class ...Args>
  void operator()(Args&&...) = delete;

  template <class ...Args>
  void operator()(Args&&...) const {}
};

int main() {
    Func f;
    std::bind(f)(); // Broken after your change.
}

This patch cannot introduce regressions but changing to using decltype(auto) does. I'm not sure the behavior you want is possible. The library is required to evaluate the validity of calling the specified functor in the signature of the call operator in order to correctly SFINAE.
I think this makes accepting the code in PR32856 impossible.

[Arcoth]

In D32824#745392, @EricWF wrote:

This change regresses other code. By changing __bind_return<...>::type into decltype(auto) you prevent the member functions from SFINAE'ing. For example:

#include <functional>

struct Func {
  template <class ...Args>
  void operator()(Args&&...) = delete;

  template <class ...Args>
  void operator()(Args&&...) const {}
};

int main() {
    Func f;
    std::bind(f)(); // Broken after your change.
}

This patch cannot introduce regressions but changing to using decltype(auto) does. I'm not sure the behavior you want is possible. The library is required to evaluate the validity of calling the specified functor in the signature of the call operator in order to correctly SFINAE.
I think this makes accepting the code in PR32856 impossible.

This is intended to fail (as I also mentioned in the motivating SO post). The type of the object argument fd is FD, where FD is decay_t<Func>, i.e. Func. That's it. For non-const object arguments, overload resolution prefers non-const member functions per se, hence we should e.g. get a diagnostic saying that a deleted function is called. Alternatively, some other construct inside bind should fail: libstdc++'s bind somehow requires result_of_t<Func&()>, which fails.

In short, this was never well-formed; the fact that it compiled is a consequence of the return type being denoted in an expression SFINAE manner.

include/functional

 template <class _Predicate>
 class _LIBCPP_TEMPLATE_VIS binary_negate
     : public binary_function<typename _Predicate::first_argument_type,
                              typename _Predicate::second_argument_type,
                              bool>
 {
     _Predicate __pred_;
 public:
-    _LIBCPP_INLINE_VISIBILITY explicit _LIBCPP_CONSTEXPR_AFTER_CXX11 
+    _LIBCPP_INLINE_VISIBILITY explicit _LIBCPP_CONSTEXPR_AFTER_CXX11
     binary_negate(const _Predicate& __pred) : __pred_(__pred) {}
 
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const typename _Predicate::first_argument_type& __x,
                     const typename _Predicate::second_argument_type& __y) const
         {return !__pred_(__x, __y);}
 };
 
function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f)
     : __f_(0)
 {
     typedef allocator_traits<_Alloc> __alloc_traits;
     if (__function::__not_null(__f))
     {
         typedef __function::__func<_Fp, _Alloc, _Rp(_ArgTypes...)> _FF;
         typedef typename __rebind_alloc_helper<__alloc_traits, _FF>::type _Ap;
         _Ap __a(__a0);
-        if (sizeof(_FF) <= sizeof(__buf_) && 
+        if (sizeof(_FF) <= sizeof(__buf_) &&
             is_nothrow_copy_constructible<_Fp>::value && is_nothrow_copy_constructible<_Ap>::value)
         {
             __f_ = ::new((void*)&__buf_) _FF(_VSTD::move(__f), _Alloc(__a));
         }
         else
         {
             typedef __allocator_destructor<_Ap> _Dp;
             unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
template <class _Gp, class ..._BA,
                                >::type>
       _LIBCPP_INLINE_VISIBILITY
       explicit __bind(_Gp&& __f, _BA&& ...__bound_args)
         : __f_(_VSTD::forward<_Gp>(__f)),
           __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {}
 
     template <class ..._Args>
         _LIBCPP_INLINE_VISIBILITY
+#ifndef __cpp_decltype_auto
         typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type
+#else
+        decltype(auto)
+#endif
         operator()(_Args&& ...__args)
         {
             return __apply_functor(__f_, __bound_args_, __indices(),
                                   tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
         }
 
     template <class ..._Args>
         _LIBCPP_INLINE_VISIBILITY
+#ifndef __cpp_decltype_auto
         typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type
+#else
+        decltype(auto)
+#endif
         operator()(_Args&& ...__args) const
         {
             return __apply_functor(__f_, __bound_args_, __indices(),
                                    tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
         }
 };
 
 template<class _Fp, class ..._BoundArgs>