procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

libstdc++: Make std::function deduction guide support explicit object functions [PR113335]

Browse source 
This makes the deduction guides for std::function and std::packaged_task
work for explicit object member functions, i.e. "deducing this", as per
LWG 3617.

libstdc++-v3/ChangeLog:

	PR libstdc++/113335
	* include/bits/std_function.h (__function_guide_helper): Add
	partial specialization for explicit object member functions, as
	per LWG 3617.
	* testsuite/20_util/function/cons/deduction_c++23.cc: Check
	explicit object member functions.
	* testsuite/30_threads/packaged_task/cons/deduction_c++23.cc:
	Likewise.
This commit is contained in:
Jonathan Wakely 2024-02-02 10:03:12 +00:00
parent f929293589
commit 6f75149488
3 changed files with 76 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
libstdc++-v3/include/bits/std_function.h
View file

@ -697,6 +697,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
>
{ using type = _Res(_Args...); };
#if __cpp_explicit_this_parameter >= 202110L
template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
struct __function_guide_helper<_Res (*) (_Tp, _Args...) noexcept(_Nx)>
{ using type = _Res(_Args...); };
#endif
#if __cpp_static_call_operator >= 202207L && __cpp_concepts >= 202002L
template<typename _StaticCallOp>
struct __function_guide_static_helper

35
libstdc++-v3/testsuite/20_util/function/cons/deduction_c++23.cc
View file

@ -21,3 +21,38 @@ test_static_call_operator()
std::function func2 = F2{};
check_type<std::function<float(char, void*)>>(func2);
}
void
test_explicit_object_call_operator()
{
// LWG 3617 - function/packaged_task deduction guides and deducing this
struct F {
int operator()(this const F&) { return 42; }
};
std::function g = F{};
check_type<std::function<int()>>(g);
struct F2 {
short operator()(this F2&, float&) { return 0; }
};
std::function g2 = F2{};
check_type<std::function<short(float&)>>(g2);
struct F3 {
void operator()(this const F3, char*, long) { }
};
std::function g3 = F3{};
check_type<std::function<void(char*, long)>>(g3);
struct F4 {
int i;
operator const int&() const { return i; }
const long& operator()(this int, const long& l) { return l; }
};
std::function g4 = F4{};
check_type<std::function<const long&(const long&)>>(g4);
}

35
libstdc++-v3/testsuite/30_threads/packaged_task/cons/deduction_c++23.cc
View file

@ -20,3 +20,38 @@ test_static_call_operator()
std::packaged_task task2{ F2{} };
check_type<std::packaged_task<float(char, void*)>>(task2);
}
void
test_explicit_object_call_operator()
{
// LWG 3617 - function/packaged_task deduction guides and deducing this
struct F {
int operator()(this const F&) { return 42; }
};
std::packaged_task g{ F{} };
check_type<std::packaged_task<int()>>(g);
struct F2 {
short operator()(this F2&, float&) { return 0; }
};
std::packaged_task g2{ F2{} };
check_type<std::packaged_task<short(float&)>>(g2);
struct F3 {
void operator()(this const F3, char*, long) { }
};
std::packaged_task g3{ F3{} };
check_type<std::packaged_task<void(char*, long)>>(g3);
struct F4 {
int i;
operator const int&() const { return i; }
const long& operator()(this int, const long& l) { return l; }
};
std::packaged_task g4{ F4{} };
check_type<std::packaged_task<const long&(const long&)>>(g4);
}