Why doesn't ADL find function templates?

Question

What part of the C++ specification restricts argument dependent lookup from finding function templates in the set of associated namespaces? In other words, why does the last call in main below fail to compile?

namespace ns {     struct foo {};     template<int i> void frob(foo const&) {}     void non_template(foo const&) {} }  int main() {     ns::foo f;     non_template(f); // This is fine.     frob<0>(f); // This is not. } 

Answer 1

This part explains it:

C++ Standard 03 14.8.1.6:

[Note: For simple function names, argument dependent lookup (3.4.2) applies even when the function name is not visible within the scope of the call. This is because the call still has the syntactic form of a function call (3.4.1). But when a function template with explicit template arguments is used, the call does not have the correct syntactic form unless there is a function template with that name visible at the point of the call. If no such name is visible, the call is not syntactically well-formed and argument-dependent lookup does not apply. If some such name is visible, argument dependent lookup applies and additional function templates may be found in other namespaces.

namespace A {   struct B { };   template<int X> void f(B); } namespace C {   template<class T> void f(T t); } void g(A::B b) {   f<3>(b);    //ill-formed: not a function call   A::f<3>(b); //well-formed   C::f<3>(b); //ill-formed; argument dependent lookup               // applies only to unqualified names   using C::f;   f<3>(b);    //well-formed because C::f is visible; then               // A::f is found by argument dependent lookup } 

Answer 2

Since c++20, adl works also fine with explicit function template. Here is the proposal: P0846R0: ADL and Function Templates that are not Visible:

Instead of requiring the user to use the template keyword, a revision to the lookup rules was proposed so that a name for which a normal lookup produces either no result or finds one or more functions and that is followed by a a "<" would treated as if a function template name had been found and would cause ADL to be performed.

Currently, only GCC 9 has implement this feature, so your example can compile.

live demo.