std::variant of inner class cannot be created if inner class has initializers

[tbleher]

The following code does not build:

#include <variant>

struct X {
    struct A { int a=0; };
    struct B {
        std::variant<X::A> a;
    };
};

void test() {
    X::B b;
}

See https://godbolt.org/z/4ExGEvTf6 (on clang-trunk, with -std=c++20 -O2).

The error is:

<source>:11:10: error: call to implicitly-deleted default constructor of 'X::B'
   11 |     X::B b;
      |          ^
<source>:6:28: note: default constructor of 'B' is implicitly deleted because field 'a' has no default constructor
    6 |         std::variant<X::A> a;
      |                            ^

Each of the following changes will make the code compile:

• making A and B top-level classes
• Changing class A to not have an initializer for a
• Changing class A to have an explicit constructor (like A() : a(0) {})

I think this code should be accepted. GCC accepts this code since version 14.1 (previous versions reject it with an error message similar to clang's message).

[frederick-vs-ja]

A library-free, reduced example (Godbolt link)

template<class T>
inline constexpr bool my_is_default_constructible_v = __is_constructible(T);

template<class T>
struct Wrapper {
    constexpr Wrapper() requires my_is_default_constructible_v<T> : t() {}
    T t;
};

struct X {
    struct A { int a = 0; };
    struct B {
        Wrapper<X::A> aa;
    };
};

void test() {
    [[maybe_unused]] X::B b;
}

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Thomas Bleher (tbleher)

The following code does not build: ``` #include <variant>

struct X {
struct A { int a=0; };
struct B {
std::variant<X::A> a;
};
};

void test() {
X::B b;
}

See https://godbolt.org/z/4ExGEvTf6 (on clang-trunk, with -std=c++20 -O2).

The error is:

<source>:11:10: error: call to implicitly-deleted default constructor of 'X::B'
11 | X::B b;
| ^
<source>:6:28: note: default constructor of 'B' is implicitly deleted because field 'a' has no default constructor
6 | std::variant<X::A> a;
| ^

Each of the following changes will make the code compile:
- making A and B top-level classes
- Changing class A to not have an initializer for a
- Changing class A to have an explicit constructor (like `A() : a(0) {}`)

I think this code should be accepted. GCC accepts this code since version 14.1 (previous versions reject it with an error message similar to clang's message).
</details>

[pinskia]

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

[eyalroz]

Also see the Stack Overflow discussion of a similar situation, and this LLVM bug.

[shafik]

Also see the Stack Overflow discussion of a similar situation, and this LLVM bug.

So if Davis Herring this is complicated and points to the specific CWG issues on this being CWG2335 and CWG1360 then that is indeed the case. He is definitely one of the core experts in this area.

So once the core issues are resolved then we will know what the correct answer is here.