Правильно ли Clang отклонять код, в котором вложенный класс шаблона класса определяется только через специализации?

Дан следующий шаблон класса:

template<typename T>
struct Outer
{
    struct Inner;

    auto f(Inner) -> void;
};

мы определяем Innerотдельно для каждой специализации Outer:

template<>
struct Outer<int>::Inner {};

template<>
struct Outer<double>::Inner {};

а затем определить функцию-член fодин раз для всех специализаций Outer:

auto Outer<T>::f(Inner) -> void
{

}

но Кланг (9.0.0) жалуется:

error: variable has incomplete type 'Outer::Inner'

auto Outer<T>::f(Inner) -> void

                      ^

Мы можем избежать ошибки компилятора, также предоставив определение Innerдля всех других специализаций Outer:

template<typename T>
struct Outer<T>::Inner {};

или определяя fотдельно для каждой специализации:

template<>
auto Outer<int>::f(Inner) -> void
{

}

template<>
auto Outer<double>::f(Inner) -> void
{

}

И GCC, и MSVC принимают исходный код, который вызывает вопрос; это ошибка Clang или единственная совместимая реализация из трех?

Попробуйте в Compiler Explorer

Я считаю, что Clang не прав, чтобы отклонить ваш код. Мы должны спросить себя, как соотносятся ваше объявление и определение функции с

auto f(typename T::Inner) -> void;

// ...

template<typename T>
auto Outer<T>::f(typename T::Inner) -> void
{ }

В этом примере, T::Innerочевидно, является зависимым типом. Таким образом, Clang может не предполагать, что он неполон до момента его создания. То же самое относится и к вашему примеру? Я бы так сказал. Ибо у нас есть это в стандарте:

[Temp.dep.type]

5 Имя является членом текущего экземпляра, если оно

• Неквалифицированное имя, которое при поиске относится, по крайней мере, к одному члену класса, который является текущим экземпляром, или его независимому базовому классу. [Примечание: это может происходить только при поиске имени в области, заключенной в определение шаблона класса. - конец примечания]
• ...

Имя является зависимым членом текущего экземпляра если оно является членом текущего экземпляра, который при поиске ссылается по крайней мере на один член класса, который является текущим экземпляром.

9 Тип зависит, если он

• ...
• член неизвестной специализации,
• вложенный класс или перечисление, являющееся зависимым членом текущего экземпляра,
• ...

Таким образом, первая пуля в пункте 9 охватывает случай typename T::Inner . Это зависимый тип.

Между тем ваш случай покрыт второй пулей. Outer::Innerэто имя, которое встречается в текущем экземпляре Outer, более того, оно находится внутри Outerсебя, а не в базовом классе. Это делает его зависимым членом текущего экземпляра. Это имя относится к вложенному классу. Это означает, что все условия, указанные во втором пункте, применимы, что также делает Outer::Innerзависимый тип!

Поскольку в обоих случаях мы сами имеем зависимый тип, компиляторы должны одинаково относиться к ним как к зависимым типам. Мой вывод заключается в том, что GCC и MSVC правы.