Неполный тип не допускается в классе, но разрешен в шаблоне класса

Я отвечу на третью часть вашего вопроса - как IANALL (не языковой юрист).

Код недействителен по той же причине, что недопустимо использовать функцию до ее объявления - даже несмотря на то, что компилятор может выяснить, какой должна быть функция, перейдя дальше в той же единице преобразования. И случаи аналогичны также в том смысле, что если у вас есть просто объявление без определения, этого достаточно для компилятора, а здесь у вас есть определение шаблона до создания экземпляра.

Итак, суть в следующем: Стандарт языка требует, чтобы компилятор не смотрел вперед для вас., когда вы хотите что-то определить (а шаблон класса не является определением класса).

Я думаю, что этот пример явно разрешен

17.6.1.2 Member classes of class templates [temp.mem.class]

1 A member class of a class template may be defined outside the class template definition in which it is declared. [Note: The member class must be defined before its first use that requires an instantiation (17.8.1) For example,

template<class T> struct A {
  class B;
};

A<int>::B* b1; // OK: requires A to be defined but not A::B
template<class T> class A<T>::B { };
A<int>::B b2; // OK: requires A::B to be defined

—end note ]

Это тоже должно быть в порядке с Работа:

template <typename = void>
struct foo_impl {
    struct bar;
    bar x;        // no problems here
};

template<typename T>
struct foo_impl<T>::bar{ int value{42}; };

using foo = foo_impl<>;

int main()
{
    return foo{}.x.value;
}

Реальный ответ может быть ¯ \ _ (ツ) _ / ¯, но, вероятно, в настоящее время это нормально, потому что шаблоны волшебны, но может быть более явно не годным до решения некоторых других основных проблем.

Во-первых, основная проблема конечно [class.mem] / 14:

Non-static data members shall not have incomplete types.

Вот почему ваш пример без шаблона плохо сформирован. Однако, согласно [temp.point] / 4:

For a class template specialization, a class member template specialization, or a specialization for a class member of a class template, if the specialization is implicitly instantiated because it is referenced from within another template specialization, if the context from which the specialization is referenced depends on a template parameter, and if the specialization is not instantiated previous to the instantiation of the enclosing template, the point of instantiation is immediately before the point of instantiation of the enclosing template. Otherwise, the point of instantiation for such a specialization immediately precedes the namespace scope declaration or definition that refers to the specialization.

Это предполагает, что для foo_impl<void>::bar создается экземпляр передfoo_impl<void>, и, следовательно, он завершается в точке, где создается экземпляр нестатических данных типа bar. Так что, может, все в порядке.

тем не мение, проблемы с основным языком 1626 и 2335 имеют дело с не совсем такими же, но все еще довольно похожими проблемами, касающимися полноты и шаблонов, и оба указывают на желание сделать случай шаблона более согласованным с случаем без шаблона.

Что все это означает в целом? Я не уверен.

Подробнее о принятом ответе

Я не уверен, что принятый ответ является правильным объяснением, но на данный момент он наиболее правдоподобен. Экстраполируя этот ответ, вот ответы на мои первоначальные вопросы:

1. Это действительно валидный код на C++ или просто причуда компиляторов? [Это действующий код.]
2. Если это действительный код, есть ли в стандарте C++ параграф, касающийся этого исключения? [[temp.point] / 4]
3. Если это действительный код, почему первая версия (без template) считается недействительной? Если компилятор может определить второй вариант, я не вижу причин, по которым он не сможет определить первый. [Потому что C++ странный - он обрабатывает шаблоны классов иначе, чем классы (вы, наверное, уже догадались об этом). ]

Еще несколько объяснений

Что будет происходить с кажется

При создании экземпляра foo{} в main компилятор создает экземпляр (неявной) специализации для foo_impl<void>. Эта специализация ссылается на foo_impl<void>::bar в строке 4 (bar x;). Контекст находится в определении шаблона, поэтому он зависит от параметра шаблона, а специализация foo_impl<void>::bar, очевидно, не была ранее создана, поэтому все предварительные условия для [temp.point] / 4 выполняются, и компилятор генерирует следующий промежуточный (псевдо) код:

template <typename = void>
struct foo_impl {
    struct bar;
    bar x;        // no problems here
    struct bar{ int value{42}; };
};

using foo = foo_impl<>;

// implicit specialization of foo_impl<void>::bar, [temp.point]/4
$ struct foo_impl<void>::bar {
$     int value{42};
$ };
// implicit specialization of foo_impl<void> 
$ struct foo_impl<void> {
$     struct bar;
$     bar x;   // bar is not incomplete here
$ };
int main() { return foo{}.x.value; }

О специализация

Согласно [temp.spec] / 4:

A specialization is a class, function, or class member that is either instantiated or explicitly specialized.

поэтому вызов foo{}.x.value в исходной реализации с шаблонами квалифицируется как специализация (для меня это было чем-то новым).

О версии с явной специализацией

Версия с явной специализацией не компилируется, поскольку кажется, что:

if the context from which the specialization is referenced depends on a template parameter

больше не выполняется, поэтому правило из [temp.point] / 4 не применяется.