Why is this ADL resolution ambigous - c++

Question

I am trying to use the custom allocaters feature of c++ asio library (http://think-async.com/Asio/asio-1.10.6/doc/asio/overview/core/allocation.html). My functions code is all in namespace bb, as is a custom allocation function void* asio_handler_allocate(std::size_t size, ...). I expected ADL to pick my custom version, but for some reason it results in an ambiguity:
c:\mysrv\asio\detail\handler_alloc_helpers.hpp(38): error C2668: 'bb::asio_handler_allocate': ambiguous call to overloaded function
1> c:\mysrv\connection.hpp(16): note: could be 'void *bb::asio_handler_allocate(std::size_t,...)' [found using argument-dependent lookup]
1> c:\mysrv\asio\impl\handler_alloc_hook.ipp(27): note: or 'void *asio::asio_handler_allocate(std::size_t,...)'
1> c:\mysrv\asio\detail\handler_alloc_helpers.hpp(38): note: while trying to match the argument list '(std::size_t, bb::Server::do_accept::<lambda_18e060fa7342c1167c1b66e6dfdfd1b2> *)'
Any explanation as to why the second one also matches and/or as to how to use this feature correctly would be appreciated
Thanks
P.S. I am adding the boost-asio tag since it is supposed the same library but only in a different namespace. I am actually using the stand-alone c++11 version fouind here http://think-async.com/
Here is a simplified example:
#include "asio.hpp"
#include <memory>
#include <iostream>
namespace bb {
void* asio_handler_allocate(std::size_t size, ...) {
std::cerr << 'H' << ' ' << /**h <<*/ ' ' << size << '\n';
return asio::asio_handler_allocate(size);
}
class Connection
: public std::enable_shared_from_this<Connection>
{
public:
Connection(asio::ip::tcp::socket socket)
: socket_(std::move(socket))
{
}
void start()
{
do_read();
}
private:
void do_read()
{
auto self(shared_from_this());
socket_.async_read_some(asio::buffer(data_),
[this, self](std::error_code ec, std::size_t length)
{
if (!ec)
{
do_write(length);
}
});
}
void do_write(std::size_t length)
{
auto self(shared_from_this());
asio::async_write(socket_, asio::buffer(data_, length),
[this, self](std::error_code ec, std::size_t /*length*/)
{
if (!ec)
{
do_read();
}
});
}
asio::ip::tcp::socket socket_;
std::array<char, 1024> data_;
};
class Server
{
public:
Server(asio::io_service& io_service, short port)
: acceptor_(io_service, asio::ip::tcp::endpoint(asio::ip::tcp::v4(), port)),
socket_(io_service)
{
do_accept();
}
private:
void do_accept()
{
acceptor_.async_accept(socket_,
[this](std::error_code ec)
{
if (!ec)
{
std::make_shared<Connection>(std::move(socket_))->start();
}
do_accept();
});
}
asio::ip::tcp::acceptor acceptor_;
asio::ip::tcp::socket socket_;
};
}
int main(int argc, char* argv[])
{
try
{
if (argc != 2)
{
std::cerr << "Usage: server <port>\n";
return 1;
}
asio::io_service io_service;
bb::Server s(io_service, std::atoi(argv[1]));
io_service.run();
}
catch (std::exception& e)
{
std::cerr << "Exception: " << e.what() << "\n";
}
return 0;
}

Answer 1

ADL merely add argument's namespaces to the list of namespaces where the name should be looked up (this is not very precise, but for the purpose of your question, its enough). It does not make an overload in that namespace the preferable one automatically. If two equally ranked match are found, an ambiguous still happens. In your case, the two are exactly the same.
If you read the ASIO document you linked, you will know that the correct way to declare the ADL overload is
void* asio_handler_allocate(size_t, Handler);
Where Handler is the user defined handler type. The above declaration can also have possible CV qualifiers for Handler. In this case, the two overload found are one with the second parameter a concrete type and another with .... Any legal match with a typed parameter is ranked higher than the variadic arguments (not to be confused with C++11 variadic template arguments). Therefore, there would be no ambiguous match