static function lookup from a template function issue with xlC

Question

While I was searching for clues about a compilation problem I have had in my source, I have come across this bug report (against Mozilla's JavaScript engine source) related to functions lookup. Quoting from the bug report:

TypedArrayTemplate is (obviously) a template, and it is referencing INT_TO_JSVAL, a static inline function, without prefixing it with "::". This breaks xlC because it can not resolve INT_TO_JSVAL. The standard does not require that statics be considered if the unqualified name is not found in the context of the template arguments. g++ does this fallback, xlC does not.

Informative message from the compiler:

(I) Static declarations are not considered for a function call if the function is not qualified.

In my case the code that was failing was similar to this:

namespace N
{

static bool foo (std::string const &);

template <typename T>
void bar (T const &, std::string const & s)
{
    // expected unqualified call to N::foo()
    foo (s);
}

void baz (std::string const & s)
{
    bar (s);
}

} // namespace N

Is the behaviour that xlC implements really correct? Where does the 2003 or 2011 standard talk about this?

Answer 1

Prior to C++11 this was the correct behavior: unqualified name resolution of names used in templates was defined to only find functions with external linkage.

C++03 section 14.6.4.2 Candidate Functions [temp.dep.candidate] paragraph 1:

For a function call that depends on a template parameter, if the function name is an unqualified-id but not a template-id, the candidate functions are found using the usual lookup rules (3.4.1, 3.4.2) except that:

• For the part of the lookup using unqualified name lookup (3.4.1), only function declarations with external linkage from the template definition context are found.

• For the part of the lookup using associated namespaces (3.4.2), only function declarations with external linkage found in either the template definition context or the template instantiation context are found.

which changes in C++11 to:

For a function call that depends on a template parameter, the candidate functions are found using the usual lookup rules (3.4.1, 3.4.2, 3.4.3) except that:

• For the part of the lookup using unqualified name lookup (3.4.1) or qualified name lookup (3.4.3), only function declarations from the template definition context are found.

• For the part of the lookup using associated namespaces (3.4.2), only function declarations found in either the template definition context or the template instantiation context are found.