Failure at disambiguating overloaded method - c++

Question

What follows is reduced from a system that stores pointers to methods along with their parameter's types. The user just provides type::method and the template machinery does the rest. When the method is overloaded the user must provide the signature of the desired method.
This was working very well until we tried it with some boost::asio stuff. The following code demonstrates the problem:
#include <boost/asio.hpp>
using namespace boost::asio::ip;
using namespace boost::system;
template <typename TT, typename MFP, MFP> struct OpM;
template <typename TR, typename TT, typename ... Ts, TR (TT::*f)(Ts...)>
struct OpM<TT, TR (TT::*)(Ts...), f> {};
using sig = error_code (tcp::socket::*)(const tcp::endpoint&, error_code&);
struct RM {
template <class C, typename R, typename ... Ps>
RM(R (C::*)(Ps...)) {
typedef OpM<C, R (C::*)(Ps...), &tcp::socket::connect> OP;
}
} MRegisterer(static_cast<sig>(&tcp::socket::connect));
g++ 8.3 fails to compile with the message:
g++ -std=c++17 -c connect.cpp
connect.cpp: In instantiation of 'RM::RM(R (C::*)(Ps ...)) [with C = boost::asio::basic_stream_socket<boost::asio::ip::tcp>; R = boost::system::error_code; Ps = {const boost::asio::ip::basic_endpoint<boost::asio::ip::tcp>&, boost::system::error_code&}]':
connect.cpp:19:40: required from here
connect.cpp:17:46: error: conversion from 'boost::system::error_code (boost::asio::basic_socket<boost::asio::ip::tcp>::*)(const endpoint_type&, boost::system::error_code&)' {aka 'boost::system::error_code (boost::asio::basic_socket<boost::asio::ip::tcp>::*)(const boost::asio::ip::basic_endpoint<boost::asio::ip::tcp>&, boost::system::error_code&)'} to 'boost::system::error_code (boost::asio::basic_stream_socket<boost::asio::ip::tcp>::*)(const boost::asio::ip::basic_endpoint<boost::asio::ip::tcp>&, boost::system::error_code&)' in a converted constant expression
typedef OpM<C, R (C::*)(Ps...), &tcp::socket::connect> OP;
^~
connect.cpp:17:46: error: could not convert template argument '& boost::asio::basic_socket<boost::asio::ip::tcp>::connect' from '<unresolved overloaded function type>' to 'boost::system::error_code (boost::asio::basic_stream_socket<boost::asio::ip::tcp>::*)(const boost::asio::ip::basic_endpoint<boost::asio::ip::tcp>&, boost::system::error_code&)'
It is weird that the error message refers to a conversion error from ... boost::asio::basic_socket ... to ... boost::asio::basic_stream_socket ... (and something similar for the endpoint parameter).
I'm providing the full type of the method, in RM seems to work fine but when the method is passed to OpM apparently the compiler gets confused.
What is wrong?
For completeness' sake, this is the output of clang++ 8.0:
~/bin/clang++ -std=c++17 -c connect.cpp
connect.cpp:17:37: error: conversion from '<overloaded function type>' to
'boost::system::error_code
(boost::asio::basic_stream_socket<boost::asio::ip::tcp>::*)(const
boost::asio::ip::basic_endpoint<boost::asio::ip::tcp> &,
boost::system::error_code &)' is not allowed in a converted constant
expression
typedef OpM<C, R (C::*)(Ps...), &tcp::socket::connect> OP;
^~~~~~~~~~~~~~~~~~~~~
connect.cpp:19:3: note: in instantiation of function template specialization
'RM::RM<boost::asio::basic_stream_socket<boost::asio::ip::tcp>,
boost::system::error_code, const
boost::asio::ip::basic_endpoint<boost::asio::ip::tcp> &,
boost::system::error_code &>' requested here
} MRegisterer(static_cast<sig>(&tcp::socket::connect));
^
1 error generated.

Answer 1

Here's a short reproduction of the same issue without Boost.Asio or even overloaded functions:
struct B {
void foo();
};
struct D : B { };
template <typename T, T> struct X { };
using T = X<void (D::*)(), &D::foo>; // error
The problem is, the type of &D::foo, despite being spelled D::, is actually void (B::*)(). And that type is not implicitly convertible to void (D::*)().
The nice thing for you is that since you're using C++17, you don't actually have to go through this explicit typing rigamarole, you can just write:
template <auto F> struct X { };
using T = X<&D::foo>; // fine
Or rework the whole thing to use pointers to function instead, and turn your pointer-to-member function into a function taking a D* (which you can do with a lambda or write out a function template and use an explicit specialization of it).