[libc++] Refactor __perfect_forward, bind_front and not_fn

[ldionne]

Summary

This patch fixes the constrains on the __perfect_forward constructor
and its call operators, which were incorrect. In particular, it makes
sure that we closely follow [func.require], which basically says that
we must deliver the bound arguments with the appropriate value category
or make the call ill-formed, but not silently fall back to using a
different value category.

As a fly-by, this patch also:

• Adds types bind_front_t and not_fn_t to make the result of calling bind_front and not_fn more opaque, and improve diagnostics for users.
• Adds a bunch of tests for bind_front and remove some that are now redundant.
• Adds some missing _LIBCPP_HIDE_FROM_ABI annotations.

Immense thanks to @tcanens for raising awareness about this issue, and
providing help with the = delete bits.

[zoecarver]

Nothing major. This looks good to me!

libcxx/include/__functional/bind_front.h

42

Nit: _And

libcxx/include/__functional/perfect_forward.h

36–84

This makes me wonder if we should replace __call with operator() and then we can just use is_invocable here. I guess we could really do that anyway, though.

36–84

Concepts would make a lot of this a lot easier :(

76

Shouldn't tuple be an xvalue here, not a prvalue? Or am I just confused?

[• Quuxplusone]

If buildkite is happy, I'm happy.

libcxx/include/__functional/bind_front.h

26–33

FWIW, I'd prefer to see lines 31-33 all indented one level (4 spaces).
Alternatively, would it make sense to pull _LIBCPP_EXPRESSION_EQUIVALENT into <__config> or <type_traits> and then be able to use it here and below?

27

I'd call this whitespace wrong. (Did clang-format do this?) template<class... Ts> is better than template<class ...Ts>.

libcxx/include/__functional/not_fn.h

25–32

Again FWIW I'd prefer 4 spaces in front of lines 30-32.

libcxx/include/__functional/perfect_forward.h

76

The trick is that declval<_Tuple>() on line 42 always returns _Tuple&&. So adding another && here on line 82 would be harmless but also unnecessary.

89

Nit: I'd make this just [func.require], not a full URL.

libcxx/test/std/utilities/function.objects/func.bind_front/bind_front.pass.cpp

407–412

(1) Surely s/tests/test/?
(2) I notice a lack of tests verifying no-special-treatment-of-std::reference_wrapper-arguments. Maybe consider adding one.

[mclow.lists]

libcxx/include/__functional/bind_front.h

26–33

Historical note: I thought several times about writing something like _LIBCPP_EXPRESSION_EQUIVALENT for use with less, greater, etc., and always decided that it reduced the readability of the code.

[ldionne]

Address review comments

libcxx/include/__functional/bind_front.h

26–33

I'm going to shed the discussion on _LIBCPP_EXPRESSION_EQUIVALENT for now in order to make progress. If we want to use it, we can do so in a trivial follow-up patch.

27

We're quite inconsistent about this in the library. I used template<...> because I think I've seen it more often and wanted to be consistent, but I agree template <...> is better. Changed.

libcxx/include/__functional/perfect_forward.h

36–84

Yeah, I think it does work actually. Please take a look at my new implementation, I think it's much simpler now.

[ldionne]

I'll ship this once CI passes based on reviewer approvals.

[• Quuxplusone]

libcxx/include/__functional/bind_front.h

27

Heh, personally I prefer template< over template < (although the latter is libc++ style), so "agree" is the wrong word. :)

But I was talking about template <class... _Args> versus template <class ..._Args>. You've still got the latter on line 28. I'd like to see the former.

[• Quuxplusone]

libcxx/include/__functional/perfect_forward.h

36–84

Per my "When Should You Give Two Things the Same Name?", you know I'm leery of giving this detail the same name as the ordinary call operator. Do we ever publicly inherit from __perfect_forward_impl, or do anything else where the user-programmer might observe that foo(1,2,3) works when it shouldn't?
(Whereas the user-programmer is not allowed to observe that foo.__call(1,2,3) works, because __call is a reserved name.)
However, I'm not asking for it to be changed back unless someone (not me) comes up with the actual concrete example that proves why the name operator() can't be used. I'm just betting that such an example exists.

[miscco]

libcxx/include/__functional/perfect_forward.h

44–48

Is it necessary to default those? they should be compiler generated anyway

[ldionne]

libcxx/include/__functional/bind_front.h

27

Oops, I read that too fast.

