Eu tenho o seguinte código:

template <typename TC>
class C
{
    struct S
    {
        template <typename TS>
        void fun() const
        {}
    };

    void f(const S& s)
    {
        s.fun<int>();
    }
};

// Dummy main function
int main()
{
    return 0;
}

Ao compilar isso com o gcc 9.2 e o clang (9.0), estou recebendo um erro de compilação devido à templateexigência da palavra - chave para a chamada fun. Clang mostra:

error: use 'template' keyword to treat 'fun' as a dependent template name
        s.fun<int>();
          ^
          template 

Não entendo por que o compilador pensa que funé um nome dependente no contexto de f, já que fnão é um modelo em si. Se eu mudar Cpara ser uma classe regular em vez de um modelo, o erro desaparece; no entanto, não vejo por que deveria haver um erro em primeiro lugar, pois Snem fdependemos disso TC.

Curiosamente, o MSVC 19.22 compila isso muito bem.

Nota

Antes de votar para fechar como idiota de Onde e por que tenho que colocar as palavras-chave "modelo" e "nome do tipo"? considere que este é um caso especial em que, mesmo que Sseja realmente um nome dependente, no contexto fdele não seria dependente se não fosse pelo fato de serem membros da instanciação atual.

Considere :

template<typename T>
struct C
{
    struct S
    {
        int a = 99;
    };

    void f(S s, int i)
    {
        s.a<0>(i);
    }
};

template<>
struct C<long>::S
{
    template<int>
    void a(int)
    {}
};

int main()
{
    C<int>{}.f({}, 0); // #1
    C<long>{}.f({}, 0); // #2
}

s.a<0>(i)é analisado como uma expressão que contém duas operações de comparação <e >, e isso é bom para o 1, mas falha para o 2.

Se isso for alterado para s.template a<0>(i), o item 2 está OK e o item 1 falha. Portanto, a templatepalavra-chave nunca é redundante aqui.

O MSVC é capaz de interpretar a expressão nos s.a<0>(i)dois sentidos no mesmo programa. Mas isso não está correto de acordo com o padrão; cada expressão deve ter apenas uma análise para o compilador lidar.

funpode ou não ser uma função de modelo (ou pode não existir), dependendo do parâmetro de modelo de class C.

Isso porque você pode se especializar S(sem se especializar C):

template <> struct C<int>::S {};

Como o compilador deseja saber se funé ou não um modelo quando olha pela primeira vez class C(antes de substituir o parâmetro do modelo), templateé necessário.