clang-19 returns true for `__is_literal_type` on union with non trivial member starting with C++-23

[AMS21]

Given the following code

struct non_trivial {
    ~non_trivial();
};

union non_trivial_union {
    int i;
    non_trivial n;
};

static_assert(!__is_literal_type(non_trivial), "");
static_assert(!__is_literal_type(non_trivial_union), "");

clang-18.1.0 compiles fine while clang-19 fails the second static_assert.

godbolt

Note that this does not happen in C++-20 mode godbolt

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: None (AMS21)

Given the following code

struct non_trivial {
    ~non_trivial();
};

union non_trivial_union {
    int i;
    non_trivial n;
};

static_assert(!__is_literal_type(non_trivial), "");
static_assert(!__is_literal_type(non_trivial_union), "");

clang-18.1.0 compiles fine while clang-19 fails the second static_assert.

godbolt

Note that this does not happen in C++-20 mode godbolt

[Sirraide]

This is a bit strange. Afaik a union is literal if it contains at least one literal nsdm (provided there is no other reason for it to be non-literal). It is a bit strange that the result is different in C++23 and C++20 though.

CC @zygoloid @shafik

[AMS21]

Just took another look at my test code and there seems to be a lot of disagreement if this type is literal or not.

gcc before 10.0 says it's always: not literal
gcc since 10.0 says it's literal starting with C++-20
MSVC 2019/2022 say it's literal starting with C++-17

With that and the fact that is_literal_type was removed in C++-20 feel free to close as won't fix.

[frederick-vs-ja]

Seems related to #77753. The implicitly declared destructor of non_trivial_union is non-trivial and deleted. IIUC non_trivial_union becomes a literal type since C++20.

[Sirraide]

With that and the fact that is_literal_type was removed in C++-20 feel free to close as won't fix.

That would explain the discrepancy, yeah. I’d leave the issue open in case I either misread the standard and the type is in fact not supposed to be literal (because we currently think it is, except in C++23 mode, apparently) or in case we do decide to do something about this.

[Fznamznon]

I think it works as expected in C++23 mode. Union with at least one literal member is literal. The fact why it is not considered literal by clang in C++20 mode is the destructor. If a class doesn't have a constexpr destructor then it is not literal. Before C++23 clang takes into account destructors for all members of a class to decide that its destructor is constexpr (i.e. for destructor of a class to be constexpr, destructors of all of its members should be constexpr). I also double checked that union is a class https://eel.is/c++draft/class.union#general-1 , so this all worked for unions in pre C++23 too. non_trivial_union has constexpr destructor only after C++23 since its members don't matter anymore, hence the outcome.

[frederick-vs-ja]

Before C++23 clang takes into account destructors for all members of a class to decide that its destructor is constexpr (i.e. for destructor of a class to be constexpr, destructors of all of its members should be constexpr).

Looks like that we shouldn't do this when the destructor is deleted. IIUC when the destructor is deleted, the constexpr-ness isn't changed in C++23.

[frederick-vs-ja]

I used to think the literality of such a union wouldn't affect conformance in C++20. But the following example will be accepted after necessary changes. The example is already accepted by GCC, and IIUC it's well-formed in C++20.

llvm-project/clang/test/AST/ByteCode/cxx23.cpp

Lines 257 to 286 in fa5a10d

	namespace AnonUnionDtor {
	struct A {
	A ();
	~A();
	};
	template <class T>
	struct opt
	{
	union { // all20-note {{is not literal}}
	char c;
	T data;
	};
	constexpr opt() {}
	constexpr ~opt() {
	if (engaged)
	data.~T();
	}
	bool engaged = false;
	};
	consteval void foo() {
	opt<A> a; // all20-error {{variable of non-literal type}}
	}
	void bar() { foo(); }
	}

So it seems to me that there was actually a conformance bug in C++20 mode.