[Bug c++/88165] error: default member initializer for 'A::B::m' required before the end of its enclosing class

["redi at gcc dot gnu.org" <gcc-bugzilla@gcc.gnu.org>]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=88165

--- Comment #10 from Jonathan Wakely <redi at gcc dot gnu.org> ---
(In reply to Fedor Chelnokov from comment #7)
> This struct definition:
> ```
> struct A {
>     struct B {
>         int i = 0;
>         B() {}

This declares default constructor, meaning that the type is default
constructible. Period.

By declaring B(); you assert that B is default constructible.

>     };
>     A(B = {});

This is valid, because the user-provided default constructor for B is all the
compiler needs to see to know that B={} is valid.

> };
> ```
> is accepted by GCC, but another one ({} replaced with = default) is not:
> ```
> struct C {
>     struct D {
>         int i = 0;
>         D() = default;

This declares a default constructor that might be defined implicitly by the
compiler, **or** it might get deleted if the member definitions of D would make
the implicit default constructor ill-formed. This is obviously very different
from the case where you declare B(); There is no assertion that D is default
constructible, the compiler has to deduce whether or not that's true. That
depends on the default member initializer for D::i. The initializer (which is
just '0' here) is a "complete class context" which means it is not processed
until the class D is complete (this allows you to use other members, or e.g.
sizeof(D) as the initializer).

A nested class like C::D is not complete until its enclosing class is complete.
This means the initializer for C::D::i is compiled after C is complete. This
means whether C::D is default constructible is not known until C is complete.


>     };
>     C(D = {});

This requires checking whether C::D is default constructible, but we are still
in the body of C, so C is not complete, which means C::D is not complete, which
means we don't know if C::D is default constructible.

> };
> ```
> Demo: https://gcc.godbolt.org/z/WTPdTn1Yf
> 
> Could you please explain why? I though that both must be same accepted or
> same rejected.

I hope the explanation above helps.

GCC trunk now has a tweak to parse simple initializers like 0 immediately,
instead of waiting for the class to be complete (because 0 doesn't depend on
anything in the class). But for the original example in comment 0 the
initializer std::numeric_limits<double>::max(); has to perform name lookup and
overload resolution, and so is still delayed until the class is complete.