Não tenho certeza se isso tem algo a ver com sfinae, ou apenas algo que é relevante para qualquer função modelada. Eu estou tentando usar sfinae para ativar / desativar uma função de membro com base na existência de função livre correspondente, que por sua vez é habilitado / desabilitado com base na existência de função de membro em outro tipo, todos usando o método descritoAqui:

struct S;

template <typename T>
inline auto f(S& s, T const& t)
   -> decltype(t.f(s), void())
{
   t.f(s);
}

struct S
{
    template <typename T>
    auto f(T const& t)
        -> decltype(f(*this, t), void())
    {
        f(*this, t); // <------------------------------------------- HERE
    }
};

struct pass
{
    void f(S&) const
    {
        //...
    }
};

struct fail
{
};

int main()
{
    S s;
    s.f(pass()); // should compile fine
    //s.f(fail()); // should fail to compile due to absence of f from S
    return 0;
}

no entanto gcc 4.7.1 me dá isso na linha marcada pela seta:

erro: nenhuma função correspondente para chamar para 'S :: f (S &, const pass &)'
nota: o candidato é:
Nota: template decltype ((f ((* isto), t), void ())) S :: f (const T &)
Nota: dedução / substituição do argumento do modelo falhou:
nota: o candidato espera 1 argumento, 2 forneceu

o que aparentemente significa que globalf acima não é considerado para resolução de sobrecarga.

Por que isso e o que eu faço para fazer isso?

Além disso, por que não há erros duas linhas acima, ondef usado em decltype de maneira similar?

ATUALIZAR

Como @ n.m. disse, funções membro funções completamente livre de sombra, mesmo quando suas assinaturas são diferentes, então aqui está uma solução alternativa que não quebra ADL paraf (ao contrário da qualificação de nome completo sugerida por @ n.m.). Faça a função livre (f_dispatcher) em algum lugar ninguém vai olhar (detail) e qualificar totalmente o seu nomeS::f. Nessa função, ligue grátisf e deixe que a ADL cuide dela a partir daí, assim:

struct S;

template <typename T>
inline auto f(S& s, T const& t)
    -> decltype(t.f(s), void())
{
    t.f(s);
}

namespace detail
{
    template <typename T>
    inline auto f_dispatcher(S& s, T const& t)
        -> decltype(f(s, t), void())
    {
        f(s, t);
    }
}

struct S
{
    template <typename T>
    auto f(T const& t)
        -> decltype(detail::f_dispatcher(*this, t), void())
    {
        detail::f_dispatcher(*this, t);
    }
};

struct pass
{
    void f(S&) const
    {
        //...
    }
};

struct fail
{
};

int main()
{
    S s;
    s.f(pass()); // compiles fine
    //s.f(fail()); // fails to compile due to absence of f from S
    return 0;
}