<functional>: Fixes around not_fn

[frederick-vs-ja]

Make the return type (_Not_fn) perfect forwarding call wrapper since C++20, which is a change in WG21-P0356R5.

Currently this PR leaves _Not_fn as-is in C++17 mode, because the return type was nearly fully specified in C++17 (N4659 [func.not_fn]/1), which means that

1. due to the absence of deleted operator() overloads, an invocation to a non-const value of the return type might select a const overload, and
2. due to the use of decltype(!declval<invoke_result_t<...>>()), if the operator! takes a non-movable return type of std::invoke(args...) by value, the return type of operator() would be ill-formed, while !std::invoke(args...) being well-formed.

In C++20 the first case should be ill-formed (in an SFINAE-friendly way), and the second case should be well-formed.

Also make not_fn reject non-move-constructible types. Fixes #4048.

I don't know why call wrappers (except for std::function) are still required to be Cpp17MoveConstructible in C++17 and later. It seems that the restrictions can be lifted.

[hewillk]

You should probably also add a static_assert for is_constructible_v<FD, F> to avoid hard errors in the function body:

struct OnlyMovableFun {
  OnlyMovableFun() = default;
  OnlyMovableFun(const OnlyMovableFun&) = delete;
  OnlyMovableFun(OnlyMovableFun&&) = default;
  bool operator()(auto) const;
};

int main() {
  OnlyMovableFun f;
  auto nf = std::not_fn(f); // should be static_assert?
}

[CaseyCarter]

You should probably also add a static_assert for is_constructible_v<FD, F> to avoid hard errors in the function body:

That wouldn't "avoid hard errors", it would transform a hard error into a different hard error.

[StephanTLavavej]

Thanks - this compile-time change is low-risk enough that I think we need only one maintainer approval.

[StephanTLavavej]

I'm mirroring this to the MSVC-internal repo - please notify me if any further changes are pushed.

[StephanTLavavej]

Thanks for noticing and fixing this issue in not_fn! 🛠️ 🎉 😻