[libc++] `std::variant` introduces padding if a variant member contains a variant

[zygoloid]

Testcase:

#include <variant>

struct A {
  int x;
};

struct B {
  int y;
  int z;
};
static_assert(sizeof(B) == 8);

static_assert(sizeof(std::variant<A, B>) == 12);

struct C {
  std::variant<int> v;
};
static_assert(sizeof(C) == 8);

static_assert(sizeof(std::variant<A, C>) == 16);

variant<A, C> ought to be only 12 bytes, but is actually 16 bytes. The reason for this is that std::variant derives from __sfinae_ctor_base<...> and __sfinae_assign_base<...>, and those base classes are the same for std::variant<A, C> and for std::variant<int>.

This prevents the variant's first field (the __union) from being put at offset 0 within the variant, because that would mean we have two different __sfinae_ctor_base<...> subobjects at the same offset within the same object, and the C++ language rules don't permit that struct layout.

The solution is to change variant so that it doesn't derive from a class that is, or can be, independent of the variant's template arguments. Perhaps either change the __sfinae_... types to use CRTP (even though they don't care what the derived class is), or remove them and rely on getting the special members' properties from the __impl type instead.

Of course, fixing this will break std::variant's ABI, so it'd need to be done only in the unstable ABI. :(

std::optional appears to use the same implementation strategy, so I would imagine it has the same deficiency (assuming it puts the T first, not the bool), but I've not checked. And it looks like std::tuple may also suffer from the same issue.

[zygoloid]

Testcase for the corresponding issue for optional:

#include <optional>

using T = std::optional<char>;
static_assert(sizeof(T) == 2);

using U = std::optional<T>;
static_assert(sizeof(U) == 4);

sizeof(U) ought to be 3 here, but is 4. For optional, this only makes the type larger if the alignment of the inner type is 1, because otherwise there's already padding after the bool member in which the extra __sfinae_... bases can be stored.

(The extra padding use for the empty base is nonetheless visible with wider-aligned types, eg:

#include <optional>

using T = std::optional<int>;
static_assert(sizeof(T) == 8);

using U = std::optional<T>;
static_assert(sizeof(U) == 12);

struct S2 : U {
  char c[2];
};

static_assert(sizeof(S2) == 12);

struct S3 : U {
  char c[3];
};

static_assert(sizeof(S3) == 16);

Here, S3 ought to fit into 12 bytes, because the dsize of U ought to be 9, but is in fact 10 because of the failed EBO, so there are only two available bytes of tail padding.)

[philnik777]

This... sucks. I think the easiest solution would be to use CRTP, since we can make the base class an alias instead and point to the appropriate struct (either passing the deriving type to the actual struct to improve the layout or dropping it to keep the ABI stable).