Is `using Base::operator T` allowed where `T` is a template type parameter?

Question

Consider this example:

struct B { operator int(); };

template<class T>
struct X:B
{
    using B::operator T;
};

GCC accepts the code, while Clang and MSVC rejects it. Which is correct?

Note that if the base type is dependent, all the compilers accept the code:

template<class T>
struct B { operator T(); };

template<class T>
struct X:B<T>
{
    using B<T>::operator T;
};

Answer 1

I think GCC is right, in §7.3.3/1, we can find:

The set of declarations introduced by the using-declaration is found by performing qualified name lookup (3.4.3, 10.2) for the name in the using-declaration, excluding functions that are hidden as described below.

I don't see any reason why operator T would not be found, actually:

template<class T>
struct X: B {
    T f () { return B::operator T; }
};

...compiles fine with g++ and clang (did not test on MSVC).

I cannot find anything in the standard specific to conversion functionsfor qualified name lookup except:

Since specializations of member templates for conversion functions are not found by name lookup, they are not considered when a using-declaration specifies a conversion function (14.5.2).

But B::operator int is not a specialization of a member function template, so it should not be taken into account by the above.

Answer 2

Hmm... Gcc does not like the first one either. It compiles unless you try to create instance of struct X with template parameter other than int. What would be the meaning of X<double>::operator double()? Class B does not have such an operator but we would try to use it.

To sum up: MSVC and clang try to warn you beforehand (even if you don't do anything veeeery stupid right now) while gcc does produce an error only if you attempt to create something incorrect. This does not compile in gcc (5.3.0):

#include <iostream>

struct B { operator int(); };

template<class T>
struct X:B
{
    using B::operator T;
};

int main(int argc, char **argv)
{
    X<char> x;
    std::cout << "Hello!" << std::endl;
    return 0;
}