Regarding template <class... _Args> versus template <class ..._Args>: When an ellipse appears to the left of a parameter, it declares a parameter pack. When placed to the right, it expands the parameter pack (see https://docs.microsoft.com/en-us/cpp/cpp/ellipses-and-variadic-templates?view=msvc-160#syntax). I've always used the convention of declaring parameter packs with ...args because it follows most naturally from that. Using class... Args makes it look like we're expanding the parameter pack class, which is not what's happening. Of course, it's all just whitespace and both ways are equivalent, but IMO using class ...Args conveys better what we're doing based on the syntax of the language.

libcxx/include/__functional/perfect_forward.h

36–84

Just for the record, I didn't change __perfect_forward::__call to __perfect_forward::operator(). It's always been operator(), and that's important because the intent is for it to be inherited and provide its base class with an operator().

The change was to go from _Op::__call to _Op::operator() in order to be able to reuse std::is_invocable instead of rolling our own. But _Op is an internal-only helper and we never inherit from it.

44–48

I think I added them because some test was failing, however logic would dictate that they are not necessary. And to be sure, I removed them, ran the tests again and everything succeeded, so we could remove them.

However, I kind of like defaulting them explicitly since it reduces the cognitive burden (for me at least) of checking whether the compiler will generate them or not. LMK if you'd much rather remove them.

[• Quuxplusone]

(Phab is listing several of my comments as "unsubmitted" but I think that's just a glitch. Sorry if I'm resubmitting comments and/or some of these comments look obsolete now.)

libcxx/include/__functional/bind_front.h

27

I remember thinking that way back in the 2012-2015 timeframe; but these days class... Ts is just so much easier on the eyes; and it's certainly libc++ style. The syntax situation is of course exactly analogous to const _Tp& __t versus const _Tp &__t, or for that matter _Tp const &__t: there's "the way everyone actually likes to see it" and then "the way that reflects the history of the syntax."

libcxx/include/__functional/perfect_forward.h

36–84

Ah. SGTM then.

libcxx/include/__functional/bind_front.h

 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
-struct __bind_front_op
-{
-    template<class... _Args>
-    constexpr static auto __call(_Args&&... __args)
+struct __bind_front_op {
+    template <class ..._Args>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator()(_Args&& ...__args) const
         noexcept(noexcept(_VSTD::invoke(_VSTD::forward<_Args>(__args)...)))
         -> decltype(      _VSTD::invoke(_VSTD::forward<_Args>(__args)...))
         { return          _VSTD::invoke(_VSTD::forward<_Args>(__args)...); }
 };
 
-template<class _Fn, class... _Args,
-         class = _EnableIf<conjunction<is_constructible<decay_t<_Fn>, _Fn>,
-                                       is_move_constructible<decay_t<_Fn>>,
-                                       is_constructible<decay_t<_Args>, _Args>...,
-                                       is_move_constructible<decay_t<_Args>>...
-                                       >::value>>
-constexpr auto bind_front(_Fn&& __f, _Args&&... __args)
-{
-    return __perfect_forward<__bind_front_op, _Fn, _Args...>(_VSTD::forward<_Fn>(__f),
-                                                             _VSTD::forward<_Args>(__args)...);
+template <class _Fn, class ..._BoundArgs>
+struct __bind_front_t : __perfect_forward<__bind_front_op, _Fn, _BoundArgs...> {
+    using __perfect_forward<__bind_front_op, _Fn, _BoundArgs...>::__perfect_forward;
+};
+
+template <class _Fn, class... _Args, class = _EnableIf<
+    _And<
+        is_constructible<decay_t<_Fn>, _Fn>,
+    >::value
+>>
+_LIBCPP_HIDE_FROM_ABI
+constexpr auto bind_front(_Fn&& __f, _Args&&... __args) {
+    return __bind_front_t<decay_t<_Fn>, decay_t<_Args>...>(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...);
 }
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FUNCTIONAL_BIND_FRONT_H

libcxx/include/__functional/not_fn.h

 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
 
-struct __not_fn_op
-{
-    template<class... _Args>
-    static _LIBCPP_CONSTEXPR_AFTER_CXX17 auto __call(_Args&&... __args)
+struct __not_fn_op {
+    template <class... _Args>
+    _LIBCPP_HIDE_FROM_ABI
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 auto operator()(_Args&&... __args) const
         noexcept(noexcept(!_VSTD::invoke(_VSTD::forward<_Args>(__args)...)))
         -> decltype(      !_VSTD::invoke(_VSTD::forward<_Args>(__args)...))
         { return          !_VSTD::invoke(_VSTD::forward<_Args>(__args)...); }
 };
 
-template<class _Fn,
-         class = _EnableIf<is_constructible_v<decay_t<_Fn>, _Fn> &&
-                           is_move_constructible_v<_Fn>>>
-_LIBCPP_CONSTEXPR_AFTER_CXX17 auto not_fn(_Fn&& __f)
-{
-    return __perfect_forward<__not_fn_op, _Fn>(_VSTD::forward<_Fn>(__f));
+template <class _Fn>
+struct __not_fn_t : __perfect_forward<__not_fn_op, _Fn> {
+    using __perfect_forward<__not_fn_op, _Fn>::__perfect_forward;
+};
+
+template <class _Fn, class = _EnableIf<
+    is_constructible_v<decay_t<_Fn>, _Fn> &&
+    is_move_constructible_v<decay_t<_Fn>>
+>>
+_LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR_AFTER_CXX17 auto not_fn(_Fn&& __f) {
+    return __not_fn_t<decay_t<_Fn>>(_VSTD::forward<_Fn>(__f));
 }
 
 #endif // _LIBCPP_STD_VER > 14
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FUNCTIONAL_NOT_FN_H

libcxx/include/__functional/perfect_forward.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FUNCTIONAL_PERFECT_FORWARD_H
 #define _LIBCPP___FUNCTIONAL_PERFECT_FORWARD_H
 
 #include <__config>
+#include <__utility/declval.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
 #include <tuple>
 #include <type_traits>
-#include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
 
-template<class _Op, class _Tuple,
-         class _Idxs = typename __make_tuple_indices<tuple_size<_Tuple>::value>::type>
+template <class _Op, class _Indices, class ..._Bound>
 struct __perfect_forward_impl;
 
-template<class _Op, class... _Bound, size_t... _Idxs>
-struct __perfect_forward_impl<_Op, __tuple_types<_Bound...>, __tuple_indices<_Idxs...>>
-{
+template <class _Op, size_t ..._Idx, class ..._Bound>
+struct __perfect_forward_impl<_Op, index_sequence<_Idx...>, _Bound...> {
+private:
     tuple<_Bound...> __bound_;
 
-    template<class... _Args>
-    _LIBCPP_INLINE_VISIBILITY constexpr auto operator()(_Args&&... __args) &
-    noexcept(noexcept(_Op::__call(_VSTD::get<_Idxs>(__bound_)..., _VSTD::forward<_Args>(__args)...)))
-    -> decltype(      _Op::__call(_VSTD::get<_Idxs>(__bound_)..., _VSTD::forward<_Args>(__args)...))
-    {return           _Op::__call(_VSTD::get<_Idxs>(__bound_)..., _VSTD::forward<_Args>(__args)...);}
-
-    template<class... _Args>
-    _LIBCPP_INLINE_VISIBILITY constexpr auto operator()(_Args&&... __args) const&
-    noexcept(noexcept(_Op::__call(_VSTD::get<_Idxs>(__bound_)..., _VSTD::forward<_Args>(__args)...)))
-    -> decltype(      _Op::__call(_VSTD::get<_Idxs>(__bound_)..., _VSTD::forward<_Args>(__args)...))
-    {return           _Op::__call(_VSTD::get<_Idxs>(__bound_)..., _VSTD::forward<_Args>(__args)...);}
-
-    template<class... _Args>
-    _LIBCPP_INLINE_VISIBILITY constexpr auto operator()(_Args&&... __args) &&
-    noexcept(noexcept(_Op::__call(_VSTD::get<_Idxs>(_VSTD::move(__bound_))...,
-                                  _VSTD::forward<_Args>(__args)...)))
-    -> decltype(      _Op::__call(_VSTD::get<_Idxs>(_VSTD::move(__bound_))...,
-                                  _VSTD::forward<_Args>(__args)...))
-    {return           _Op::__call(_VSTD::get<_Idxs>(_VSTD::move(__bound_))...,
-                                  _VSTD::forward<_Args>(__args)...);}
-
-    template<class... _Args>
-    _LIBCPP_INLINE_VISIBILITY constexpr auto operator()(_Args&&... __args) const&&
-    noexcept(noexcept(_Op::__call(_VSTD::get<_Idxs>(_VSTD::move(__bound_))...,
-                                  _VSTD::forward<_Args>(__args)...)))
-    -> decltype(      _Op::__call(_VSTD::get<_Idxs>(_VSTD::move(__bound_))...,
-                                  _VSTD::forward<_Args>(__args)...))
-    {return           _Op::__call(_VSTD::get<_Idxs>(_VSTD::move(__bound_))...,
-                                  _VSTD::forward<_Args>(__args)...);}
-
-    template<class _Fn = typename tuple_element<0, tuple<_Bound...>>::type,
-             class = _EnableIf<is_copy_constructible_v<_Fn>>>
-    constexpr __perfect_forward_impl(__perfect_forward_impl const& __other)
-        : __bound_(__other.__bound_) {}
-
-    template<class _Fn = typename tuple_element<0, tuple<_Bound...>>::type,
-             class = _EnableIf<is_move_constructible_v<_Fn>>>
-    constexpr __perfect_forward_impl(__perfect_forward_impl && __other)
-        : __bound_(_VSTD::move(__other.__bound_)) {}
-
-    template<class... _BoundArgs>
-    explicit constexpr __perfect_forward_impl(_BoundArgs&&... __bound) :
-        __bound_(_VSTD::forward<_BoundArgs>(__bound)...) { }
+public:
+    template <class ..._BoundArgs, class = _EnableIf<
+        is_constructible_v<tuple<_Bound...>, _BoundArgs&&...>
+    >>
+    explicit constexpr __perfect_forward_impl(_BoundArgs&& ...__bound)
+        : __bound_(_VSTD::forward<_BoundArgs>(__bound)...)
+    { }
+
+    __perfect_forward_impl(__perfect_forward_impl const&) = default;
+    __perfect_forward_impl(__perfect_forward_impl&&) = default;
+
+    __perfect_forward_impl& operator=(__perfect_forward_impl const&) = default;
+    __perfect_forward_impl& operator=(__perfect_forward_impl&&) = default;
+
+    template <class ..._Args, class = _EnableIf<is_invocable_v<_Op, _Bound&..., _Args...>>>
+    _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Args&&... __args) &
+        noexcept(noexcept(_Op()(_VSTD::get<_Idx>(__bound_)..., _VSTD::forward<_Args>(__args)...)))
+        -> decltype(      _Op()(_VSTD::get<_Idx>(__bound_)..., _VSTD::forward<_Args>(__args)...))
+        { return          _Op()(_VSTD::get<_Idx>(__bound_)..., _VSTD::forward<_Args>(__args)...); }
+
+    template <class ..._Args, class = _EnableIf<!is_invocable_v<_Op, _Bound&..., _Args...>>>
+    auto operator()(_Args&&...) & = delete;
+
+    template <class ..._Args, class = _EnableIf<is_invocable_v<_Op, _Bound const&..., _Args...>>>
+    _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Args&&... __args) const&
+        noexcept(noexcept(_Op()(_VSTD::get<_Idx>(__bound_)..., _VSTD::forward<_Args>(__args)...)))
+        -> decltype(      _Op()(_VSTD::get<_Idx>(__bound_)..., _VSTD::forward<_Args>(__args)...))
+        { return          _Op()(_VSTD::get<_Idx>(__bound_)..., _VSTD::forward<_Args>(__args)...); }
+
+    template <class ..._Args, class = _EnableIf<!is_invocable_v<_Op, _Bound const&..., _Args...>>>
+    auto operator()(_Args&&...) const& = delete;
+
+    template <class ..._Args, class = _EnableIf<is_invocable_v<_Op, _Bound..., _Args...>>>
+    _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Args&&... __args) &&
+        noexcept(noexcept(_Op()(_VSTD::get<_Idx>(_VSTD::move(__bound_))..., _VSTD::forward<_Args>(__args)...)))
+        -> decltype(      _Op()(_VSTD::get<_Idx>(_VSTD::move(__bound_))..., _VSTD::forward<_Args>(__args)...))
+        { return          _Op()(_VSTD::get<_Idx>(_VSTD::move(__bound_))..., _VSTD::forward<_Args>(__args)...); }
+
+    template <class ..._Args, class = _EnableIf<!is_invocable_v<_Op, _Bound..., _Args...>>>
+    auto operator()(_Args&&...) && = delete;
+
+    template <class ..._Args, class = _EnableIf<is_invocable_v<_Op, _Bound const..., _Args...>>>
+    _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Args&&... __args) const&&
+        noexcept(noexcept(_Op()(_VSTD::get<_Idx>(_VSTD::move(__bound_))..., _VSTD::forward<_Args>(__args)...)))
+        -> decltype(      _Op()(_VSTD::get<_Idx>(_VSTD::move(__bound_))..., _VSTD::forward<_Args>(__args)...))
+        { return          _Op()(_VSTD::get<_Idx>(_VSTD::move(__bound_))..., _VSTD::forward<_Args>(__args)...); }
+
+    template <class ..._Args, class = _EnableIf<!is_invocable_v<_Op, _Bound const..., _Args...>>>
+    auto operator()(_Args&&...) const&& = delete;
 };
 
-template<class _Op, class... _Args>
-using __perfect_forward =
-    __perfect_forward_impl<_Op, __tuple_types<decay_t<_Args>...>>;
+// __perfect_forward implements a perfect-forwarding call wrapper as explained in [func.require].
+template <class _Op, class ..._Args>
+using __perfect_forward = __perfect_forward_impl<_Op, index_sequence_for<_Args...>, _Args...>;
 
 #endif // _LIBCPP_STD_VER > 14
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FUNCTIONAL_PERFECT_FORWARD_H

libcxx/test/std/utilities/function.objects/func.bind_front/bind_front.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++03, c++11, c++14, c++17
 
 // functional
 
-// template <class F, class... Args> constexpr unspecified bind_front(F&&, Args&&...);
+// template <class F, class... Args>
+// constexpr unspecified bind_front(F&&, Args&&...);
 
 #include <functional>
+#include <cassert>
+#include <tuple>
+#include <type_traits>
+#include <utility>
 
 #include "callable_types.h"
 #include "test_macros.h"
 
-constexpr int add(int a, int b) { return a + b; }
+struct CopyMoveInfo {
+  enum { none, copy, move } copy_kind;
 
-constexpr int long_test(int a, int b, int c, int d, int e, int f) {
-  return a + b + c + d + e + f;
-}
+  constexpr CopyMoveInfo() : copy_kind(none) {}
+  constexpr CopyMoveInfo(CopyMoveInfo const&) : copy_kind(copy) {}
+  constexpr CopyMoveInfo(CopyMoveInfo&&) : copy_kind(move) {}
+};
+
+template <class ...Args>
+struct is_bind_frontable {
+  template <class ...LocalArgs>
+  static auto test(int)
+      -> decltype((void)std::bind_front(std::declval<LocalArgs>()...), std::true_type());
+
+  template <class...>
+  static std::false_type test(...);
 
-struct Foo {
-  int a;
-  int b;
+  static constexpr bool value = decltype(test<Args...>(0))::value;
+};
+
+struct NotCopyMove {
+  NotCopyMove() = delete;
+  NotCopyMove(const NotCopyMove&) = delete;
+  NotCopyMove(NotCopyMove&&) = delete;
+  template <class ...Args>
+  void operator()(Args&& ...) const { }
 };
 
-struct FooCall {
-  constexpr Foo operator()(int a, int b) { return Foo{a, b}; }
+struct NonConstCopyConstructible {
+  explicit NonConstCopyConstructible() {}
+  NonConstCopyConstructible(NonConstCopyConstructible&) {}
 };
 
-struct S {
-  constexpr bool operator()(int a) { return a == 1; }
+struct MoveConstructible {
+  explicit MoveConstructible() {}
+  MoveConstructible(MoveConstructible&&) {}
 };
 
-struct CopyMoveInfo {
-  enum { none, copy, move } copy_kind;
+struct MakeTuple {
+  template <class ...Args>
+  constexpr auto operator()(Args&& ...args) const {
+    return std::make_tuple(std::forward<Args>(args)...);
+  }
+};
 
-  constexpr CopyMoveInfo() : copy_kind(none) {}
-  constexpr CopyMoveInfo(CopyMoveInfo const&) : copy_kind(copy) {}
-  constexpr CopyMoveInfo(CopyMoveInfo&&) : copy_kind(move) {}
+template <int X>
+struct Elem {
+  template <int Y>
+  constexpr bool operator==(Elem<Y> const&) const
+  { return X == Y; }
 };
 
-constexpr bool wasCopied(CopyMoveInfo info) {
-  return info.copy_kind == CopyMoveInfo::copy;
+constexpr bool test() {
+  // Bind arguments, call without arguments
+  {
+    {
+      auto f = std::bind_front(MakeTuple{});
+      assert(f() == std::make_tuple());
+    }
+    {
+      auto f = std::bind_front(MakeTuple{}, Elem<1>{});
+      assert(f() == std::make_tuple(Elem<1>{}));
+    }
+    {
+      auto f = std::bind_front(MakeTuple{}, Elem<1>{}, Elem<2>{});
+      assert(f() == std::make_tuple(Elem<1>{}, Elem<2>{}));
+    }
+    {
+      auto f = std::bind_front(MakeTuple{}, Elem<1>{}, Elem<2>{}, Elem<3>{});
+      assert(f() == std::make_tuple(Elem<1>{}, Elem<2>{}, Elem<3>{}));
+    }
+  }
+
+  // Bind no arguments, call with arguments
+  {
+    {
+      auto f = std::bind_front(MakeTuple{});
+      assert(f(Elem<1>{}) == std::make_tuple(Elem<1>{}));
+    }
+    {
+      auto f = std::bind_front(MakeTuple{});
+      assert(f(Elem<1>{}, Elem<2>{}) == std::make_tuple(Elem<1>{}, Elem<2>{}));
+    }
+    {
+      auto f = std::bind_front(MakeTuple{});
+      assert(f(Elem<1>{}, Elem<2>{}, Elem<3>{}) == std::make_tuple(Elem<1>{}, Elem<2>{}, Elem<3>{}));
+    }
+  }
+
+  // Bind arguments, call with arguments
+  {
+    {
+      auto f = std::bind_front(MakeTuple{}, Elem<1>{});
+      assert(f(Elem<10>{}) == std::make_tuple(Elem<1>{}, Elem<10>{}));
+    }
+    {
+      auto f = std::bind_front(MakeTuple{}, Elem<1>{}, Elem<2>{});
+      assert(f(Elem<10>{}) == std::make_tuple(Elem<1>{}, Elem<2>{}, Elem<10>{}));
+    }
+    {
+      auto f = std::bind_front(MakeTuple{}, Elem<1>{}, Elem<2>{}, Elem<3>{});
+      assert(f(Elem<10>{}) == std::make_tuple(Elem<1>{}, Elem<2>{}, Elem<3>{}, Elem<10>{}));
+    }
+
+    {
+      auto f = std::bind_front(MakeTuple{}, Elem<1>{});
+      assert(f(Elem<10>{}, Elem<11>{}) == std::make_tuple(Elem<1>{}, Elem<10>{}, Elem<11>{}));
+    }
+    {
+      auto f = std::bind_front(MakeTuple{}, Elem<1>{}, Elem<2>{});
+      assert(f(Elem<10>{}, Elem<11>{}) == std::make_tuple(Elem<1>{}, Elem<2>{}, Elem<10>{}, Elem<11>{}));
+    }
+    {
+      auto f = std::bind_front(MakeTuple{}, Elem<1>{}, Elem<2>{}, Elem<3>{});
+      assert(f(Elem<10>{}, Elem<11>{}) == std::make_tuple(Elem<1>{}, Elem<2>{}, Elem<3>{}, Elem<10>{}, Elem<11>{}));
     }
-constexpr bool wasMoved(CopyMoveInfo info) {
-  return info.copy_kind == CopyMoveInfo::move;
   }
 
-constexpr void basic_tests() {
+  // Basic tests with fundamental types
+  {
     int n = 2;
     int m = 1;
+    auto add = [](int x, int y) { return x + y; };
+    auto addN = [](int a, int b, int c, int d, int e, int f) {
+      return a + b + c + d + e + f;
+    };
 
     auto a = std::bind_front(add, m, n);
     assert(a() == 3);
 
-  auto b = std::bind_front(long_test, m, n, m, m, m, m);
+    auto b = std::bind_front(addN, m, n, m, m, m, m);
     assert(b() == 7);
 
-  auto c = std::bind_front(long_test, n, m);
+    auto c = std::bind_front(addN, n, m);
     assert(c(1, 1, 1, 1) == 7);
 
-  auto d = std::bind_front(S{}, m);
-  assert(d());
-
     auto f = std::bind_front(add, n);
     assert(f(3) == 5);
 
     auto g = std::bind_front(add, n, 1);
     assert(g() == 3);
 
-  auto h = std::bind_front(long_test, 1, 1, 1);
+    auto h = std::bind_front(addN, 1, 1, 1);
     assert(h(2, 2, 2) == 9);
+  }
+
+  // Make sure we don't treat std::reference_wrapper specially.
+  {
+    auto add = [](std::reference_wrapper<int> a, std::reference_wrapper<int> b) {
+      return a.get() + b.get();
+    };
+    int i = 1, j = 2;
+    auto f = std::bind_front(add, std::ref(i));
+    assert(f(std::ref(j)) == 3);
+  }
+
+  // Make sure we can call a function that's a pointer to a member function.
+  {
+    struct MemberFunction {
+      constexpr bool foo(int, int) { return true; }
+    };
+    MemberFunction value;
+    auto fn = std::bind_front(&MemberFunction::foo, value, 0);
+    assert(fn(0));
+  }
 
-  // Make sure the arg is passed by value.
+  // Make sure that we copy the bound arguments into the unspecified-type.
+  {
+    auto add = [](int x, int y) { return x + y; };
+    int n = 2;
     auto i = std::bind_front(add, n, 1);
     n = 100;
     assert(i() == 3);
+  }
 
+  // Make sure we pass the bound arguments to the function object
+  // with the right value category.
+  {
+    {
+      auto wasCopied = [](CopyMoveInfo info) {
+        return info.copy_kind == CopyMoveInfo::copy;
+      };
       CopyMoveInfo info;
       auto copied = std::bind_front(wasCopied, info);
       assert(copied());
+    }
 
+    {
+      auto wasMoved = [](CopyMoveInfo info) {
+        return info.copy_kind == CopyMoveInfo::move;
+      };
+      CopyMoveInfo info;
       auto moved = std::bind_front(wasMoved, info);
       assert(std::move(moved)());
     }
+  }
 
-struct variadic_fn {
-  template <class... Args>
-  constexpr int operator()(Args&&... args) {
-    return sizeof...(args);
+  // Make sure we call the correctly cv-ref qualified operator() based on the
+  // value category of the bind_front unspecified-type.
+  {
+    struct F {
+      constexpr int operator()() & { return 1; }
+      constexpr int operator()() const& { return 2; }
+      constexpr int operator()() && { return 3; }
+      constexpr int operator()() const&& { return 4; }
+    };
+    auto x = std::bind_front(F{});
+    using X = decltype(x);
+    assert(static_cast<X&>(x)() == 1);
+    assert(static_cast<X const&>(x)() == 2);
+    assert(static_cast<X&&>(x)() == 3);
+    assert(static_cast<X const&&>(x)() == 4);
   }
-};
 
-constexpr void test_variadic() {
-  variadic_fn value;
-  auto fn = std::bind_front(value, 0, 0, 0);
-  assert(fn(0, 0, 0) == 6);
+  // Make sure the bind_front unspecified-type is NOT invocable when the call would select a
+  // differently-qualified operator().
+  //
+  // For example, if the call to `operator()() &` is ill-formed, the call to the unspecified-type
+  // should be ill-formed and not fall back to the `operator()() const&` overload.
+  {
+    // Make sure we delete the & overload when the underlying call isn't valid
+    {
+      struct F {
+        void operator()() & = delete;
+        void operator()() const&;
+        void operator()() &&;
+        void operator()() const&&;
+      };
+      using X = decltype(std::bind_front(F{}));
+      static_assert(!std::is_invocable_v<X&>);
+      static_assert( std::is_invocable_v<X const&>);
+      static_assert( std::is_invocable_v<X>);
+      static_assert( std::is_invocable_v<X const>);
     }
 
-struct mutable_callable {
-  bool should_call_const;
+    // There's no way to make sure we delete the const& overload when the underlying call isn't valid,
+    // so we can't check this one.
 
-  constexpr bool operator()(int, int) {
-    assert(!should_call_const);
-    return true;
-  }
-  constexpr bool operator()(int, int) const {
-    assert(should_call_const);
-    return true;
+    // Make sure we delete the && overload when the underlying call isn't valid
+    {
+      struct F {
+        void operator()() &;
+        void operator()() const&;
+        void operator()() && = delete;
+        void operator()() const&&;
+      };
+      using X = decltype(std::bind_front(F{}));
+      static_assert( std::is_invocable_v<X&>);
+      static_assert( std::is_invocable_v<X const&>);
+      static_assert(!std::is_invocable_v<X>);
+      static_assert( std::is_invocable_v<X const>);
     }
-};
-
-constexpr void test_mutable() {
-  const mutable_callable v1{true};
-  const auto fn1 = std::bind_front(v1, 0);
-  assert(fn1(0));
 
-  mutable_callable v2{false};
-  auto fn2 = std::bind_front(v2, 0);
-  assert(fn2(0));
+    // Make sure we delete the const&& overload when the underlying call isn't valid
+    {
+      struct F {
+        void operator()() &;
+        void operator()() const&;
+        void operator()() &&;
+        void operator()() const&& = delete;
       };
+      using X = decltype(std::bind_front(F{}));
+      static_assert( std::is_invocable_v<X&>);
+      static_assert( std::is_invocable_v<X const&>);
+      static_assert( std::is_invocable_v<X>);
+      static_assert(!std::is_invocable_v<X const>);
+    }
+  }
 
-struct call_member {
-  constexpr bool member(int, int) { return true; }
+  // Some examples by Tim Song
+  {
+    {
+      struct T { };
+      struct F {
+        void operator()(T&&) const &;
+        void operator()(T&&) && = delete;
       };
-
-constexpr void test_call_member() {
-  call_member value;
-  auto fn = std::bind_front(&call_member::member, value, 0);
-  assert(fn(0));
+      using X = decltype(std::bind_front(F{}));
+      static_assert(!std::is_invocable_v<X, T>);
     }
 
-struct no_const_lvalue {
-  constexpr void operator()(int) && {};
+    {
+      struct T { };
+      struct F {
+        void operator()(T const&) const;
+        void operator()(T&&) const = delete;
       };
-
-constexpr auto make_no_const_lvalue(int x) {
-  // This is to test that bind_front works when something like the following would not:
-  // return [nc = no_const_lvalue{}, x] { return nc(x); };
-  // Above would not work because it would look for a () const & overload.
-  return std::bind_front(no_const_lvalue{}, x);
+      using X = decltype(std::bind_front(F{}, T{}));
+      static_assert(!std::is_invocable_v<X>);
+    }
   }
 
-constexpr void test_no_const_lvalue() { make_no_const_lvalue(1)(); }
-
-constexpr void constructor_tests() {
+  // Test properties of the constructor of the unspecified-type returned by bind_front.
+  {
     {
       MoveOnlyCallable value(true);
       using RetT = decltype(std::bind_front(std::move(value), 1));
 
-    static_assert(std::is_move_constructible<RetT>::value);
+      static_assert( std::is_move_constructible<RetT>::value);
       static_assert(!std::is_copy_constructible<RetT>::value);
       static_assert(!std::is_move_assignable<RetT>::value);
       static_assert(!std::is_copy_assignable<RetT>::value);
 
       auto ret = std::bind_front(std::move(value), 1);
       assert(ret());
       assert(ret(1, 2, 3));
 
       auto ret1 = std::move(ret);
       assert(!ret());
       assert(ret1());
       assert(ret1(1, 2, 3));
     }
     {
       CopyCallable value(true);
       using RetT = decltype(std::bind_front(value, 1));
 
-    static_assert(std::is_move_constructible<RetT>::value);
-    static_assert(std::is_copy_constructible<RetT>::value);
+      static_assert( std::is_move_constructible<RetT>::value);
+      static_assert( std::is_copy_constructible<RetT>::value);
       static_assert(!std::is_move_assignable<RetT>::value);
       static_assert(!std::is_copy_assignable<RetT>::value);
 
       auto ret = std::bind_front(value, 1);
       assert(ret());
       assert(ret(1, 2, 3));
 
       auto ret1 = std::move(ret);
       assert(ret1());
       assert(ret1(1, 2, 3));
 
       auto ret2 = std::bind_front(std::move(value), 1);
       assert(!ret());
       assert(ret2());
       assert(ret2(1, 2, 3));
     }
     {
       CopyAssignableWrapper value(true);
       using RetT = decltype(std::bind_front(value, 1));
 
       static_assert(std::is_move_constructible<RetT>::value);
       static_assert(std::is_copy_constructible<RetT>::value);
       static_assert(std::is_move_assignable<RetT>::value);
       static_assert(std::is_copy_assignable<RetT>::value);
     }
     {
       MoveAssignableWrapper value(true);
       using RetT = decltype(std::bind_front(std::move(value), 1));
 
-    static_assert(std::is_move_constructible<RetT>::value);
+      static_assert( std::is_move_constructible<RetT>::value);
       static_assert(!std::is_copy_constructible<RetT>::value);
-    static_assert(std::is_move_assignable<RetT>::value);
+      static_assert( std::is_move_assignable<RetT>::value);
       static_assert(!std::is_copy_assignable<RetT>::value);
     }
   }
 
-template <class Res, class F, class... Args>
-constexpr void test_return(F&& value, Args&&... args) {
-  auto ret =
-      std::bind_front(std::forward<F>(value), std::forward<Args>(args)...);
-  static_assert(std::is_same<decltype(ret()), Res>::value);
-}
-
-constexpr void test_return_types() {
-  test_return<Foo>(FooCall{}, 1, 2);
-  test_return<bool>(S{}, 1);
-  test_return<int>(add, 2, 2);
-}
-
-constexpr void test_arg_count() {
-  using T = decltype(std::bind_front(add, 1));
+  // Make sure bind_front is SFINAE friendly
+  {
+    using T = decltype(std::bind_front(std::declval<int(*)(int, int)>(), 1));
     static_assert(!std::is_invocable<T>::value);
-  static_assert(std::is_invocable<T, int>::value);
-}
-
-template <class... Args>
-struct is_bind_frontable {
-  template <class... LocalArgs>
-  static auto test(int)
-      -> decltype((void)std::bind_front(std::declval<LocalArgs>()...),
-                  std::true_type());
-
-  template <class...>
-  static std::false_type test(...);
-
-  static constexpr bool value = decltype(test<Args...>(0))::value;
-};
-
-struct NotCopyMove {
-  NotCopyMove() = delete;
-  NotCopyMove(const NotCopyMove&) = delete;
-  NotCopyMove(NotCopyMove&&) = delete;
-  void operator()() {}
-};
-
-struct NonConstCopyConstructible {
-  explicit NonConstCopyConstructible() {}
-  NonConstCopyConstructible(NonConstCopyConstructible&) {}
-};
-
-struct MoveConstructible {
-  explicit MoveConstructible() {}
-  MoveConstructible(MoveConstructible&&) {}
-};
+    static_assert( std::is_invocable<T, int>::value);
+    static_assert(!std::is_invocable<T, void*>::value);
+    static_assert(!std::is_invocable<T, int, int>::value);
 
-constexpr void test_invocability() {
-  static_assert(!std::is_constructible_v<NotCopyMove, NotCopyMove>);
+    static_assert(!std::is_constructible_v<NotCopyMove, NotCopyMove&>);
     static_assert(!std::is_move_constructible_v<NotCopyMove>);
     static_assert(!is_bind_frontable<NotCopyMove>::value);
     static_assert(!is_bind_frontable<NotCopyMove&>::value);
 
-  static_assert(
-      !std::is_constructible_v<MoveConstructible, MoveConstructible&>);
-  static_assert(std::is_move_constructible_v<MoveConstructible>);
-  static_assert(is_bind_frontable<variadic_fn, MoveConstructible>::value);
-  static_assert(
-      !is_bind_frontable<variadic_fn, MoveConstructible&>::value);
+    auto takeAnything = [](auto&& ...) { };
+    static_assert(!std::is_constructible_v<MoveConstructible, MoveConstructible&>);
+    static_assert( std::is_move_constructible_v<MoveConstructible>);
+    static_assert( is_bind_frontable<decltype(takeAnything), MoveConstructible>::value);
+    static_assert(!is_bind_frontable<decltype(takeAnything), MoveConstructible&>::value);
 
-  static_assert(std::is_constructible_v<NonConstCopyConstructible,
-                                        NonConstCopyConstructible&>);
+    static_assert( std::is_constructible_v<NonConstCopyConstructible, NonConstCopyConstructible&>);
     static_assert(!std::is_move_constructible_v<NonConstCopyConstructible>);
-  static_assert(
-      !is_bind_frontable<variadic_fn, NonConstCopyConstructible&>::value);
-  static_assert(
-      !is_bind_frontable<variadic_fn, NonConstCopyConstructible>::value);
+    static_assert(!is_bind_frontable<decltype(takeAnything), NonConstCopyConstructible&>::value);
+    static_assert(!is_bind_frontable<decltype(takeAnything), NonConstCopyConstructible>::value);
   }
 
-constexpr bool test() {
-  basic_tests();
-  constructor_tests();
-  test_return_types();
-  test_arg_count();
-  test_variadic();
-  test_mutable();
-  test_call_member();
-  test_no_const_lvalue();
-  test_invocability();
-
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/utilities/function.objects/func.bind_front/bind_front.verify.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++03, c++11, c++14, c++17
 
 // functional
 
-// template <class F, class... Args> constexpr unspecified bind_front(F&&, Args&&...);
+// template <class F, class... Args>
+// constexpr unspecified bind_front(F&&, Args&&...);
 
 #include <functional>
 
 #include "test_macros.h"
 
 constexpr int pass(const int n) { return n; }
 
 int simple(int n) { return n; }